``` container with the class of ```.card-body```
-
-###### This is how it will look in an html doc
-
-```html
-
-```
-### Header and Footer
---------
-
-The structure of the card can be enhanced by the addition of a header and a footer. To add one of these elements, you have to create a ```
``` container with the ```.card-header``` or ```.card-footer``` class.
-
-###### This is how it will look in an html doc
-
-```html
-
-```
-
-### Cards with Images
------------
-* You may also use specific classes for displaying images in cards.
-
-* There are two classes for this purpose: card-img-top, which places an image on the top of the card, and card-img-bottom, which places the image on the bottom, both of them fitting them to the rounded border of the card neatly.
-
-* These classes have to be used with the ```
``` tag inside a card to work properly.
-
-* Keep in mind, that if you want an image to span the entire width, you would add the image container outside of the ```
``` container with the card-body class.
-
-###### This is how it will look in an html doc
-
-
-```html
-
-
-
-
-
Body content
-
-
-
-
Body content
-
-
-
-```
-
-### Cards Overlay
-----
-* For making an image into the background of the card and displaying the text on top of it you need to use the class card-img-overlay on the content, which you want to display over the image, instead of using the card-body class.
-
-###### This is how it will look in an html doc
-
-```html
-
-
-
-
-
Overlay content
-
-```
diff --git a/client/src/guide/english/bootstrap/fontawesome-icons/index.md b/client/src/guide/english/bootstrap/fontawesome-icons/index.md
deleted file mode 100644
index 7c16792ed0..0000000000
--- a/client/src/guide/english/bootstrap/fontawesome-icons/index.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title: Fontawesome Icons For Bootstrap
----
-## Fontawesome Icons For Bootstrap
-
-Bootstrap (version 4) have dropped Glyphicon icons font in their latest release.
-Fontawesome Icons provide you with over 675 icons, they come in font format.
-
-#### How To Use:
-
-In the `` of your html include a reference to Font Awesome.
-```html
-
-```
-Using fontawesome is same as using Glyphicon.
-
-Simply create `
` or `` tag and apply the CSS Prefix `fa` and the icon's name. A code example has been provided below.
-
-**Code Example:**
-
-``
-
-
-
-`
-#include
-
-int main(void) {
- int arrayDimension,i;
- int* arrayPointer;
-
- scanf("Please insert the array dimension:%d",arrayDimension);
- arrayPointer = (int*)malloc(sizeof(int)*arrayDimension);
-
- if(arrayPointer == NULL){
- printf("Error allocating memory!");
- return -1;
- }
-
- for(i=0;i
-
-int main()
-{
-
- char operator;
- double firstNumber,secondNumber;
-
- printf("Enter an operator (+, -, *, /): ");
- scanf("%c", &operator);
-
- printf("Enter two operands: ");
- scanf("%lf %lf",&firstNumber, &secondNumber);
-
- switch(operator)
- {
- case '+':
- printf("%.1lf + %.1lf = %.1lf",firstNumber, secondNumber, firstNumber+secondNumber);
- break;
-
- case '-':
- printf("%.1lf - %.1lf = %.1lf",firstNumber, secondNumber, firstNumber-secondNumber);
- break;
-
- case '*':
- printf("%.1lf * %.1lf = %.1lf",firstNumber, secondNumber, firstNumber*secondNumber);
- break;
-
- case '/':
- printf("%.1lf / %.1lf = %.1lf",firstNumber, secondNumber, firstNumber/secondNumber);
- break;
-
- // operator is doesn't match any case constant (+, -, *, /)
- default:
- printf("Error! operator is not correct");
- }
-
- return 0;
-}
-```
-### Output
-```
-Enter an operator (+, -, *,): -
-Enter two operands: 32.5
-12.4
-32.5 - 12.4 = 20.1
-```
-The '-' operator entered by the user is stored in operator variable. And, two operands 32.5 and 12.4 are stored in variables firstNumber and secondNumber respectively.
-
-Then, control of the program jumps to
-```
-printf("%.1lf / %.1lf = %.1lf",firstNumber, secondNumber, firstNumber/firstNumber);
-```
-Finally, the break statement ends the switch statement.
-
-If break statement is not used, all cases after the correct case is executed.
diff --git a/client/src/guide/english/c/for/index.md b/client/src/guide/english/c/for/index.md
deleted file mode 100644
index 7e84928fa6..0000000000
--- a/client/src/guide/english/c/for/index.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title: For Loop
----
-
-# For Loop
-
-The `for` loop executes a block of code until a specified condition is false. Use `while` loops when the number of iterations are variable, otherwise use `for` loops. A common use of `for` loops are array iterations.
-
-## Syntax of For Loop
-
-```c
-for ( init; condition; increment ) {
- statement(s);
-}
-```
-
-The `for` loop consists of 3 sections, the initialization section, a specific condition and the incremental or decremental operation section. These 3 sections control the `for` loop.
-
-The initialization statement is executed only once. Then, the test expression is evaluated. If the test expression is false (0), for loop is terminated. But if the test expression is true (nonzero), codes inside the body of for loop is executed and the update expression is updated. This process repeats until the test expression is false.
-
-The for loop is commonly used when the number of iterations is known.
-
-## Example
-```c
-#include
-
-int main () {
-
- int array[] = {1, 2, 3, 4, 5};
-
- for (int i = 0; i < 5; i++) {
- printf("Item on index %d is %d\n", i, array[i]);
- }
-}
-```
-
-## Output:
-```shell
-> Item on index 0 is 1
-> Item on index 1 is 2
-> Item on index 2 is 3
-> Item on index 3 is 4
-```
-
diff --git a/client/src/guide/english/c/functions/index.md b/client/src/guide/english/c/functions/index.md
deleted file mode 100644
index f5c8dfed46..0000000000
--- a/client/src/guide/english/c/functions/index.md
+++ /dev/null
@@ -1,117 +0,0 @@
----
-title: Functions
----
-# Functions in C
-Sometimes you have a chunk of code that you need to use over and over, but at different times and places in your code. You could copy and paste it over and over, but that's not a great solution- your file size ends up being bigger, your code is harder to debug, and your code is harder to read. Instead, use a function: functions are like mini-programs that exist within your code. You can pass them variables to use, and they can give back data.
-## An Example
-Here's a simple example of a function that divides two numbers. It's not very useful since we have `/`, but it shows the different parts of a function.
-```C
-#include
-
-int divides(int a, int b) {
- return a / b;
-}
-
-int main(void) {
- int first = 5;
- int second = 10; //MUST NOT BE ZERO;
-
- int result = divides(first, second);
-
- printf("first divided by second is %i\n", result);
-
- return 0;
-}
-```
-
-Notice that like `main`, `divides` has a similar format. That's because `main` is also a function- it's just special because C looks for it first. `divides` also comes before `main`. This is important because `main` calls `divides`. Calling a function means that its code is being used. Code must be compiled before it gets used, and C compiles line by line from the top, so in order for a function to be called, it must be written out before it is called like in this example. If `divides` came after `main`, it would fail because the compiler doesn't know that `divides` exists yet. You may also use a function prototype before main to allow you to place `divides` after main. A function prototype is identical to the function with the same variables and return type, except they braces are omitted and replaced with a semicolon like so:
-```C
-int divides(int a, int b);
-```
-
-Also notice that `divides` and `main` are not sharing brackets and are not in each other's brackets. They are meant to be separate, even though one calls the other.
-
-With that in mind, let's go over the first line in a function in our next section, titled:
-
-## Breaking down the function declaration
-
-```C
-int divides(int a, int b)
-```
-The function declaration begins with a data type, which in this case is `int`. Whatever data type you want the function to return, you should place here. You can have the return be any data type, or it can be no data type by placing `void` here.
-
-Next is the name of the function. Whenever you want to call the function, this is the name you'll use. Try to make it be something descriptive, so you can easily identify what it does.
-
-After the name comes a pair of parenthesis. In these parenthesis go our function's parameters, which are the variables that this function will take and use when the code runs. In this case, there are two. Both of them are the `int` data type, and they will be named `a` and `b`. Ideally, there would be better names to use here, but you'll find that for simple and quick methods temporary variable names are often used.
-
-Now let's take a look at what's inside the brackets:
-```C
-return a / b;
-```
-This is pretty straightforward, because this is such a simple function. `a` is divided by `b`, and that value is returned. You've seen `return` before in the `main` function, but now instead of ending our program, it ends the method and gives the value to whatever called it.
-
-So to recap what this function does- it gets two integers, divides them, and gives them back to whatever called it.
-
-###Parameters of a function
-Parameters are used to pass arguements to the function.
-Their are two types of parameters:
-Parameter Written In Function Definition is Called “Formal Parameter”.
-Parameter Written In Function Call is Called “Actual Parameter”.They are also known as arguments.They are passed to the function definition and a copy is created in the form of formal parameters.
-
-
-## A more complex example
-That one was a single line function. You'll see them when there's a pretty simple operation that needs to be performed over and over, or an operation that ends up being one long line. By making it a function, the code ends up being more readable and manageable.
-
-That being said, most functions will not be a single line of code. Let's take a look at another, slightly more complex example that chooses the greater of two numbers.
-```C
-int choose_bigger_int(int a, int b) {
- if(a > b)
- return a;
-
- if(b > a)
- return b;
-
- return a;
-}
-```
-Just like before, the function is going to return an integer and takes two integers. Nothing new to see there.
-
-This code starts with an if statement that checks if `a` is greater than `b`. In the event that it is, it will return `a`. If this is done, the function ends here- the rest of the code doesn't get evaluated. If this return statement isn't reached, however, the next if statement will be evaluated. If it is true, `b` will be returned and the function ends here.
-
-With that, the conditions for a being greater than b, and b being greater than a, have been accounted for. However, if a equals b, the function still won't have returned anything. For that reason, we return a (a is equal to b, so we could return either).
-
-## A word on 'scope'
-Scope is a thing to be aware of. It refers to the areas in your code where a variable is accessible. When you pass a variable to a function, the function gets its own copy to use. This means that adjusting the variable in the function will not adjust it anywhere else. Similarly, if you haven't passed a variable to a function, it doesn't have it and can't use it.
-
-You may have observed a similar issue with things like if statements and any of the loops. If you declare a variable within brackets, it won't be accessible outside of those brackets. This is true for functions in the same way, but there are some ways to get around it:
-* Make a global variable by declaring it outside of any functions
- * This makes your code messier and is generally not recommended. It should be avoided whenever possible
-* Use pointers, which you'll read about next
- * This can make your code harder to read and debug
-* Pass into your functions like you're supposed to
- * This is the best way to do it, if doing so is an option
-
-Ideally, you'll always pass into your functions as parameters, but you may not always be able to. Picking the best solution is your job as a programmer.
-
-Recursion in C
-When function is called within the same function, it is known as recursion in C. The function which calls the same function, is known as recursive function.
-```
-int factorial (int n)
-{
- if ( n < 0)
- return -1; /*Wrong value*/
- if (n == 0)
- return 1; /*Terminating condition*/
- return (n * factorial (n -1));
-}
-```
-
-# Before you go on...
-## A review
-* Functions are good to use because they make your code cleaner and easier to debug.
-* Functions need to be declared before they get called.
-* Functions need to have a data type to return- if nothing is getting returned, use `void`.
-* Functions take parameters to work with- if they're taking nothing, use `void`.
-* `return` ends the function and gives back a value. You can have several in one function, but as soon as you hit one the function ends there.
-* When you pass a variable to a function, it has its own copy to use - changing something in a function doesn't change it outside the function.
-* Variables declared inside a function are only visible inside that function, unless they are declared static.
diff --git a/client/src/guide/english/c/index.md b/client/src/guide/english/c/index.md
deleted file mode 100644
index 1f1526604d..0000000000
--- a/client/src/guide/english/c/index.md
+++ /dev/null
@@ -1,123 +0,0 @@
----
-title: C
----
-
-# Hello World! - Your first C Program
-
-## Getting the most out of this course
-Make sure that you're comfortable with all of the concepts in this part of the guide before moving on. Getting your first program running is important because it will allow you to follow along with the examples, which is another good thing to do- practice makes perfect! Concepts that might be confusing will have an annotation that links to an appendix. If you don't understand a concept, make sure that you consult the appendix for more information.
-
-## Course Goal
-The goals of this course are to teach the C language to beginners. Ideally, someone who has never touched a computer language before will be able to know C by following these guides. However, they will still be useful to more experienced programmers by including a summary at the end of each article. Although the content taught here is transferable to microcontrollers like the Arduino, it is not the focus of this guide.
-
-## What is C?
-
-C is a general purpose programming language invented by Dennis Ritchie between 1969 and 1973 at Bell Labs. Since then, it has been used to create things like the Linux Kernel, which allows software to interact with hardware on Linux-based operating systems. It can do this, and other low-level operations, because it was designed to be very close to machine code while still being human-readable. Because of this, it provides direct access to computer memory and hardware. This makes it very useful in hardware and robotics applications where having access to those features quickly is important.
-C, like other low-level languages, requires compilation. The compilation process takes the C code that can be read by a person and turns it into code that can be read and executed by a computer. Compilation requires a compiler, which can either be used from the command line or can be used in an IDE.
-
-If you would prefer to use the command line, consider `gcc`. It can be found by default on GNU+Linux operating systems and on Mac, and is easy to get on Windows. For beginners, however, having an IDE may be more comfortable. Consider CodeBlocks or Xcode if you're interested in being able to write and run code from a GUI.
-
-Now that you have that background, let's start with our 'Hello, World' program. 'Hello, World' is a traditional way of getting started with a language: it shows that we can write code and make it run, so it's a good place to start!
-
-## Hello world in C
-
-```C
-#include
-
-int main(void)
-{
- printf("hello, world\n");
- return 0;
-}
-```
-
-Let's break this program down step-by-step.
-
-First is the `#include`:
-```C
-#include // This is called preprocessor directives
-```
-This is an instruction to the compiler to find and include a set of header files. Header files contain additional code that we can use. In this case, the compiler has been instructed to include ``, which contains all kinds of useful functions like `printf()`. We can also write it as `#include"stdio.h"`. We'll get into detail about what functions are later, but for now just remember that a function is a collection of code that we can use.
-
-```C
-int main(void)
-{
-}
-```
-This code declares the main function. The main function is special- it will always get called and is always the 'main' part of your program. If this isn't in your program, your program can't run and won't compile.
-
-Starting the function declaration with `int` means that this function will give an `int` value when it's done running through its code- it's this function's output. `int` is the 'integer' data type, and integers are whole numbers like -3, 0, or 18. So we know that this code will run, and when it's done, it will give us back an integer. By convention, this integer is 0.
-
-Next is `main`. `main` is the name of this function, and as you learned earlier, it's important to have a `main` function because your program won't work without it. `main` is followed by `(void)`. This tells the compiler that this function doesn't take any parameters, meaning that it has no input.
-
-This might not make a lot of sense right now, but you'll be learning more about this when you start reading about functions in C later. For now, just remember that `main` is required for your C program, it isn't taking any input, and it's giving a number as its output.
-
-Finally, there are the brackets: `{` and `}`. These mark the beginning and end of the function. The open curly bracket (`{`) marks the beginning, and the close curly bracket (`}`) marks the end. Everything between the two is within the function.
-
-Now let's look at the meat of the program:
-
-```C
- printf("Hello, World!\n");
-```
-
-`printf` is a function that takes text and prints it to the screen. The parenthesis indicates what information we want the `printf` function to take and print to the screen. We show that this is a string we want printed by surrounding it in quotes "like this".
-
-Notice the \n found within the quotes- this tells the `printf` function to print a newline. A newline is what gets printed when you hit enter on your keyboard. Without explicitly telling C to print a newline, everything will be printed on the same line.
-
-Finally, the printf() statement is concluded with a semicolon (`;`). This shows that this line of code is over. Without it, the compiler doesn't know where one line ends and another begins, so it's important to include.
-
-The program ends with a return statement:
-```C
-return 0;
-```
-This shows that the function is over and that it should end by giving a value of 0 to whatever made it run. When you're running code on your computer, this is good to have because it allows other programs to interact with yours in a better way.
-
-As before, this line ends with a semicolon to indicate that the line has completed.
-
-## Compilation and Running
-You can save your hello world file as whatever you want, but it needs to end with the .c file extension. In this example, the file has been named "helloworld.c", because that is a clear name with a .c file extension.
-
-There are many ways to compile and get C code running on your computer. Here are a few:
-
-#### Compilation and running from the command line with GCC
-If you're running Mac or GNU+Linux, you've already got GCC installed.
-
-In order to run your C program, it needs to be compiled. In order to compile from the command line using gcc, run the following command from your terminal:
-```shell
-gcc -o helloworld ./helloworld.c
-```
-`gcc` is the Gnu C Compiler, and it will compile the C file we give it into a program that can be run by your computer.
-
-`-o helloworld` tells GCC that you want the compiled file (the output of gcc) to be a file called "helloworld". The final part of the command tells GCC where the C file to be compiled can be found. If you aren't comfortable with navigating from the command line, this step will be hard, but that's okay- it's easy to learn and come back, or you can try from an IDE.
-
-Once you've got it compiled, run the following command:
-```shell
-./helloworld
-```
-
-If everything has gone well, you should see `Hello, World!` printed to the screen.
-
-#### Compilation and running C with CodeBlocks
-Codeblocks can be downloaded from here.
-Make a new program with `file` -> `new` -> `file`, select C/C++ source, select C as your language, and then copy over the helloworld.c text that you read through earlier. Compile and run the code with `Build` -> `Build and Run`.
-
-
-#### Compilation and running C with Xcode
-[Xcode can be downloaded from here.](https://developer.apple.com/xcode/)
-
-#### Compilation and running C with Dev-C++
-Dev-C++ can be downloaded from here.
-Make a new program with `file` -> `new` -> `Source File`, then copy over the helloworld.c text that you read through earlier and then save the file with`file` -> `save As` as hello.c , and Compile and run the code with `Execute` -> `Compile & Run`.
-
-# Before you go on...
-
-## A review
-* C is lingua franca of programming languages.
-* C was used to re-implement the Unix operating system.
-* C is useful because it's small, fast, and has access to low-level operations. Because of this, it gets used a lot in robotics, operating systems, and consumer electronics, but not in things like webpages.
-* A C program has a few critical parts:
- * The include statement, which tells the C compiler where to find additional code that will be used in the program.
- * The main function, which is where the code will first be executed and is required in order to compile.
- * Stuff within that main function which will get executed, including a return statement that closes the program and gives a value to the program that called it.
-* C needs to be compiled in order to run.
-* C can be used to access specific hardware addresses and to perform type punning to match externally imposed interface requirements, with a low run-time demand on system resources.
diff --git a/client/src/guide/english/c/loops/index.md b/client/src/guide/english/c/loops/index.md
deleted file mode 100644
index 8aba300461..0000000000
--- a/client/src/guide/english/c/loops/index.md
+++ /dev/null
@@ -1,619 +0,0 @@
----
-title: Loops of all kinds
----
-# Loops of all kinds in C
-Loops are what you use when you have code that you want to loop, meaning that after it runs, you might want it to loop around to the beginning and run again. There are a few of these in C.
-
-## While loops
-The simplest of the bunch are while loops. While loops will run while the condition within the parenthesis is true. They should be used when you want something to happen until a certain condition takes place.
-
-### Syntax
-```
-while(condition) {
- statement(s);
-}
-```
-
-Here's an example:
-```C
-#include
-
-int main(void) {
- int my_number = 0;
-
- while(my_number != 10){
- ++my_number;
- }
-
- printf("my_number = %i", my_number);
-
- return 0;
-}
-```
-While the statement within the while loop is true, the content within the brackets will be run. When the program hits the `while(my_number)`, it checks the statement within the parenthesis. If that statement is false, it won't run the while loop. Instead, it will skip over the code between the two brackets and will pick up where it left off.
-
-If the statement is true, the code within the brackets will be run. Once the code within the brackets has run, the statement within the parenthesis will be checked again. Just like before, if the statement is true, the code will be run, if it's false, the code will be skipped.
-
-Something that you may run into when playing with this or any other loop is the idea of an infinite loop- a loop that will run an infinite amount of times because there's nothing to stop it. Sometimes this can happen on purpose:
-
-```C
-while(1) {
- printf("This will get printed forever unless the program is stopped!");
-}
-```
-Of course, it can also happen accidentally. Here's the same code as before, but with a subtle difference that turns it into an infinite loop:
-```C
-#include
-
-int main(void) {
- int my_number = 11;
-
- while(my_number != 10){
- ++my_number;
- }
-
- printf("my_number = %i", my_number);
-
- return 0;
-}
-```
-When this while loop is evaluated, `my_number` will be checked to see if it isn't 10. It isn't, because it's been initialized at 11, so the code within the while loop will run and `my_number` will be 12. 12 does not equal 10, so the code within the while loop will be run and `my_number` will be 13. This will keep running forever because this condition will never become false- the only way for it to stop is for the program to be forced to stop running. This is an example of an infinite loop, because if left alone, it will run an infinite amount of times.
-
-## Do-while loops
-Do-while loops are a less commonly used version of a while loop. While loops start with an evaluation, so if that evaluation is false, the code within the brackets will not be run. With a do-while loop, however, the code within the brackets gets run once, then the evaluation is performed to see if it should be run again.
-
-### Syntax
-```
-do {
- statement(s);
-} while( condition );
-```
-
-Here's a look at that:
-```C
-#include
-
-int main(void){
- int a = 0;
-
- do {
- a++
- } while(a == -123);
-
- printf("%i\n", a);
-
- return 0;
-}
-```
-If this were a while loop, the code within the brackets would never get run because this condition isn't true when the evaluation is performed. However, because this is a do-while loop, the code will be performed once, and then the evaluation is done to see if it should be done again. Do-while loops are useful for when you know you want something to be done once, but you may need it to be run additional times after that.
-
-## For loops
-For loops are for when we want something to run a set number of times.
-
-### Syntax
-```
-for(initialisation; condition; changer)
-{
- statement(s);
-}
-```
-
-Here's an example of that:
-```C
-#include
-
-int main(void) {
- int a = 4;
- int b = 2;
- int result = 0;
-
- for(int count = 0; count != b; count++) {
- result = result + a;
- }
-
- printf("a times b is %i\n", result);
-
- return 0;
-}
-```
-Multiplication is just repeated addition, so this is doing addition on `a`, `b` times. Let's a take a look at the `for` bit in particular:
-```C
-for(int count = 0; count != b; count++)
-```
-Unlike the for loop, there are three things in our parenthesis that are separated by semicolons. The first section is for initialization, and is referred to as 'initialization': it allows you to make a new variable and set it a value, or set an existing variable to a different value, or you can not set anything and just put a semicolon down.
-
-The next section is a boolean condition that will be checked for true or false, just like our while loop. It's referred to as a 'condition', because it's the condition that will get checked before starting a loop.
-
-The final section is referred to as the 'increment/decrement'. Its job is to perform some operation every loop - usually adding or subtracting from the initial variable - after the code within the brackets has been run through. In this case, it's just adding one to the count. This is the most common way for the increment to be used, because it lets you keep count of how many times you've run through a for loop.
-
-### Syntax Comparison
-```
-
-main()
-{
- int i = 1;
- while(i<=5)
- {
- printf(“While”);
- i++;
- }
- getch();
-}
-
-
-main()
-{
- int i = 1;
- do
- {
- printf(“do-while”);
- i++;
- } while(i<=5);
- getch();
-
-}
-
-
-main()
-{
- int i
- for(i=1;i<=5;i++)
- {
- printf(“for”);
- }
- getch();
-}
-```
-
-
-# Loop Control Statements
-Loop control statements change execution form its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.
-
-C supports the following control statements:
-
-#### 1. Break statement
-Terminates the loop or switch statement and transfers execution to the statement immediately following the loop or switch.
-
-#### 2. Continue statement
-Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.
-
-#### 3. Goto statement
-Transfers control to the labeled statement.
-
-# Some Fun and Useful Quirks
-
-## Infinite looping with for loops
-Take a moment to consider what this code will do:
-```C
-for(;;){
- printf("hello, world! \n");
-}
-
-while("Free Code Camp"){
- printf("hello, world! \n");
-}
-```
-There's nothing in the initialization section, so nothing has been initialized. That's fine, and that is done sometimes because you don't always want or need to initialize anything.
-
-Next is the condition, which is blank. That's a little odd. This means that no condition will be tested, so it's never going to be false, so it will run through the loop, perform the afterthought (which is to do nothing), and then check the condition again, which will make it run again. As you've probably realized, this is an infinite loop. As it turns out, this is actually useful. When creating performing an infinite loop, the method of doing `while(1)` is perfectly legitimate, but performs a comparison every time. `for(;;)`, on the other hand, does not. For that reason, `for(;;)` has a legitimate use in that it is a hair more efficient than other methods of infinite looping. Thankfully, many compilers will take care of this for you.
-
-The loop in second code while("Free Code Camp") will also execute infinitely.The reason is because C considers any non-zero value as true and hence will execute the loop infinitely.
-
-## Not using brackets
-Throughout this page, you've read that the code 'within the brackets' is what gets run, and that's mostly true. However, what if there are no brackets?
-```C
-while(true)
- printf("hello, world! \n");
-```
-In cases like this, C will treat the next line as the only content that needs to be looped. C ignores whitespace, so that indent is just there for clarity. Only that one line will be treated as though it is in the loop, and this is a property that if statements, for loops, and while loops all share. Because the whitespace is ignored, the placement doesn't matter: it could be on the same line, the next line, or 300 lines and two spaces down as long as there's no other lines of code in between. This feature can make your code look a bit cleaner when you only have one line of code to run in a statement.
-
-## Semicolons instead of brackets
-If there are no brackets, the compiler will look only at the next line and have that be the content of the loop. Semicolons tell the compiler that a line is over. With these things combined, we can have C wait until something becomes true. Let's say we have a method called `is_button_pressed` that returns false if a button is not pressed, and true if a button is pressed:
-```C
-while(!is_button_pressed());
-```
-Nothing happens in this loop, because the only line it will look at is a semicolon. As a result, the `is_button_pressed` method will be called, and its return value will be evaluated. If the button is not pressed and the return value is false, the `!` will flip it to true so the function is run again and evaluated again. If the return value is true, the `!` will flip it to false and the while loop will be exited.
-
-This has the effect of putting a pause in your code. In this case, the code reached the while loop, and didn't go any further. Instead, it kept checking for the status of the button to change. This would be useful for when you want nothing to happen until a certain condition has been met.
-
-# Before you go on...
-## A review
-* Loops allow your code to be run more than once, when certain conditions are met.
-* There are a couple of loops available to us in C:
- * While loops, which allow us to run code while a condition is true
- * Do-while loops, which run code and then continue running it if a condition is true
- * For loops, which run code while a condition is true and allow us to perform an operation every loop.
-
-
-## Using loops for designing patterns.
-#### Example 1: Program to print half pyramid using *
-
-```
-*
-* *
-* * *
-* * * *
-* * * * *
-```
-
-**Source Code**
-
-```c
-#include
-
-int main()
-{
- int i, j, rows;
-
- printf("Enter number of rows: ");
- scanf("%d",&rows);
-
- for(i=1; i<=rows; ++i)
- {
- for(j=1; j<=i; ++j)
- {
- printf("* ");
- }
- printf("\n");
- }
- return 0;
-}
-```
-
-#### Example 2: Program to print half pyramid a using numbers
-
-```
-1
-1 2
-1 2 3
-1 2 3 4
-1 2 3 4 5
-```
-
-
-**Source Code**
-
-```c
-#include
-
-int main()
-{
- int i, j, rows;
-
- printf("Enter number of rows: ");
- scanf("%d",&rows);
-
- for(i=1; i<=rows; ++i)
- {
- for(j=1; j<=i; ++j)
- {
- printf("%d ",j);
- }
- printf("\n");
- }
- return 0;
-}
-```
-
-#### Example 3: Program to print half pyramid using alphabets
-
-```
-A
-B B
-C C C
-D D D D
-E E E E E
-```
-
-**Source Code**
-
-```c
-#include
-
-int main()
-{
- int i, j;
- char input, alphabet = 'A';
-
- printf("Enter the uppercase character you want to print in last row: ");
- scanf("%c",&input);
-
- for(i=1; i <= (input-'A'+1); ++i)
- {
- for(j=1;j<=i;++j)
- {
- printf("%c", alphabet);
- }
- ++alphabet;
-
- printf("\n");
- }
- return 0;
-}
-```
-
-Programs to print inverted half pyramid using * and numbers
-
-#### Example 4: Inverted half pyramid using *
-
-```
-* * * * *
-* * * *
-* * *
-* *
-*
-```
-
-**Source Code**
-
-```c
-#include
-
-int main()
-{
- int i, j, rows;
-
- printf("Enter number of rows: ");
- scanf("%d",&rows);
-
- for(i=rows; i>=1; --i)
- {
- for(j=1; j<=i; ++j)
- {
- printf("* ");
- }
- printf("\n");
- }
-
- return 0;
-}
-```
-
-#### Example 5: Inverted half pyramid using numbers
-
-```
-1 2 3 4 5
-1 2 3 4
-1 2 3
-1 2
-1
-```
-
-**Source Code**
-
-```c
-#include
-
-int main()
-{
- int i, j, rows;
-
- printf("Enter number of rows: ");
- scanf("%d",&rows);
-
- for(i=rows; i>=1; --i)
- {
- for(j=1; j<=i; ++j)
- {
- printf("%d ",j);
- }
- printf("\n");
- }
-
- return 0;
-}
-```
-
-#### Example 6: Program to print full pyramid using *
-
-```
- *
- * * *
- * * * * *
- * * * * * * *
-* * * * * * * * *
-```
-
-**Source Code**
-
-```c
-#include
-
-int main()
-{
- int i, space, rows, k=0;
-
- printf("Enter number of rows: ");
- scanf("%d",&rows);
-
- for(i=1; i<=rows; ++i, k=0)
- {
- for(space=1; space<=rows-i; ++space)
- {
- printf(" ");
- }
-
- while(k != 2*i-1)
- {
- printf("* ");
- ++k;
- }
-
- printf("\n");
- }
-
- return 0;
-}
-```
-
-#### Example 7: Program to print pyramid using numbers
-
-```
- 1
- 2 3 2
- 3 4 5 4 3
- 4 5 6 7 6 5 4
-5 6 7 8 9 8 7 6 5
-```
-
-**Source Code**
-
-```c
-#include
-
-int main()
-{
- int i, space, rows, k=0, count = 0, count1 = 0;
-
- printf("Enter number of rows: ");
- scanf("%d",&rows);
-
- for(i=1; i<=rows; ++i)
- {
- for(space=1; space <= rows-i; ++space)
- {
- printf(" ");
- ++count;
- }
-
- while(k != 2*i-1)
- {
- if (count <= rows-1)
- {
- printf("%d ", i+k);
- ++count;
- }
- else
- {
- ++count1;
- printf("%d ", (i+k-2*count1));
- }
- ++k;
- }
- count1 = count = k = 0;
-
- printf("\n");
- }
- return 0;
-}
-```
-
-#### Example 8: Inverted full pyramid using *
-
-```
-* * * * * * * * *
- * * * * * * *
- * * * * *
- * * *
- *
-```
-
-**Source Code**
-
-```c
-#include
-
-int main()
-{
- int rows, i, j, space;
-
- printf("Enter number of rows: ");
- scanf("%d",&rows);
-
- for(i=rows; i>=1; --i)
- {
- for(space=0; space < rows-i; ++space)
- printf(" ");
-
- for(j=i; j <= 2*i-1; ++j)
- printf("* ");
-
- for(j=0; j < i-1; ++j)
- printf("* ");
-
- printf("\n");
- }
-
- return 0;
-}
-```
-
-#### Example 9: Print Pascal's triangle
-
-```
- 1
- 1 1
- 1 2 1
- 1 3 3 1
- 1 4 6 4 1
- 1 5 10 10 5 1
-```
-
-**Source Code**
-
-```c
-#include
-
-int main()
-{
- int rows, coef = 1, space, i, j;
-
- printf("Enter number of rows: ");
- scanf("%d",&rows);
-
- for(i=0; i
-
-int main()
-{
- int rows, i, j, number= 1;
-
- printf("Enter number of rows: ");
- scanf("%d",&rows);
-
- for(i=1; i <= rows; i++)
- {
- for(j=1; j <= i; ++j)
- {
- printf("%d ", number);
- ++number;
- }
-
- printf("\n");
- }
-
- return 0;
-}
-```
diff --git a/client/src/guide/english/c/math/index.md b/client/src/guide/english/c/math/index.md
deleted file mode 100644
index 336258ff02..0000000000
--- a/client/src/guide/english/c/math/index.md
+++ /dev/null
@@ -1,156 +0,0 @@
----
-title: Basic Math
----
-# Math in C
-C provides a lot of options for doing math. We'll start with some of the more common ones first.
-
-## The basic stuff
-These following examples aren't complete code, they're just examples of what a piece of code looks like. Remember that in C, we'll need to have everything declared before we're using it- `result`, `a`, and `b` will need to have already been initialized and set to a value. Whether they are `int`, `double`, or whatever is important to prevent errors and loss of information- we'll get to that later.
-
-#### Addition: `+`
-Addition is performed with a `+`, like so:
-```C
-result = a + b;
-```
-In the above example, the variable `result` will be equal to a + b.
-
-#### Subtraction: `-`
-Addition is performed with a `-`, like so:
-```C
-result = a - b;
-```
-In the above example, the variable `result` will be equal to a - b.
-
-#### Multiplication: `*`
-Multiplication is performed with a `*`, like so:
-```C
-result = a * b;
-```
-In the above example, the variable `result` will be equal to a multiplied by b.
-
-#### Division: `/`
-Division is performed with a `/`, like so:
-```C
-result = a / b;
-```
-In the above example, the variable `result` will be equal to a divided by b. This is not always a fraction of a over b, however. When dealing with integers, things get a little different- more on that later.
-
-# The not-so-basic stuff
-## Modulo: '%'
-Okay, now things start getting a little weird.
-
-Modulo allows you to find the remainder in division. Remember that with integers, we can't have a decimal. Division is about finding how many times one number will fit into another, modulo is about finding what's left over. Take 27 divided by 4: 4 fits into 27 6 times. 6 times 4 is 24, which means there is 3 left over. As a result, 27%4 is 3. 10 divided by 5 is 2, 2 times 5 is 10, so there is 0 left over. As a result, 10%5 is 0.
-
-The modulo operator is more important than you may think, especially in C where the difference between floating point and integer numbers is enforced. It's worth being comfortable with. Here's an example:
-```C
-result = a % b;
-```
-In the above example, `result` will be equal to a modulo b.
-
-## Integers and math
-Integers can't have decimals. As a result, when you perform division with integers, any sort of decimal will be truncated. For example, 17 divided by 10 is 1.7. However, if we're only dealing with integers, that result will be 1, not 1.7. 10 fits into 17 1 time, so the answer is 1.
-
-When dealing with floating point numbers, this isn't an issue. Floating point numbers can take decimal places, so we don't have to worry about things getting truncated.
-
-### Why does C do this?
-C, as discussed earlier, is a low-level language. There are big differences between floating point and integer numbers in the hardware of a computer, and they require that certain data types have certain properties (like not accepting decimals, for example). C makes no assumptions as to what you want, and forces you to think about it yourself.
-
-### Why don't we just use floating point numbers all the time?
-This also comes down to C being a low-level language. C is much, much faster and much, much lighter than many other languages, and one of the reasons it is this way because of the programmer being able to make intelligent decisions about data types. Remember that floating point numbers take up a lot more memory than integers. As a result, it's important to use the appropriate data type, and deal with integer to floating point conversions whenever needed.
-
-### How do we get around this?
-Casting (described later) is one solution. The other is using floating point numbers. If one or both of the numbers being operated on are a floating point number, the result will be a floating point number. This becomes more complex when we start dealing with order of operations, but for now, be aware that this works:
-```C
-double result = 23.0 / 2;
-
-```
-
-# A full example
-```C
-#include
-
-// This is a comment. It gets ignored by the compiler, so we can write notes after the double slashes.
-
-int main(void) {
- int a = 3;
- int b = 5;
- int result = 0;
-
- // Doing things with variables:
- result = a + b;
- printf("a plus b = %i \n", result);
-
- // You can also do the operation inside the printf.
- // Here's an example of that with subtraction:
- printf("a minus b = %i \n", a-b);
-
- // You don't need to do this with variables at all.
- // Here's an example of that with multiplication:
- printf("10 times 5 = %i \n", 10*5);
-
- // Here's a look at division.
- // Notice that the decimals are truncated because we're dealing with integers.
- printf("12 divided by 5 = %i \n", 12/5);
-
- // Now let's force floating point numbers by including a decimal.
- // Notice that even though these are integers, the decimal forces them to be
- // treated as floating point numbers, so they aren't truncated.
- // Note that I'm printing a double with %d, not an int with %i.
- printf("12.0 divided by 5 = %d \n", 12.0/5);
-
- return 0;
-}
-```
-Give that a run to see what happens, and be sure to play with the operators and values to see what and how things change.
-
-# Math library
-C provides a math library (`math.h`) that provides multiple useful math functions. As an example, the power of a number can be calculated as:
-
-```#include
-int result = pow(2,3) // will result in 2*2*2 or 8
-```
-
-Some other (`math.h`) library functions that may prove useful are:
-
-```#include
-double angle = cos(90.00); // Givs us 0.00
-int result = sqrt(16); // Gives us 4
-double result = log(10.00) // Gives us 2.30 (note this is ln(10), not log base 10)
-```
-
-// C code to illustrate
-// the use of ceil function.
-#include
-#include
-
-int main ()
-{
-float val1, val2, val3, val4;
-
-val1 = 1.6;
-val2 = 1.2;
-val3 = -2.8;
-val4 = -2.3;
-
-printf ("value1 = %.1lf\n", ceil(val1));
-printf ("value2 = %.1lf\n", ceil(val2));
-printf ("value3 = %.1lf\n", ceil(val3));
-printf ("value4 = %.1lf\n", ceil(val4));
-
-return(0);
-}
-
-# Before you go on...
-## A review
-* There are several basic operators:
- * `+` for addition
- * `-` for subtraction
- * `*` for multiplication
- * `/` for division
- * `%` for modulo
- * There are also a bunch more operators, but we'll get into detail with them later.
-* Integer math is a thing that C is pretty strict about.
-* C is very strict about data types
-* If only integers are involved, an integer will be returned
-* If a floating point number is involved in an operation, that part of the operation becomes floating point
-* C provides a `math.h` library with multiple functions like `pow` for calculating the power of a number.
diff --git a/client/src/guide/english/c/pointers/index.md b/client/src/guide/english/c/pointers/index.md
deleted file mode 100644
index 25b51b9a70..0000000000
--- a/client/src/guide/english/c/pointers/index.md
+++ /dev/null
@@ -1,285 +0,0 @@
----
-title: Pointers
----
-# Pointers in C
-By now you should be aware that C is a low-level language, and nothing shows that better than pointers. Pointers are variables that get you the variable value by "pointing" to a memory location rather than storing the value of the variable itself. This allows for some handy tricks, and is also what gives us access to arrays and file handling, among other things.
-
-#
-```
-type *var-name;
-```
-
-## Making and Using a Pointer
-```c
-#include
-
-int main(void){
- double my_double_variable = 10.1;
- double *my_pointer;
-
- my_pointer = &my_double_variable;
-
- printf("value of my_double_variable: %f\n", my_double_variable);
-
- ++my_double_variable;
-
- printf("value of my_pointer: %f\n", *my_pointer);
-
- return 0;
-}
-```
-Output:
-```
-value of my_double_variable: 10.100000
-value of my_pointer: 11.100000
-```
-
-In this code, there are two declarations. The first is a typical variable initialization which creates a `double` and sets it equal to 10.1. New in our declarations is the usage of `*`. The asterisk (`*`) is usually used for multiplication, but when we use it by placing it in front of a variable it tells C that this is a pointer variable.
-
-The next line tells the compiler where that somewhere else actually is. By using `&` in this way, it becomes the 'dereferencing operator', and returns the memory location of the variable it's looking at.
-
-With that in mind, let's take another look at this chunk of code:
-```c
-double *my_pointer;
-// my_pointer now stored the address of my_double_variable
-my_pointer = &my_double_variable;
-```
-`my_pointer` has been declared, and it's been declared as a pointer. The C compiler now knows that `my_pointer` is going to point to a memory location. The next line assigns `my_pointer` a memory location value using the `&`.
-
-Now let's take a look what referring to a memory location means for your code:
-```c
- printf("value of my_double_variable: %f\n", my_double_variable);
-
- // Same as my_double_variable = my_double_variable + 1
- // In human language, adding one to my_double_variable
- ++my_double_variable;
-
- printf("value of my_pointer: %f\n", *my_pointer);
-```
-Notice that in order to get the value of the data at `*my_pointer`, you'll need to tell C that you want to get the value the variable is pointing at. Try running this code without that asterisk, and you'll be able to print the memory location, because that's what the `my_variable` variable is actually holding.
-
-You can declare multiple pointer in a single statement as with standard variables, like so:
-```c
-int *x, *y;
-```
-Notice that the `*` is required before each variable. This is because being a pointer is considered as part of the variable and not part of the datatype.
-
-## Practical Uses of Pointers
-### Arrays
-The most common application of a pointer is in an array. Arrays, which you'll read about later, allow for a group of variables. You don't actually have to deal with `*` and `&` to use arrays, but that's what they're doing behind the scenes.
-
-### Functions
-Sometimes you want to adjust the value of a variable inside of a function, but if you simply pass in your variable by-value, the function will work with a copy of your variable instead of the variable itself. If, instead, you pass in the pointer pointing to the memory location of the variable, you can access and modify it from outside of its normal scope. This is because you are touching the original memory location itself, allowing you to adjust something in a function and having it make changes elsewhere. In contrast to "call by value", this is called "call by reference".
-
-The following program swaps the values of two variables inside of the dedicated `swap` function. To achieve that, the variables are passed in by reference.
-
-```c
- /* C Program to swap two numbers using pointers and function. */
-#include
-void swap(int *n1, int *n2);
-
-int main()
-{
- int num1 = 5, num2 = 10;
-
- // address of num1 and num2 is passed to the swap function
- swap( &num1, &num2);
- printf("Number1 = %d\n", num1);
- printf("Number2 = %d", num2);
- return 0;
-}
-
-void swap(int * n1, int * n2)
-{
- // pointer n1 and n2 points to the address of num1 and num2 respectively
- int temp;
- temp = *n1;
- *n1 = *n2;
- *n2 = temp;
-}
-```
-
-Output
-```
-Number1 = 10
-Number2 = 5
-
-```
-The addresses, or memory locations, of `num1` and `num2` are passed to the function `swap` and are represented by the pointers `*n1` and `*n2` inside of the function. So, now the pointers `n1` and `n2` point to the addresses of `num1` and `num2` respectively.
-
-So, now the pointer n1 and n2 points to the address of num1 and num2 respectively.
-
-When, the value of pointers are changed, the value in the pointed memory location also changes correspondingly.
-
-Hence, changes made to *n1 and *n2 are reflected in num1 and num2 in the main function.
-
-
-### POINTERS AS PARAMETERS TO FUNCTION
-when we pass any parameter to function we are making a copy of the parameter. let see with the example
-```C
-#include
-
-void func(int);
-
-int main(void) {
- int a = 11;
- func(a);
- printf("%d",a);// print 11
-
-
- return 0;
-}
-void func(int a){
- a=5
- printf("%d",a);//print 5
-}
-```
-In the example above we are changinging the value of integer a in function func, but we still geting 11 in the main function. This happens because in the function copy of integer a has passed as parameter, so in this function we have not access to the 'a' which is in main function.
-
-So how could you change the value of integer defined in main , by using another function? Here POINTERS comes in to role.
-when we supply pointer as a parameter , we have access to address of that parameter and we could to any thig with this parameter and result will be shown everywhere.
-Below is an example which does exactly the same thing we want...
-
-By dereferencing `n1` and `n2`, we now can modify the memory to which `n1` and `n2` point. This allows us to change the value of the two variables `num1` and `num2` declared in the `main` function outside of their normal scope. After the function is done, the two variables now have swapped their values, as can be seen in the output.
-
-### Tricks with Memory Locations
-Whenever it can be avoided, it's a good idea to keep your code easy to read and understand. In the best case scenario, your code will tell a story- it will have easy to read variable names and make sense if you read it out loud, and you'll use the occasional comment to clarify what a line of code does.
-
-Because of that, you should be careful when using pointers. It's easy to make something confusing for you to debug or for someone else to read. However, it is possible to do some pretty neat things with them.
-
-Take a look at this code, which turns something from uppercase to lowercase:
-```c
-#include
-#include
-
-char *lowerCase (char *string) {
- char *p = string;
- while (*p) {
- if (isupper(*p)) *p = tolower(*p);
- p++;
- }
- return string;
-}
-```
-This starts by taking a string (something you'll learn about when you get into arrays) and runs through each location. Notice the p++. This increments the pointer, which means that it is looking at the next memory location. Each letter is a memory location, so in this way the pointer is looking at every letter and deciding what to do for each one.
-
-### Const Qualifer
-The qualifier const can be applied to the declaration of any variable to specify that its value will not be changed ( Which depends upon where const variables are stored, we may change value of const variable by using pointer ).
-
-# Pointer to variable
-We can change the value of ptr and we can also change the value of object ptr pointing to.
-Following code fragment explains pointer to variable
-```c
-#include
-int main(void)
-{
- int i = 10;
- int j = 20;
- int *ptr = &i; /* pointer to integer */
- printf("*ptr: %d\n", *ptr);
-
- /* pointer is pointing to another variable */
- ptr = &j;
- printf("*ptr: %d\n", *ptr);
-
- /* we can change value stored by pointer */
- *ptr = 100;
- printf("*ptr: %d\n", *ptr);
-
- return 0;
-}
-```
-# Pointer to constant
-We can change pointer to point to any other integer variable, but cannot change value of object (entity) pointed using pointer ptr.
-```c
-#include
-int main(void)
-{
- int i = 10;
- int j = 20;
- const int *ptr = &i; /* ptr is pointer to constant */
-
- printf("ptr: %d\n", *ptr);
- *ptr = 100; /* error: object pointed cannot be modified
- using the pointer ptr */
-
- ptr = &j; /* valid */
- printf("ptr: %d\n", *ptr);
-
- return 0;
-}
-```
-# Constant pointer to variable
-In this we can change the value of the variable the pointer is pointing to. But we can't change the pointer to point to
-another variable.
-```c
-#include
-int main(void)
-{
- int i = 10;
- int j = 20;
- int *const ptr = &i; /* constant pointer to integer */
-
- printf("ptr: %d\n", *ptr);
-
- *ptr = 100; /* valid */
- printf("ptr: %d\n", *ptr);
-
- ptr = &j; /* error */
- return 0;
-}
-```
-# constant pointer to constant
-Above declaration is constant pointer to constant variable which means we cannot change value pointed by pointer as well as we cannot point the pointer to other variable.
-```c
-#include
-
-int main(void)
-{
- int i = 10;
- int j = 20;
- const int *const ptr = &i; /* constant pointer to constant integer */
-
- printf("ptr: %d\n", *ptr);
-
- ptr = &j; /* error */
- *ptr = 100; /* error */
-
- return 0;
-}
-```
-
-# Before you go on...
-## A review
-* Pointers are variables, but instead of storing a value, they store a memory location.
-* `*` and `&` are used to access values at memory locations and to access memory locations, respectively.
-* Pointers are useful for some of the underlying features of C.
-
-#Pointer vs Array in C
-Most of the time, pointer and array accesses can be treated as acting the same, the major exceptions being:
-
-1) the sizeof operator
-* `sizeof(array)` returns the amount of memory used by all elements in array
-* `sizeof(pointer)` only returns the amount of memory used by the pointer variable itself
-
-2) the & operator
-* &array is an alias for &array[0] and returns the address of the first element in array
-* &pointer returns the address of pointer
-
-3) a string literal initialization of a character array
-* `char array[] = “abc”` sets the first four elements in array to ‘a’, ‘b’, ‘c’, and ‘\0’
-* `char *pointer = “abc”` sets pointer to the address of the “abc” string (which may be stored in read-only memory and thus unchangeable)
-
-4) Pointer variable can be assigned a value whereas array variable cannot be.
-```c
- int a[10];
- int *p;
- p = a; /*legal*/
- a = p; /*illegal*/
-```
-5) Arithmetic on pointer variable is allowed.
-```c
- p++; /*Legal*/
- a++; /*illegal*/
-```
-
diff --git a/client/src/guide/english/certifications/coding-interview-prep/data-structures/create-a-queue-class/index.md b/client/src/guide/english/certifications/coding-interview-prep/data-structures/create-a-queue-class/index.md
deleted file mode 100644
index 703918a9d2..0000000000
--- a/client/src/guide/english/certifications/coding-interview-prep/data-structures/create-a-queue-class/index.md
+++ /dev/null
@@ -1,80 +0,0 @@
----
-title: Create a Queue Class
----
-## Create a Queue Class
-
-
-### Method:
-- A Queue is an abstract Data Structure.
-- A Queue folow FIFO/LILO principle.
-- In this challenge we nede to implement `enqueue()`, `dequeue()`, `front()`, `size()`, `isEmpty()` methods.
- - `enqueue()` - This method adds the element to the queue.
- - `dequeue()` - This method removes the first element from the queue.
- - `front()` - This method returns the first element in the queue that'd be dequeue'd.
- - `size()` - This method returns the size of the queue.
- - `isEmpty()` - This method returns if the queue is empty.
--
- | DS | Access | Search | Insert | Delete |
- | ----- | ------ | ------ | ------ | ------ |
- | Queue | n | n | 1 | 1 |
-
- - 
-
-### Solution:
-
-#### Basic:
-##### Note:
-- This solution is not exactly a queue, the shift() method used in the dequeue() method is of complexity `O(n)` and not `O(1)`. However, the advanced solution rectifies this and uses Object(HashTables) instead of Array to implement Queue.
-```js
-function Queue () {
- var collection = [];
- this.print = function() {
- console.log(collection);
- };
- this.enqueue = function(val){
- collection.push(val);
- };
- this.dequeue = function(){
- return collection.shift();
- }
- this.front = function(){
- return collection[0];
- }
- this.size = function(){
- return collection.length;
- }
- this.isEmpty = function(){
- return collection.length === 0;
- }
-}
-```
-#### Advanced - ES6 class syntax:
-```js
-class Queue {
- constructor(){
- this.collection = {};
- this.start = 0;
- this.end = 0;
- }
- print(){
- console.log(this.collection);
- }
- enqueue(val){
- this.collection[this.end++] = val;
- }
- dequeue(){
- return this.collection[this.start++];
- }
- front(){
- return this.collection[this.start];
- }
- size(){
- return this.end - this.start;
- }
- isEmpty(){
- return this.size() === 0;
- }
-}
-```
-### References:
-- [Wikipedia](https://en.wikipedia.org/wiki/Queue_(abstract_data_type))
diff --git a/client/src/guide/english/certifications/coding-interview-prep/project-euler/problem-8-largest-product-in-a-series/index.md b/client/src/guide/english/certifications/coding-interview-prep/project-euler/problem-8-largest-product-in-a-series/index.md
deleted file mode 100644
index 148e790b9c..0000000000
--- a/client/src/guide/english/certifications/coding-interview-prep/project-euler/problem-8-largest-product-in-a-series/index.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: Largest product in a series
----
-## Problem 8: Largest product in a series
-
-### Method:
-
-- In this challenge we need to get the largest product of `n` cosnecutive numbers.
-- We can use the sliding window method to solve this problem.
-- Steps to follow:
- 1. Select the first n consecutive numbers.
- 2. Find their product.
- 3. Compare it to the maximum product yet.
- 4. Move the pointer by 1 element.
- 5. Repeat the process.
- - This algorithm's big O is **O(n\*m)** where n is the length of the array and m is the number of consecutive elements.
-### Solution:
-```js
-function largestProductinaSeries(n) {
- let thousandDigits = [7,3,1,6,7,1,7,6,5,3,1,3,3,0,6,2,4,9,1,9,2,2,5,1,1,9,6,7,4,4,2,6,5,7,4,7,4,2,3,5,5,3,4,9,1,9,4,9,3,4,9,6,9,8,3,5,2,0,3,1,2,7,7,4,5,0,6,3,2,6,2,3,9,5,7,8,3,1,8,0,1,6,9,8,4,8,0,1,8,6,9,4,7,8,8,5,1,8,4,3,8,5,8,6,1,5,6,0,7,8,9,1,1,2,9,4,9,4,9,5,4,5,9,5,0,1,7,3,7,9,5,8,3,3,1,9,5,2,8,5,3,2,0,8,8,0,5,5,1,1,1,2,5,4,0,6,9,8,7,4,7,1,5,8,5,2,3,8,6,3,0,5,0,7,1,5,6,9,3,2,9,0,9,6,3,2,9,5,2,2,7,4,4,3,0,4,3,5,5,7,6,6,8,9,6,6,4,8,9,5,0,4,4,5,2,4,4,5,2,3,1,6,1,7,3,1,8,5,6,4,0,3,0,9,8,7,1,1,1,2,1,7,2,2,3,8,3,1,1,3,6,2,2,2,9,8,9,3,4,2,3,3,8,0,3,0,8,1,3,5,3,3,6,2,7,6,6,1,4,2,8,2,8,0,6,4,4,4,4,8,6,6,4,5,2,3,8,7,4,9,3,0,3,5,8,9,0,7,2,9,6,2,9,0,4,9,1,5,6,0,4,4,0,7,7,2,3,9,0,7,1,3,8,1,0,5,1,5,8,5,9,3,0,7,9,6,0,8,6,6,7,0,1,7,2,4,2,7,1,2,1,8,8,3,9,9,8,7,9,7,9,0,8,7,9,2,2,7,4,9,2,1,9,0,1,6,9,9,7,2,0,8,8,8,0,9,3,7,7,6,6,5,7,2,7,3,3,3,0,0,1,0,5,3,3,6,7,8,8,1,2,2,0,2,3,5,4,2,1,8,0,9,7,5,1,2,5,4,5,4,0,5,9,4,7,5,2,2,4,3,5,2,5,8,4,9,0,7,7,1,1,6,7,0,5,5,6,0,1,3,6,0,4,8,3,9,5,8,6,4,4,6,7,0,6,3,2,4,4,1,5,7,2,2,1,5,5,3,9,7,5,3,6,9,7,8,1,7,9,7,7,8,4,6,1,7,4,0,6,4,9,5,5,1,4,9,2,9,0,8,6,2,5,6,9,3,2,1,9,7,8,4,6,8,6,2,2,4,8,2,8,3,9,7,2,2,4,1,3,7,5,6,5,7,0,5,6,0,5,7,4,9,0,2,6,1,4,0,7,9,7,2,9,6,8,6,5,2,4,1,4,5,3,5,1,0,0,4,7,4,8,2,1,6,6,3,7,0,4,8,4,4,0,3,1,9,9,8,9,0,0,0,8,8,9,5,2,4,3,4,5,0,6,5,8,5,4,1,2,2,7,5,8,8,6,6,6,8,8,1,1,6,4,2,7,1,7,1,4,7,9,9,2,4,4,4,2,9,2,8,2,3,0,8,6,3,4,6,5,6,7,4,8,1,3,9,1,9,1,2,3,1,6,2,8,2,4,5,8,6,1,7,8,6,6,4,5,8,3,5,9,1,2,4,5,6,6,5,2,9,4,7,6,5,4,5,6,8,2,8,4,8,9,1,2,8,8,3,1,4,2,6,0,7,6,9,0,0,4,2,2,4,2,1,9,0,2,2,6,7,1,0,5,5,6,2,6,3,2,1,1,1,1,1,0,9,3,7,0,5,4,4,2,1,7,5,0,6,9,4,1,6,5,8,9,6,0,4,0,8,0,7,1,9,8,4,0,3,8,5,0,9,6,2,4,5,5,4,4,4,3,6,2,9,8,1,2,3,0,9,8,7,8,7,9,9,2,7,2,4,4,2,8,4,9,0,9,1,8,8,8,4,5,8,0,1,5,6,1,6,6,0,9,7,9,1,9,1,3,3,8,7,5,4,9,9,2,0,0,5,2,4,0,6,3,6,8,9,9,1,2,5,6,0,7,1,7,6,0,6,0,5,8,8,6,1,1,6,4,6,7,1,0,9,4,0,5,0,7,7,5,4,1,0,0,2,2,5,6,9,8,3,1,5,5,2,0,0,0,5,5,9,3,5,7,2,9,7,2,5,7,1,6,3,6,2,6,9,5,6,1,8,8,2,6,7,0,4,2,8,2,5,2,4,8,3,6,0,0,8,2,3,2,5,7,5,3,0,4,2,0,7,5,2,9,6,3,4,5,0];
-
- let len = n;
- let prod = 1, max = 1;
- while (len < thousandDigits.length){
- prod = 1;
-
- //Looping and computing products of n numbers
- for (let i = len-n; i < len; i++){
- prod*= thousandDigits[i];
- }
- if (prod > max) max = prod;
- len++;
- }
- return max;
-}
-
-console.log(largestProductinaSeries(13));
-```
-- [Run Code](https://repl.it/@ezioda004/Project-Euler-Problem-8-Largest-product-in-a-series)
-
-### References:
-
-- [Sliding Window Technique](https://www.geeksforgeeks.org/window-sliding-technique/)
diff --git a/client/src/guide/english/certifications/data-visualization/data-visualization-with-d3/add-document-elements-with-d3/index.md b/client/src/guide/english/certifications/data-visualization/data-visualization-with-d3/add-document-elements-with-d3/index.md
deleted file mode 100644
index f3d5ddc5d2..0000000000
--- a/client/src/guide/english/certifications/data-visualization/data-visualization-with-d3/add-document-elements-with-d3/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Add Document Elements with D3
----
-## Add Document Elements with D3
-
-### Hint 1
-
-Use the ``` .select() ``` method.
-
-### Hint 2
- Target ``` body ```.
-
-### Hint 3
- Use the ``` .append() ``` method.
-
-### Hint 4
- Use the ``` .text() ``` method.
-### Solution Ahead
-### Solution
- ```javascript
-
-
-
-```
\ No newline at end of file
diff --git a/client/src/guide/english/certifications/data-visualization/data-visualization-with-d3/work-with-data-in-d3/index.md b/client/src/guide/english/certifications/data-visualization/data-visualization-with-d3/work-with-data-in-d3/index.md
deleted file mode 100644
index 6ebc6df174..0000000000
--- a/client/src/guide/english/certifications/data-visualization/data-visualization-with-d3/work-with-data-in-d3/index.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: Work with Data in D3
----
-## Work with Data in D3
-
-### Hint 1
-
- Use the ``` selectAll ``` method.
-
-### Hint 2
-
- Use the ``` .data() ``` method.
-
-### Spoiler Alert | Solution Ahead
-### Solution
-
-```html
-
-
-
-```
\ No newline at end of file
diff --git a/client/src/guide/english/certifications/front-end-libraries/bootstrap/add-font-awesome-icons-to-our-buttons/index.md b/client/src/guide/english/certifications/front-end-libraries/bootstrap/add-font-awesome-icons-to-our-buttons/index.md
deleted file mode 100644
index a314f8ff28..0000000000
--- a/client/src/guide/english/certifications/front-end-libraries/bootstrap/add-font-awesome-icons-to-our-buttons/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Add Font Awesome Icons to our Buttons
----
-## Add Font Awesome Icons to our Buttons
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/certifications/front-end-libraries/bootstrap/call-out-optional-actions-with-btn-info/index.md b/client/src/guide/english/certifications/front-end-libraries/bootstrap/call-out-optional-actions-with-btn-info/index.md
deleted file mode 100644
index 0e600cf413..0000000000
--- a/client/src/guide/english/certifications/front-end-libraries/bootstrap/call-out-optional-actions-with-btn-info/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Call out Optional Actions with btn-info
----
-## Call out Optional Actions with btn-info
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/certifications/front-end-libraries/bootstrap/center-text-with-bootstrap/index.md b/client/src/guide/english/certifications/front-end-libraries/bootstrap/center-text-with-bootstrap/index.md
deleted file mode 100644
index d2b9e43443..0000000000
--- a/client/src/guide/english/certifications/front-end-libraries/bootstrap/center-text-with-bootstrap/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Center Text with Bootstrap
----
-## Center Text with Bootstrap
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/certifications/front-end-libraries/bootstrap/ditch-custom-css-for-bootstrap/index.md b/client/src/guide/english/certifications/front-end-libraries/bootstrap/ditch-custom-css-for-bootstrap/index.md
deleted file mode 100644
index ce4eb49b2e..0000000000
--- a/client/src/guide/english/certifications/front-end-libraries/bootstrap/ditch-custom-css-for-bootstrap/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Ditch Custom CSS for Bootstrap
----
-## Ditch Custom CSS for Bootstrap
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/certifications/front-end-libraries/bootstrap/use-responsive-design-with-bootstrap-fluid-containers/index.md b/client/src/guide/english/certifications/front-end-libraries/bootstrap/use-responsive-design-with-bootstrap-fluid-containers/index.md
deleted file mode 100644
index e1e2a34fe1..0000000000
--- a/client/src/guide/english/certifications/front-end-libraries/bootstrap/use-responsive-design-with-bootstrap-fluid-containers/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Use Responsive Design with Bootstrap Fluid Containers
----
-## Use Responsive Design with Bootstrap Fluid Containers
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/certifications/front-end-libraries/front-end-libraries-projects/build-a-drum-machine/index.md b/client/src/guide/english/certifications/front-end-libraries/front-end-libraries-projects/build-a-drum-machine/index.md
deleted file mode 100644
index ab81c0c135..0000000000
--- a/client/src/guide/english/certifications/front-end-libraries/front-end-libraries-projects/build-a-drum-machine/index.md
+++ /dev/null
@@ -1,9 +0,0 @@
----
-title: Build a Drum Machine
----
-## Build a Drum Machine
-
-The project consists of three distinct parts:
-1. Identifying the components needed to complete the task, what components are there? Can some components be used more than once? E.g. the buttons, are they the same only with different onClick events and ids?
-2. What component should be responsible for keeping state, and how should changes in state be passed on to other components?
-3. Knowing that the corresponding audio element should be in your clickable area/button which means that the audio element is a child of the corresponding button.
diff --git a/client/src/guide/english/certifications/front-end-libraries/front-end-libraries-projects/build-a-markdown-previewer/index.md b/client/src/guide/english/certifications/front-end-libraries/front-end-libraries-projects/build-a-markdown-previewer/index.md
deleted file mode 100644
index 4cf53a9cd6..0000000000
--- a/client/src/guide/english/certifications/front-end-libraries/front-end-libraries-projects/build-a-markdown-previewer/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Build a Markdown Previewer
----
-## Build a Markdown Previewer
-
-1. Add an onChangeListener on the textarea
-2. On every onChange event save the textarea's value into the state
-3. Create the preview div, pass the textarea's value into the marked library and set the preview's html to the corresponding returned marked html output. With React you can do it using the dangerouslySetInnerHTML attribute:
-```
- dangerouslySetInnerHTML={{
- __html: ...
- }}
-```
diff --git a/client/src/guide/english/certifications/front-end-libraries/front-end-libraries-projects/build-a-pomodoro-clock/index.md b/client/src/guide/english/certifications/front-end-libraries/front-end-libraries-projects/build-a-pomodoro-clock/index.md
deleted file mode 100644
index 6b1162405e..0000000000
--- a/client/src/guide/english/certifications/front-end-libraries/front-end-libraries-projects/build-a-pomodoro-clock/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Build a Pomodoro Clock
----
-## Build a Pomodoro Clock
-
-The project consists of three distinct parts:
-1. Identifying the components needed to complete the task, what components are there? Can some components be used more than once? E.g. the buttons, are they the same only with different onClick events and ids?
-2. What component should be responsible for keeping state, and how should changes in state be passed on to other components?
-3. It's recommended to set all your time values in your state in seconds for better calculating and only converting them into minutes when displaying them on the screen.
-For converting the seconds into minutes first you could use the Math.floor() function to get the minutes without the seconds e.g. 150s / 60 = 2 minutes and then use the modulo(%) operator to get the remaining seconds e.g. 150s % 60 = 30s. Now you can combine them together to get the time in minutes with seconds => 150s is 2:30 minutes
diff --git a/client/src/guide/english/certifications/front-end-libraries/jquery/change-text-inside-an-element-using-jquery/index.md b/client/src/guide/english/certifications/front-end-libraries/jquery/change-text-inside-an-element-using-jquery/index.md
deleted file mode 100644
index d4aae524b2..0000000000
--- a/client/src/guide/english/certifications/front-end-libraries/jquery/change-text-inside-an-element-using-jquery/index.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: Change Text Inside an Element Using jQuery
----
-## Change Text Inside an Element Using jQuery
-
-### Solution:
-
-```javascript
-
-
-
-
-
-
jQuery Playground
-
-
-
#left-well
-
- #target1
- #target2
- #target3
-
-
-
-
#right-well
-
- #target4
- #target5
- #target6
-
-
-
-
Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/certifications/front-end-libraries/react/use-the-lifecycle-method-componentdidmount/index.md b/client/src/guide/english/certifications/front-end-libraries/react/use-the-lifecycle-method-componentdidmount/index.md
deleted file mode 100644
index 68bd85ac38..0000000000
--- a/client/src/guide/english/certifications/front-end-libraries/react/use-the-lifecycle-method-componentdidmount/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Use the Lifecycle Method componentDidMount
----
-## Use the Lifecycle Method componentDidMount
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/certifications/front-end-libraries/react/use-the-lifecycle-method-componentwillmount/index.md b/client/src/guide/english/certifications/front-end-libraries/react/use-the-lifecycle-method-componentwillmount/index.md
deleted file mode 100644
index 45bf7a31f0..0000000000
--- a/client/src/guide/english/certifications/front-end-libraries/react/use-the-lifecycle-method-componentwillmount/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Use the Lifecycle Method componentWillMount
----
-## Use the Lifecycle Method componentWillMount
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice/index.md
deleted file mode 100644
index 9bae5d1c62..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice/index.md
+++ /dev/null
@@ -1,74 +0,0 @@
----
-title: Slice and Splice
----
-## Slice and Splice
-
- Remember to use **`Read-Search-Ask`** if you get stuck. Try to pair program  and write your own code 
-
-###  Problem Explanation:
-
-We need to copy each element from the first array into the second array starting at the index n. We've also got to ensure that the original arrays are not mutated. That is, we cannot make any changes to the original arrays.
-
-#### Relevant Links
-
-* str.slice()
-* str.splice()
-
-##  Hint: 1
-
-Create a copy of the second array inside of the function. This will ensure that the original array is not mutated. This can be done by using the slice operation on the second array, and assign it to a variable.
-
-> _try to solve the problem now_
-
-##  Hint: 2
-
-Loop through all of the items in the first array. For each item in the first array splice it into the copied array in the index given as argument.
-
-> _try to solve the problem now_
-
-##  Hint: 3
-
-Increment the index after performing the splice.
-
-> _try to solve the problem now_
-
-## Spoiler Alert!
-
-
-
-**Solution ahead!**
-
-##  Basic Code Solution:
-
- function frankenSplice(arr1, arr2, n) {
- // It's alive. It's alive!
- let localArray = arr2.slice();
- for (let i = 0; i < arr1.length; i++) {
- localArray.splice(n, 0, arr1[i]);
- n++;
- }
- return localArray;
- }
-
- Run Code
-
-### Code Explanation:
-
-* Our goal is to take all of the elements from `arr1` and insert them into `arr2` starting with index position `n`. At the same time we must ensurethat neither `arr` or `arr2` have been mutated.
-
-* Using the `slice()` function we can create an exact replica of `arr2` and assign the result of the operation to a variable, `localArray`.
-
-* Now that we have an array that we can mutate on, we can iterate through every item in the first array. For each item in the first array we can use the `splice()` function to insert the item into index `n` of `localArray`.
-
-* We increment the index `n` by one. This will ensure that every item from the `arr1` is inserted into `localArray` in the proper index position.
-
-* Finally, we return the `localArray` and end the function.
-
-##  NOTES FOR CONTRIBUTIONS:
-
-*  **DO NOT** add solutions that are similar to any existing solutions. If you think it is **_similar but better_**, then try to merge (or replace) the existing similar solution.
-* Add an explanation of your solution.
-* Categorize the solution in one of the following categories — **Basic**, **Intermediate** and **Advanced**. 
-* Please add your username only if you have added any **relevant main contents**. ( **_DO NOT_** _remove any existing usernames_)
-
-> See  **`Wiki Challenge Solution Template`** for reference.
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript/index.md
deleted file mode 100644
index d69cae917a..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Generate Random Whole Numbers with JavaScript
----
-## Generate Random Whole Numbers with JavaScript
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop/index.md
deleted file mode 100644
index 2cdbfea636..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop/index.md
+++ /dev/null
@@ -1,70 +0,0 @@
----
-title: Iterate Through an Array with a For Loop
----
-
-## Iterate Through an Array with a For Loop
-
-
-
-Here’s the setup:
-
-```javascript
-// Example
-// Example
-var ourArr = [ 9, 10, 11, 12];
-var ourTotal = 0;
-
-for (var i = 0; i < ourArr.length; i++) {
- ourTotal += ourArr[i];
-}
-
-// Setup
-var myArr = [ 2, 3, 4, 5, 6];
-
-// Only change code below this line
-```
-
-We need to declare and initialize a variable ```total``` to ```0```. Use a ```for``` loop to add the value of each element of the ```myArr``` array to ```total```.
-
-We start from declare a variable ```total```:
-
-```javascript
-
-// Only change code below this line
-var total = 0;
-```
-
-Next, we need to use a ```for``` loop to add the value of each element of the ```myArr``` array to ```total```:
-
-```javascript
-for (var i = 0; i < myArr.length; i++) {
-
-}
-```
-
-Now we need to add each value of ```myArr``` to variable ```total```:
-
-```javascript
-for (var i = 0; i < myArr.length; i++) {
- total +=myArr[i];
-}
-```
-
- Here’s a full solution:
-
-```javascript
-// Example
-var ourArr = [ 9, 10, 11, 12];
-var ourTotal = 0;
-
-for (var i = 0; i < ourArr.length; i++) {
- ourTotal += ourArr[i];
-}
-// Setup
-var myArr = [ 2, 3, 4, 5, 6];
-// Only change code below this line
-var total = 0;
-for (var i = 0; i < myArr.length; i++) {
- total +=myArr[i];
-}
-```
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/profile-lookup/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/profile-lookup/index.md
deleted file mode 100644
index ce378f6a02..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/profile-lookup/index.md
+++ /dev/null
@@ -1,94 +0,0 @@
----
-title: Profile Lookup
----
- Remember to use **`Read-Search-Ask`** if you get stuck. Try to pair program  and write your own code 
-
-###  Problem Explanation:
-
-We have an array of objects representing different people in our contacts lists.
-
-A `lookUpProfile()` function that takes **firstName** and a property (**prop**) as arguments has been pre-written for you.
-
-The function should check if **firstName** is an actual contact's **firstName** and the given property (**prop**) is a property of that contact.
-
-If both are true, then return the _value_ of that property.
-
-If **firstName** does not correspond to any contacts then return `No such contact`.
-
-If **prop** does not correspond to any valid properties then return `No such property`.
-
-* Change the code below `// Only change code below this line` and up to `// Only change code above this line`.
-* Ensure that you are editing the inside of the `lookUpProfile()` function.
- * This function includes two parameters, **firstName** and **prop**.
-* The function should look through the **contacts** list for the given **firstName** parameter.
- * If there is a match found, the function should then look for the given **prop** parameter.
- * If both **firstName** and the associated **prop** are found, you should return the value of the **prop**.
- * If **firstName** is found and no associated **prop** is found, you should return `No such property`.
-* If **firstName** isn't found anywhere, you should return `No such contact`.
-
-#### Relevant Links
-
-* Challenge: Accessing Objects Properties with Bracket Notation
-* Challenge: Iterate with JavaScript For Loops
-
-##  Hint: 1
-
-Use a `for` loop to cycle through the **contacts** list.
-
-> _try to solve the problem now_
-
-##  Hint: 2
-
-Use a nested `if` statement to first check if the **firstName** matches, and then checks `if` the **prop** matches.
-
-> _try to solve the problem now_
-
-##  Hint: 3
-
-Leave your `return "No such contact"` out of the `for` loop as a final catch-all.
-
-> _try to solve the problem now_
-
-## Spoiler Alert!
-
-
-
-**Solution ahead!**
-
-##  Basic Code Solution:
-
- for (var x = 0; x < contacts.length; x++){
- if (contacts[x].firstName === name) {
- if (contacts[x].hasOwnProperty(prop)) {
- return contacts[x][prop];
- } else {
- return "No such property";
- }
- }
- }
- return "No such contact";
-
-### Code Explanation:
-
-* The `for` loop runs, starting at the first object in the **contacts** list.
-* If the **firstName** parameter passed into the function matches the value of the `"firstName"` key in the first object, the `if` statement passes.
-* Then, we use `.hasOwnProperty()` method (checks if there's a given property and returns a boolean) with **prop** as an argument. If it's true, the value of **prop** is returned.
- * If the second `if` statement fails, `No such property` is returned.
-* If the first `if` statement fails, the `for` loop continues on to the next object in the **contacts** list.
-* If the **firstName** parameter isn't matched by the final **contacts** object, the `for` loop exits and `No such contact` is returned.
-
-**Example Run**
-
-* `lookUpProfile("Akira","likes");` runs.
-* `"Akira"` is matched to the `"firstName"` key in the first object, so the `if` statement returns true.
-* `"likes"` is found within the first object, so the second `if` statement returns true.
-* The value of `"likes"` is returned - `"Pizza", "Coding", "Brownie Points"`.
-
-##  NOTES FOR CONTRIBUTIONS:
-
-*  **DO NOT** add solutions that are similar to any existing solutions. If you think it is **_similar but better_**, then try to merge (or replace) the existing similar solution.
-* Add an explanation of your solution.
-* Categorize the solution in one of the following categories — **Basic**, **Intermediate** and **Advanced**. 
-* Please add your username only if you have added any **relevant main contents**. ( **_DO NOT_** _remove any existing usernames_)
-
-> See  **`Wiki Challenge Solution Template`** for reference.
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch/index.md
deleted file mode 100644
index cbb5ab6282..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Replacing If Else Chains with Switch
----
-## Replacing If Else Chains with Switch
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions/index.md
deleted file mode 100644
index 0ada89f034..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Return Early Pattern for Functions
----
-## Return Early Pattern for Functions
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators/index.md
deleted file mode 100644
index 4b45be82ba..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Use Multiple Conditional (Ternary) Operators
----
-## Use Multiple Conditional (Ternary) Operators
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/es6/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/es6/index.md
deleted file mode 100644
index 2cf3c38fad..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/es6/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: ES6
----
-## ES6
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller/index.md
deleted file mode 100644
index d269320cf9..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller/index.md
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title: Steamroller
----
- Remember to use **`Read-Search-Ask`** if you get stuck. Try to pair program  and write your own code 
-
-###  Problem Explanation:
-
-This problem seems simple but you need to make sure to flatten any array, regardless of the level which is what adds a bit of difficulty to the problem.
-
-#### Relevant Links
-
-* Array.isArray()
-
-##  Hint: 1
-
-You need to check if an element is an array or not.
-
-> _try to solve the problem now_
-
-##  Hint: 2
-
-If you are dealing with an array, then you need flatten it by getting the value inside of the array. This means if you have ```[[4]]``` then instead of returning ```[4]``` you need to return ```4```. If you get ```[[[4]]]``` then the same, you want the ```4```. You can access it with ```arr[index1][index2]``` to go a level deeper.
-
-> _try to solve the problem now_
-
-##  Hint: 3
-
-You will definitely need recursion or another way to go beyond two level arrays to make the code flexible and not hard-coded to the answers needed. Have fun!
-
-> _try to solve the problem now_
-
-## Spoiler Alert!
-
-
-
-**Solution ahead!**
-
-##  Basic Code Solution:
-
- function steamrollArray(arr) {
- var flattenedArray = [];
-
- // Create function that adds an element if it is not an array.
- // If it is an array, then loops through it and uses recursion on that array.
- var flatten = function(arg) {
- if (!Array.isArray(arg)) {
- flattenedArray.push(arg);
- } else {
- for (var a in arg) {
- flatten(arg[a]);
- }
- }
- };
-
- // Call the function for each element in the array
- arr.forEach(flatten);
- return flattenedArray;
- }
-
- // test here
- steamrollArray([1, [2], [3, [[4]]]]);
-
- Run Code
-
-### Code Explanation:
-
-* Create a new variable to keep flattened arrays.
-* Create a function that will add non array elements to the new variable, and for the ones that are array it loops through them to get the element.
-* It does that by using recursion, if the element is an array then call the function again with a layer of array deeper to check if it is an array or not. if it is not then push that non-array element to the variable that gets returned. Otherwise, keep going deeper.
-* Invoke the function, the first time you will always pass it an array, so it always fall in to the isArray branch
-* Return the flattened array.
-
-#### Relevant Links
-
-* Array.push()
-* Array.forEach()
-
-##  Intermediate Code Solution:
-
- function steamrollArray(arr) {
- let flat = [].concat(...arr);
- return flat.some(Array.isArray) ? steamrollArray(flat) : flat;
- }
-
- flattenArray([1, [2], [3, [[4]]]]);
-
- Run Code
-
-### Code Explanation:
-
-* Use spread operator to concatenate each element of `arr` with an empty array
-* Use `Array.some()` method to find out if the new array contains an array still
-* If it does, use recursion call `steamrollArray` again, passing in the new array to repeat the process on the arrays that were deeply nested
-* If it does not, return the flattened array
-
-#### Relevant Links
-
-* Array.some
-* Array.concat
-* Spread operator
-* Ternary Operator (`condition ? a : b`)
-
-##  Advanced Code Solution:
-
- function steamrollArray(arr) {
- return arr.toString()
- .replace(',,', ',') // "1,2,,3" => "1,2,3"
- .split(',') // ['1','2','3']
- .map(function(v) {
- if (v == '[object Object]') { // bring back empty objects
- return {};
- } else if (isNaN(v)) { // if not a number (string)
- return v;
- } else {
- return parseInt(v); // if a number in a string, convert it
- }
- });
- }
-
- Run Code
-
-### Code Explanation:
-
-* First we turn the array to a string, which will give us a string of numbers seperated by a comma, double comma if there was an empty array and literal object text if there was an object, which we can fix it later in our if statement.
-* We replace the double comma with one, then split it back into an array.
-* map through the array and fix object values and convert string numbers to regular numbers.
-
-##  NOTES FOR CONTRIBUTIONS:
-
-*  **DO NOT** add solutions that are similar to any existing solutions. If you think it is **_similar but better_**, then try to merge (or replace) the existing similar solution.
-* Add an explanation of your solution.
-* Categorize the solution in one of the following categories — **Basic**, **Intermediate** and **Advanced**. 
-
-> See  **`Wiki Challenge Solution Template`** for reference.
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller/warning sign.gif b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller/warning sign.gif
deleted file mode 100644
index 7d401ecba0..0000000000
Binary files a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller/warning sign.gif and /dev/null differ
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none/index.md
deleted file mode 100644
index 5088b31e6d..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none/index.md
+++ /dev/null
@@ -1,20 +0,0 @@
-
-## Check for All or None
-
-
-
-## The Problem:
-
-We need to change the regex ```favRegex``` to match both the American English (favorite) and the British English (favourite) version of the word.
-
- ## Solution:
-
- ```js
-let favWord = "favorite";
-let favRegex = /favou?rite/; // Change this line
-let result = favRegex.test(favWord);
-```
-
- ## Explanation:
-
-In this regex (```/favou?rite/```), we specify the possible existence of an element (```u```) with a question mark, ```?```.
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers/index.md
deleted file mode 100644
index 1ff6c285c6..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers/index.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: Match All Letters and Numbers
----
-
-## Match All Letters and Numbers
-
-
-## The Problem:
-
-Use the shorthand character class \w to count the number of alphanumeric characters in various quotes and strings.
-
-## Solution:
-
-```js
-let quoteSample = "The five boxing wizards jump quickly.";
-let alphabetRegexV2 = /\w/gi; // Change this line
-let result = quoteSample.match(alphabetRegexV2).length;
-```
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times/index.md
deleted file mode 100644
index 01946c2bd5..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
-
-## Match Characters that Occur One or More Times
-
- ## Problem:
- You want to find matches when the letter s occurs one or more times in "Mississippi". Write a regex that uses the + sign.
-
- ## Solution:
-
-```js
-let difficultSpelling = "Mississippi";
-let myRegex = /s+/g; // this is the solution
-let result = difficultSpelling.match(myRegex);
-```
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns/index.md
deleted file mode 100644
index 28480721b2..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns/index.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: Match Ending String Patterns
----
-
-## Match Ending String Patterns
-
-
-
-We need to use the anchor character (```$```) to match the string ```"caboose"``` at the end of the string ```caboose```.
-
-## Solution:
-
-```js
-let caboose = "The last car on a train is the caboose";
-let lastRegex = /caboose$/; // Change this line
-let result = lastRegex.test(caboose);
-```
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers/index.md
deleted file mode 100644
index 2f5fb94feb..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers/index.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: Match Everything But Letters and Numbers
----
-
-## Match Everything But Letters and Numbers
-
-### Problem:
-
-We need to use the shorthand character class \W to count the number of non-alphanumeric characters in various quotes and strings.
-
-### Solution:
-
-```js
-let quoteSample = "The five boxing wizards jump quickly.";
-let nonAlphabetRegex = /\W/gi; // Change this line
-let result = quoteSample.match(nonAlphabetRegex).length;
-```
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters/index.md
deleted file mode 100644
index 06962d09bf..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters/index.md
+++ /dev/null
@@ -1,20 +0,0 @@
-
-## Match Non-Whitespace Characters
-
-
-
-## Problem:
-
-We need to change the regex ```countNonWhiteSpace``` to look for multiple non-whitespace characters in a string.
-
-## Solution:
-
-```js
-let sample = "Whitespace is important in separating words";
-let countNonWhiteSpace = /\S/g; // Change this line
-let result = sample.match(countNonWhiteSpace);
-```
-
-## Explanation:
-
-We use ```\S```, and this pattern will not match any of: whitespace, carriage return, tab, form feed, and new line characters. So we find all matching non-whitespace characters.
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-whitespace/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-whitespace/index.md
deleted file mode 100644
index 6d110ae996..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/match-whitespace/index.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: Match Whitespace
----
-
-## Match Whitespace
-
-### Problem:
-
-We need to change the regex ```countWhiteSpace``` to look for multiple whitespace characters in a string.
-
-### Solution:
-
-```js
-let sample = "Whitespace is important in separating words";
-let countWhiteSpace = /\s/g; // Change this line
-let result = sample.match(countWhiteSpace);
-```
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches/index.md
deleted file mode 100644
index dd848375fb..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches/index.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: Specify Exact Number of Matches
----
-
-## Specify Exact Number of Matches
-
-## The Problem:
-
-We need to change the regex ```timRegex``` to match the word ```"Timber"``` only when it has four letter ```m```'s.
-
- ## Solution:
-
- ```js
-let timStr = "Timmmmber";
-let timRegex = /Tim{4}ber/; // Change this line
-let result = timRegex.test(timStr);
-```
-
- ## Explanation:
-
-With this regex (```/Tim{4}ber/```) we specify a certain number (```4```) of letter ```m```'s.
diff --git a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches/index.md b/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches/index.md
deleted file mode 100644
index 623ec93bdb..0000000000
--- a/client/src/guide/english/certifications/javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches/index.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: Specify Only the Lower Number of Matches
----
-
-## Specify Only the Lower Number of Matches
-
-### The Problem:
-
-Change the regex ```haRegex``` to match the word ```"Hazzah"``` only when it has four or more letter ```z```'s.
-
-### Solution:
-
-```js
-let haStr = "Hazzzzah";
-let haRegex = /Haz{4,}ah/; // Change this line
-let result = haRegex.test(haStr);
-```
-
-### Explanation:
-
-We specify the lower and upper number of patterns with ```quantity specifiers``` using curly brackets - lower is ```4``` and unlimited upper number.
diff --git a/client/src/guide/english/chef/index.md b/client/src/guide/english/chef/index.md
deleted file mode 100644
index 471340cbcc..0000000000
--- a/client/src/guide/english/chef/index.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: Chef
----
-## Chef
-
-Chef is a powerful automation platform that transforms infrastructure into code. Whether you’re operating in the cloud, on-premises, or in a hybrid environment, Chef automates how infrastructure is configured, deployed, and managed across your network, no matter its size.
-
-#### How Chef Works
-Chef stores collections of recipes in a cookbook. One cookbook should relate to a single task, but can have a number of different server configurations involved (for example a web application with a database, will have two recipes, one for each part, stored together in a cookbook).
-
-There is a Chef server which stores each of these cookbooks and as a new chef client node checks in with the server, recipes are sent to tell the node how to configure itself.
-
-The client will then check in every now and again to make sure that no changes have occurred, and nothing needs to change. If it does, then the client deals with it. Patches and updates can be rolled out over your entire infrastructure by changing the recipe. No need to interact with each machine individually.
-
-#### Chef Configuration
-
-
-
-#### More Information:
-
-- [Chef TutorialsPoint](https://www.tutorialspoint.com/chef/chef_overview.htm)
-- [Official Documnetation](https://docs.chef.io/chef_overview.html)
-- [Chef Tutorial](http://gettingstartedwithchef.com/)
-
-
diff --git a/client/src/guide/english/cloud-development/cloud-storage/index.md b/client/src/guide/english/cloud-development/cloud-storage/index.md
deleted file mode 100644
index bcb98378c8..0000000000
--- a/client/src/guide/english/cloud-development/cloud-storage/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Cloud Storage
----
-
-## STORAGE AS A SERVICE (StAAS)
-When we use the storage of cloud, that is the StAAS. In this, cloud system has storage and the user use that storage on his system and can use that to store data.
-Cloud system should have the capability of Storage Scaling.
-We can integrate all storage. For example, if we have multiple pen-drives then we can integrate all pen-drive storages in a single one.
-
-There are mainly two types of storage
-1. Object
-2. Block
-
-### Object Storage
- - We can not a make partition in cloud storage. We can only store files and folders there. This is called object storage. We can’t install OS there as there are no partitions.
- - **Example**
- - Google drive (google compute engine, GCE), OneDrive, drop box, Microsoft azure.
- - Amazon has its own cloud service AWS. S3(Simple Storage Service, SSS) is the product of amazon that provides StAAS. It’s a public cloud. Anyone can use their services.
- - OpenStack is the biggest private cloud. OpenStack has product swift (Object Storage).
-
-### Block Storage
- - If we’re able to make partitions in provided storage, then we can install OS. We have a hard-disk and we can make partitions in them, this type of storage is known as block storage.
- - **Example**
- - Block storage service of AWS – EBS (Elastic Block Storage)
- - Cloud provides facility of scaling storage that’s the elastic property of cloud.
- - Block storage of OpenStack – Cinder
diff --git a/client/src/guide/english/cloud-development/firebase/index.md b/client/src/guide/english/cloud-development/firebase/index.md
deleted file mode 100644
index 0f53b6aca2..0000000000
--- a/client/src/guide/english/cloud-development/firebase/index.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: Firebase
----
-## Firebase
-
-
-### Overview
-Firebase, in it's most basic form, was acquired by Google in October 2014. Since then, Google have acquired additional companies that complimented the original Firebase product. This selection of software tools now makes up the current selection of Firebase tools that are on offer today.
-
-### Firebase Main Features
-Firebase main features are grouped to 3 categories:
-
-1. **Develop**
- * Authentication
- * Database
- * Storage
- * Hosting
- * Function
- * Test Lab
- * Crash Reporting
- * Performance
-
- 2. **Grow**
- * Notifications
- * Remote Config
- * Dynamic Links
-
- 3. **Earn**
- * AdMob
-
-#### More Information:
-
-- [Firebase](https://firebase.google.com/)
-- [Wikipedia](https://en.wikipedia.org/wiki/Firebase)
-- [Here](https://firebase.google.com/docs/samples/) you can find examples of how to use Firebase in your projects.
diff --git a/client/src/guide/english/computer-hardware/cooling/index.md b/client/src/guide/english/computer-hardware/cooling/index.md
deleted file mode 100644
index b7a89325b1..0000000000
--- a/client/src/guide/english/computer-hardware/cooling/index.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: Cooling Systems
----
-Your computer contains many parts that generate heat. Heat can cause premature failure and erratic behaviors. The more you overclock the graphics or the CPU, the hotter the computer will run. Cooling systems assure that your computer is stable and help you extend the life of your investment.
-
-## Case Cooling
-Case cooling can be a combination of a well ventilated case and the use of fans to circulate air within the case. Most cases come with at least one fan. This is the minimum configuration. For best results, there should be at least two fans in the case. One should be used as an intake to draw in cold air while the other should be an exhaust to expel hot air. There are many different types of fans and configurations. Cable management also plays a huge part in cooling the system. Bad cable management and tangled wires disrupt airflow and cause dust to accumulate inside the case.
-
-## Components Cooling
-Cooling devices are available for individual parts on the computer. The two most common are coolers for CPU's and graphics cards. There are generally two types of component cooling systems, active and passive.
-
-* Passive Systems - Usually consist of a heat sink or a heat conductive metal attached to the component. Passive cooling works by providing a larger surface to absorb and dissipate the heat.
-* Active Systems - Add a fan to the heat sink and you are actively removing heat. The cooling fan can be dynamically adjusted to the load of the CPU or graphics card on most motherboards.
-* Liquid Cooling - High performance computers can benefit from a liquid cooled system. These types of systems circulate a liquid between the hot components and a cooling radiator.
-
-## Environmental Considerations
-
-* Keep it clean - Dust can clog up fans, heat sinks and act an an insulating layer trapping heat. Use compressed air to keep the dust out of the internal cavity.
-* Case Covers - Contrary to what you read on the internet, keeping the case covers on the computer aids cooling. Absence of the case covers disrupts air flow and can actually increase the heat inside the case.
-Room ventilation - Locate the computer where it is neutral to the rooms environmental registers. Keep the computer away from room heaters or vents at all times.
-* Room placement - Locate the computer away from windows or areas of strong sunlight exposure. Placement in closets can also provide challenges to cooling.
-* Placement next to walls and other computers - Locating the computer away from other equipment allows cool, clean, air to flow in and out of the computer. Placement close to other equipment can constrict air flow and increase heat. Placement next to a wall may also lead to the exhaust ports being completely blocked off and consequently increase heat.
-
-[Wikipedia - Article on computer cooling](https://en.wikipedia.org/wiki/Computer_cooling)
diff --git a/client/src/guide/english/computer-hardware/cpu/index.md b/client/src/guide/english/computer-hardware/cpu/index.md
deleted file mode 100644
index 050b91e36c..0000000000
--- a/client/src/guide/english/computer-hardware/cpu/index.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: CPU
----
-## CPU
-
-The Central Processing Unit (CPU) serves as the "brain" of a computer, allowing it to perform essential computational tasks.
-
-CPUs are integrated circuits, which are complex circuits embedded on a single chip. They include registers, which store single values, and input/output pins. These pins allow them to talk to the rest of the computer. Due to the continued advancement of CPU technology, many computers today utilize a multi-processing unit. Multi-processors are single chips that contain two or more CPUs or "Cores" that allow for increased processing capabilities.
-
-CPU speeds are measured in gigahertz (GHz). For every gigahertz of speed, a CPU can perform one billion instructions in a second. These instructions are very simple, such as "add two numbers" or "move this variable to this location." To see this in action, read about assembly language .
-
-Gigahertz is not the only determining factor in the actual speed of a processor, as different processors with the same gigahertz speed (also known as clock speed) may perform real-world tasks at different speeds due to using different sets of instructions to perform these tasks. These instruction sets are called CPU architectures.
-
-Most modern CPUs use a 64-bit architecture, which means they use 64 bit long memory adresses. Older CPUs used 32-bit, 16-bit, and even 8-bit architectures. The largest number a 64-bit CPU can store is 18,446,744,073,709,552,000. A CPPU need memory adresses to get specified values from the RAM. If we call the length of the memory adresses n, 2^n is the amount of memory cells a CPU can adress.
-
-An instruction cycle for a CPU is called the fetch-decode-execute cycle - where the computer retrieves a instruction from its memory, deetermines which instruction it fetched and what it does, and then carries out said instrucitons.
-
-Perhaps the most common issue affecting the CPU is inadequate cooling. CPUs are the main generators of heat in computer systems. Due to their nature, they are typically located under the computer fan. There are various ways of reducing heat in a computer with the two main systems being air fans or liquid cooling systems. Proper heat maintenance and additional hardware can allow a properly configured CPU to perform better than rated by the chip manufacturer (aka "Overclocking").
-
-
-
-Function
-
-A microprocessor is a silicon chip containing millions of microscopic transistors. This chip functions as the computer's brain. It processes the instructions or operations contained within executable computer programs. Instead of taking instructions directly off of the hard drive, the processor takes its instructions from memory. This greatly increases the computer's speed.
-
-
- Manufacturers of computer microprocessors
-
-There are two primary manufacturers of computer microprocessors. Intel and Advanced Micro Devices (AMD) lead the market in terms of speed and quality. Intel's desktop CPUs include Celeron, Pentium and Core. AMD's desktop processors include Sempron, Athlon and Phenom. Intel makes Celeron M, Pentium M and Core mobile processors for notebooks. AMD makes mobile versions of its Sempron and Athlon, as well as the Turion mobile processor which comes in Ultra and Dual-Core versions. Both companies make both single-core and multi-core processors.
-#### More Information:
-Wikipedia
-
diff --git a/client/src/guide/english/computer-hardware/expansion-cards/index.md b/client/src/guide/english/computer-hardware/expansion-cards/index.md
deleted file mode 100644
index 0208b488aa..0000000000
--- a/client/src/guide/english/computer-hardware/expansion-cards/index.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Expansion Cards
----
-## Expansion Cards
-
-The primary purpose of an expansion card is to provide or expand on features not offered by the motherboard. For example, the original IBM PC did not have on-board graphics or hard drive capability. In that case, a graphics card and an ST-506 hard disk controller card provided graphics capability and hard drive interface respectively. Some single-board computers made no provision for expansion cards, and may only have provided integrated circuit (IC) sockets on the board for limited changes or customization. Since reliable multi-pin connectors are relatively costly, some mass-market systems such as home computers had no expansion slots and instead used a card-edge connector at the edge of the main board, putting the costly matching socket into the cost of the peripheral device.
-
-In the case of expansion of on-board capability, a motherboard may provide a single serial RS232 port or Ethernet port. An expansion card can be installed to offer multiple RS232 ports or multiple and higher bandwidth Ethernet ports. In this case, the motherboard provides basic functionality but the expansion card offers additional or enhanced ports. The most common expansion card used today is the grapics card.
-
-#### More Information:
-
-* Expansion Cards
diff --git a/client/src/guide/english/computer-hardware/gpu/index.md b/client/src/guide/english/computer-hardware/gpu/index.md
deleted file mode 100644
index cf9631a2ac..0000000000
--- a/client/src/guide/english/computer-hardware/gpu/index.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-title: GPU
----
-## GPU
-
-GPU stands for Graphics Processing Unit. The majority of computers use these to render videos or play video games.
-
-A GPU is like a CPU but has different strengths and weaknesses. CPUs are very good at running a couple of tasks very quickly. GPUs are much better at running many tasks at the same time, but slower. A typical GPU can have more than 10,000 tasks running, but to run so many tasks at the same time they must share memory and other resources. GPUs usually run very repetitive tasks over and over to save the CPU from wasting time. Some CPUs have built-in GPUs, but having a separate GPU is almost always more powerful.
-
-GPUs can be used for computation as well as video rendering. Common ways to do this include OpenACC, CUDA, OpenCL, and OpenGL. Some applications include GPU implementations to reduce the amount of time the application takes to run.
-
-The GPU was originally used mainly for 3D game rendering to improve your resolution and framerate. But now these capabilities are being harnessed more broadly to improve computational workloads in many areas; for example financial modeling, cutting-edge scientific research and oil and gas exploration. GPU's are also used as a resource for bitcoin mining, since they are able to run repetitive tasks easily without straining the resources of the CPU, which allows you run an Operating System on the computer with a low end CPU while still being able to bitcoin mine using the GPU
-
-There are two major brands producing GPUs: NVidia and AMD. They are often referred as the "green team" and "red team" which indicate the major color of their logo.
-
-Notable makers of GPU's include: Nvidia and AMD/ATI.
-
-## Origin of GPU
-
-Most primitive background of GPU can be mapped to the era of VGA (Virtual Graphics Array) controllers. But these were not actually a whole processing unit, but acted as supporting units for display functions. A VGA controller is a simple memory controller connected to Dynamic RAM and a display generator. The main function of a VGA is to receive image data, arrange it properly, and send it to a video device, which was mainly a computer monitor or a TV screen connected to a gaming console for display.
-
-The first ever full-fledged processing unit for graphic acceleration was developed and marketed by NVIDIA in 1999, "GeForce 256". Older 3D accelerators had to rely on CPU to execute graphic calculations. With the new "GeForce 256" as a co-processor for CPU, improved frame rate by more than 50% and lowered the total cost, thereby expanding itself in the consumer market.
-
-
-## GPU vs CPU
-
-A CPU is optimized for minimum latency, i.e., "to be able to execute as many instructions as possible belonging to a single serial thread, in a given window of time". The processor must be able to switch quickly between operations. In order to get lots of latency on the CPU, there is a lot of infrastructure in the CPU like large caches for data to be readily available for execution, lots of Control Units for out-of-order executions, and a few ALU cores. The ISA of CPU is designed in a more generalized manner and can perform a wide-range of operations.
-While the CPU was designed for general purpose computations and instructions, GPU evolved for graphic computations. Same computation needs to be performed on hundreds and thousands of pixels for 2D/3D rendering of graphics. Thus, GPUs were primarily optimized for maximum throughput. This is implemented using tons of ALUs in a single architecture. The L2 cache is shrunk because till the data is fetched from DRAM, GPU cores have a lot of computations to perform, thereby overlapping the CPU stall time with massive parallelism. This is known as latency hiding.
-
-
-
-## Evolution of GPU Architecture
-
-GPUs were originally modeled on the concept of graphics pipeline. Graphics pipeline is a theoretical model, comprising of levels how the graphics data is to be sent through and executed using GPU and software(like OpenGL, DirectX). The pipeline basically converts 3D spatial coordinates into 2D pixelated data for the device to display. The following is an illustration of "Traditional Fixed-function Graphics Pipeline", commonly accepted pipeline till today.
-
-### 0th Generation
-"Reality Engine" board by Silicon Graphics Inc.(SGI) marked the onset of GPU hardware and the graphics pipeline. But the technology was still dependent upon CPU for the first half. Also, the speed was limited to one pixel execution per clock cycle. The engine use OpenGL, a widely used 2D/3D application programming.
-### 1stGeneration
-The "3dfx Voodoo" (1996) evolved as one of the first true 3D-accelerator for games. It handled texture mapping, rasterization, and z-buffering but the CPU still had to do vertex transformations.
-### 2ndGeneration
-This is the point when the first-ever true GPU, NVIDIA's "GeForce 256" was released in the common market. The GPUs of this generation's used Accelerated Graphics Port(AGP), offered new functions like multi-texturing, hardware geometry transform, light maps, and lighting. The traditional pipelines were known as a "fixed function" pipeline, because once the developer sent graphics data into the GPU's pipeline, the data could not be changed.
-### 3rd Generation
-With this generation of CPUs, programmable pipelining came into existence. Now the previously non-programmable parts could be programmed by programmers. In 2001, NVIDIA released the GeForce3.
-### 4th Generation
-With the beginning of 21st century, the first "fully programmable graphics cards" had reached the consumers. NVIDIA GeForce FX, ATI Radeon 9700 were among the first. These GPUs could do per-pixel operations along with pixel shaders and programmable vertex. But, separate dedicated hardwares were needed for vertex shader and pixel shader processing.
-### 5th Generation
-GPUs were evolving and advancing at it's peak rate and this generation GPUs were the first to utilize PCI-express bus. Multiple rendering buffers, 64-bit support, texture access etc. were introduced, along with increase in GPU memory.
-### 6th Generation
-In 2006, the release of NVIDIA's GeForce 8 series GPU revolutionized the GPU industry and reach, by introducing the GPU as massively parallel processors. It was the first to have "unified" and "programmable" shaders or, in other words, programmable unified processor. Unified means all the processes of graphics pipeline were executed on a single processor and no external unit is required for any stage. Basic Unified GPU architecture components are discussed below.
-
-Since the release of the 9XX series NVidia GPUs, the performance increase between generations only got better. From the 980Ti to the 1080Ti and the newly launched 208Tis, performance has more than doubled. AMD also started to produce better GPUs like the RX 580 and Vega 64, although this is still nowhere near Nvidia's level.
-Just recently, Nvidia launched a new line of GPUs titled RTX which includes the higher-end cards like 2080Ti, 2080, and 2070. RTX stands for "Ray Tracing", which is a rendering technique used in generating images though tracing the path of light in a scene.
-
-
-## Basic Unified GPU Architecture Components
-
-Unified GPU architectures are based on a parallel array of many programmable processors, wherein all the stages of graphics pipeline, viz., vertex, geometry, rasterization, and pixel shader processing and parallel computations on the same core, in contrast with earlier GPUs. The processor array is highly integrated with fixed function processors for compression and decompression, rasterization, raster operations, texture filtering, anti-aliasing, video decoding, and HD video processing.
-
-The following discussed architecture is focused on executing many parallel threads efficiently on many processor cores.
-
-### Processor Array
-A processor array consists of many processing cores. A unified GPU processor array has a typical organized structure of multi-threaded multi-processors. For execution of each thread, a multiprocessor is involved, and in each GPUs multi-processor, also known as Streaming Multiprocessors (SM), there are numerous Streaming processors, arranged in a queue. All the processors connect to DRAM partitions via interconnection network.
-### Multi-Threading
-As discussed earlier, GPU is optimized for high throughput and latency hiding. High scale multithreading shrinks the latency of memory loads from DRAM. While a thread is at stall because of a load or fetch instruction to complete, the processor can execute another thread. Also, because of high scale multithreading, GPU supports fine-grained parallel graphics shader programming models and fine-grained parallel computer programming models.
-### Multi-Processor Architecture
-Besides multiple processor cores in a SM, there are Special Functional Units, a multithreaded instruction unit, instruction and constant caches, and a shared memory. Also, each core consists of large multi-threaded register file (RF).Each streaming processor core consists of both integer and floating point arithmetic units, which together can handle most of the operations.
-
-### SIMT
-The streaming multi-processor use a "single-instruction multiple-thread (SIMT)" architecture. The instructions are executed in group of parallel threads known as warps. Each parallel thread is of the same type and start together at the same program address. SIMT processor architecture is quite similar to SIMD architecture. In SIMT, a particular instruction is executed in multiple parallel threads independently, while in SIMD, same instruction is executed in multiple data lanes in synchronous groups.
-### Streaming Processor
-It executes all the fundamental FP operations as well as arithmetic, comparison, conversion, and logical PTX instructions.
-Special Functional Unit
-Some of the thread instructions are executed on SFUs simultaneously with other thread instruction being executed on the SPs.
-
-
-#### More Information:
-
-
-- Wikipedia
-- OpenACC
-- CUDA
-- OpenCL
-- OpenGL
-- nVidia Blog
-- NVidia
-- AMD
diff --git a/client/src/guide/english/computer-hardware/hard-drives/index.md b/client/src/guide/english/computer-hardware/hard-drives/index.md
deleted file mode 100644
index 95ab8b19fd..0000000000
--- a/client/src/guide/english/computer-hardware/hard-drives/index.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: Storage Drives
----
-
-## Hard Disk Drives (HDD)
-
-Hard drives are permanent storage devices for computers. There are several types of hard drives: traditional magnetic disks, new-generation, solid-state disks or hybrid disks which contain both SSD and magnetic storage.
-
-Traditional hard disks use magnetic needles and rotating magnetized platters to store data. Due to these moving parts, hard drives are easily damaged by drops and/or shocks. The motor that rotates the platters also consumes a lot of power, and yet no other storage method is as affordable for large volumes of storage.
-
-Hard drives come in various storage capacities, with some even storing 10TB (10 trillion bytes). Typical computers come with 256GB (256 million bytes) to 1TB of storage space. Laptops usually use Solid State Drives (SSDs) because they are faster, lighter, and contain no moving parts, making them less likely to fail due to impact. For the same amount of storage, SSDs are generally more expensive than hard drives. Recently, some SSDs have been released that interface with the motherboard through the PCIe (PCI Express) bus slot using a system called NVMe. These SSDs have proven to be even faster at read/write times than traditional SATA SSDs.
-
-Magnetic heads are responsible for reading and writing data, which is physically stored on a set of magnetically coated discs stacked above one another--referred to as a platter. The heads are located at the end of an armature. The interior discs of the platter have two heads on a single arm. This allows data to be accessed from both the discs, beneath and above the arm. The top and bottom discs of the platter only have one head at the end of an arm. On the opposite end of the arm is an actuator. It provides movement of the arm to travel from the center of the platter, the spindle, to the outermost regions of the platter. The amount of time it takes to place the head in the correct concentric location is referred to as the seek time. Once the head is in the correct concentric spatial location more time is spent waiting for the disc to rotate such that the sector with the requested data is beneath the head. This amount of time is referred to as latency.
-
-The heads are positioned only a few nanometers away from the rotating discs. The heads are said to "fly" above the platter and as such the distance between head and platter is referred to as the 'flying height'. The heads are designed to never touch the locations of the platters that store data and are magnetically coated. Should the head 'touch down' on a platter, both the head and sectors of the platters may be destroyed resulting in data loss (hence the phrase "a hard drive crash" or "head crash").
-
-Hard drives retrieve and store data from applications at the request of the CPU. This is referred to as input/output operations--IO for short. When a running program requires a certain piece of data, the CPU dispatches an instruction for the data to be fetched from the hard drive. Reading this piece of data is an input operation (from the CPU's perspective). The program may then perform a computation which changes the data and the results need to be stored back out to the hard drive. The CPU requests the data be written back out to the drive. This would be an example of an output operation (again, from the CPU's perspective).
-
-Hard drive performance is measured primarily by two key metrics 1) response time, which is how long it takes a read or write operation to complete and 2) IOPS which is an acronym for 'Input / Output Operations per Second'. As the name would suggest, IOPS is a measurement of the maximum IO operations in one second. The primary factor in achieving maximum IOPS at the lowest response time is the hard drive's rotational speed measured in revolutions per minute (RPM). Common rotational speeds are 5,400 RPM, 7,200 RPM, 10,000 RPM and 15,000 RPM (commonly notated as 5.4K, 7.2K, 10K and 15K). Hard drives with higher rotational rates RPM's) will have more platter real estate pass beneath the heads for IO operations (reads and writes). Hard drives with lower RPM rotational rates will have much higher mechanical latencies, as less real estate passes beneath the heads.
-
-One simple tool for measuring hard drive performance metrics is called IOMeter (see link below). The program is very lightweight and easy to install. Once it is up and running, several different variations of workloads can be run to simulate data reads & writes to the disk. This data is analyzed and outputs metrics for read/write times, IOPS, as well as other useful metrics. Tests can be saved for consistent checks, and the data can easily be parsed in a table or graph form.
-
-Hard drives tend to be categorized by use case (capacity or performance). Home PC's and general use office workstations tend to use slower rotating hard drives (5.4K and 7.2K) which is fine for storing pictures and office files. However large databases that support online banking transactions for instance, use the faster 10K and 15K RPM hard drives as they'll be components in an enterprise server or storage array. There's a tradeoff between a hard drive's performance and capacity, however. For instance, the largest capacity 15K hard drive available today is only 600 GB, whereas the largest capacity hard drive for the both 5.4K and 7.2K RPM is 10 TB. The 600 GB 15K drive is capable of 250 IOPS @ 3 ms response time (averages). Whereas the 10 TB 7.2K TB drive does not measure IOPS at a given response time, as it's not optimized nor intended for IOPS centric performance use cases. There are also other tradeoffs in price per GB, energy consumed and size (2.5" vs 3.5" inches).
-
-Computers store data and files on hard drives for later use. Because hard drives have moving parts, it takes much longer to read a file from a hard drive than from RAM or cache memory on the CPU. You can think of a hard drive as a filing cabinet: a place to store things that we aren't using right now, but need later. You don't have enough room on your desk for all your papers, so you store things you aren't using right now in the filing cabinet. A computer does just this. It keeps files it is using right now in RAM, and files it might need later stay on the hard drive. Though RAM has access and response times that are two orders of magnitude faster when compared to hard drives, their typical capacity is 1-2 orders of magnitude less that a typical hard drive. You can fit reams of paper in the filing cabinet, but only a few on your desk.
-
-Data stored in RAM is said to be fleeting whereas data written out to a hard drive is persistent. Meaning if the power suddenly goes out, any data that was in RAM is lost and will not be there after power is restored and the computer is booted back up. However data that was written to the hard drive will be there when power is restored. For this reason, modern operating systems and applications will periodically write session and application related data that's currently in RAM out to the hard drive. This way if the power goes out, only 10 minutes of data entered in a newly created spreadsheet that was being worked on for 3 hours preceding the power outage and not yet saved to the hard drive. These files are usually denoted with a tilde~ and can be found in a temporary or temp directory or possibly located in a 'blind directory' whose contents are referred to as hidden files.
-
-## Solid State Drives (SSD)
-Solid State Drives uses integrated circuits to store data. Therefore, an SSD has no moving parts like the HDD. THis makes them less prone to physical shocks, run silently, and have faster read/write times thanks to not needing to locate the data physically.
-
-SSDs are usually only used as boot drives or storage for the mostly used applications in a person's computer. This is because eventhough its price has lessened a lot in recent years, it is still much more expensive than a traditional hard drive. Thus, HDDs are still used to store big chunks of data like our photos and videos, or in datacenters or server farms.
-
-#### More Information:
-
-* [Wikipedia - Hard Disk Drive](https://en.wikipedia.org/wiki/Hard_disk_drive)
-* [Wikipedia - Flying height](https://en.wikipedia.org/wiki/Flying_height)
-* [Wikipedia - Computer data storage](https://en.wikipedia.org/wiki/Computer_data_storage)
-* [PCMag - SSD vs. HDD: What's the Difference?](https://www.pcmag.com/article2/0,2817,2404258,00.asp)
-* [Digital Trends - SSD vs. HDD](https://www.digitaltrends.com/computing/solid-state-drives-vs-hard-disk-drives)
-* [IOMeter Project](http://www.iometer.org)
diff --git a/client/src/guide/english/computer-hardware/motherboard/index.md b/client/src/guide/english/computer-hardware/motherboard/index.md
deleted file mode 100644
index 5e5d4e1904..0000000000
--- a/client/src/guide/english/computer-hardware/motherboard/index.md
+++ /dev/null
@@ -1,36 +0,0 @@
-Types of Motherboards. Motherboards come in different sizes, known as form factors. The most common motherboard form factor is ATX. The different types of ATX are known as micro-ATX (sometimes shown as µATX, mini-ATX, FlexATX, EATX, WATX, nano-ATX, pico-ATX, and mobileATX).---
-title: Motherboard
----
-## Motherboard
-
-The motherboard is the connecting layer that allows a computer's components to interact with each other. The motherboard typically has connections for random access memory (RAM), a hard drive, a graphics processing unit (GPU), and a central processing unit (CPU). In desktops, the motherboard is a physical board to which all of these components are connected. However, in laptops, the motherboard typically has some of these components integrated due to the space constraints of laptops.
-
-A motherboard provides power and connectivity to the computer's components, and acts as the switchboard for all inter-component communications. If the CPU needs to process information that is stored in RAM, for example, the motherboard provides a connection between the CPU and RAM, called the memory bus, to allow for data access. A motherboard includes buses for expansion cards (including the GPU), RAM, and hard drives.
-
-Top manufacturers of motherboards are INTEL, ASUS, ACER, GIGABYTE, IBM, SIMMTRONICS and many more.
-
-## Parts of a Motherboard
-
-If you were to open up your computer and take out the motherboard, you would probably get pretty confused about all the different parts. Depending on the make and model of your computer, it might look something like this.
-To understand how computers work, you don't need to know every single part of the motherboard. However, it is good to know some of the more important parts and how the motherboard connects the various parts of a computer system together. Here are some of the typical parts:
-
-- A CPU socket - the actual CPU is directly soldered onto the socket. Since high speed CPUs generate a lot of heat, there are heat sinks and mounting points for fans right next to the CPU socket.
- Take note that CPUs only support a single socket type so it mus match with the motherboards socket to work. Socket types usually change every few generations and it also varies per label(consumer-grade CPUs, HEDT, server CPUs)
-- A power connector to distribute power to the CPU and other components.
-- Slots for the system's main memory, typically in the form of DRAM chips.
-- A chip forms an interface between the CPU, the main memory and other components. On many types of motherboards, this is referred to as the Northbridge. This chip also contains a large heat sink. In recent years, features of the Northbridge have been increasingly integrated into the CPU itself.
-- A second chip controls the input and output (I/O) functions. It is not connected directly to the CPU but to the Northbridge. This I/O controller is referred to as the Southbridge. The Northbridge and Southbridge combined are referred to as the chipset.
-- Several connectors, which provide the physical interface between input and output devices and the motherboard. The Southbridge handles these connections.
-- Slots for one or more hard drives to store files. The most common types of connections are Integrated Drive Electronics (IDE) and Serial Advanced Technology Attachment (SATA).
-- A read-only memory (ROM) chip, which contains the firmware, or startup instructions for the computer system. This is also called the BIOS.
-- A slot for a video or graphics card. There are a number of different types of slots, including the Accelerated Graphics Port (AGP) and Peripheral Component Interconnect Express (PCIe).
-Additional slots to connect hardware in the form of Peripheral Component Interconnect (PCI) slots.
-
-
-#### More Information:
-
-* Motherboard
-* Chipset (wikipedia)
-
-Types of Motherboards.
-Motherboards come in different sizes, known as form factors. The most common motherboard form factor is ATX. The different types of ATX are known as micro-ATX (sometimes shown as µATX, mini-ATX, FlexATX, EATX, WATX, nano-ATX, pico-ATX, and mobileATX).
diff --git a/client/src/guide/english/computer-hardware/ram/index.md b/client/src/guide/english/computer-hardware/ram/index.md
deleted file mode 100644
index 1c72a2df2a..0000000000
--- a/client/src/guide/english/computer-hardware/ram/index.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: RAM
----
-## RAM
-
-RAM stands for random-access memory, alternatively referred to as **main memory**, **primary memory**, or **system memory**. It is a piece of computer hardware where the data that your computer is currently working on is stored.memory definition for a comparison between memory and storage.RAM .
-* [Static RAM](https://en.wikipedia.org/wiki/Static_random-access_memory)
-* [Dynamic RAM](https://en.wikipedia.org/wiki/Dynamic_random-access_memory)
-* Types of RAM .
-* [Laptop Memory Buyer's Guide](https://www.lifewire.com/laptop-memory-buyers-guide-833024)
-* Wikipedia .
\ No newline at end of file
diff --git a/client/src/guide/english/computer-hardware/rom/index.md b/client/src/guide/english/computer-hardware/rom/index.md
deleted file mode 100644
index 197e2b9664..0000000000
--- a/client/src/guide/english/computer-hardware/rom/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: ROM
----
-## Read Only Memory
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/computer-science/compiled-versus-interpreted-languages/index.md b/client/src/guide/english/computer-science/compiled-versus-interpreted-languages/index.md
deleted file mode 100644
index 28a00d7f85..0000000000
--- a/client/src/guide/english/computer-science/compiled-versus-interpreted-languages/index.md
+++ /dev/null
@@ -1,63 +0,0 @@
----
-title: Compiled Versus Interpreted Languages
----
-## Compiled Versus Interpreted Languages
-
-Every program is a set of instructions, whether it's to add two numbers or send a request over the internet. Compilers and interpreters take human-readable code and convert it to computer-readable machine code. In a compiled language, the target machine directly translates the program. In an interpreted language, the source code is not directly translated by the target machine. Instead, a *different* program, aka the interpreter, reads and executes the code.
-
-### Okay... but what does that *actually* mean?
-
-So let's say you have an hummus recipe that you want to make, but it's in Ancient Greek. There are two ways you, as a non-Ancient-Greek speaker, could follow its directions.
-
-The first is if someone had translated it into English for you already. You (and anyone else who could speak English) could get the English version and make hummus. This is the compiled version.
-
-The second is if you had a friend who knows Ancient Greek. Your friend can sit next to you and translate the Ancient Greek into English, line by line, as you go. In this case, your friend is the interpreter. This is the interpreted version.
-
-### Compiled Languages
-
-Compiled languages are converted directly into machine code that the processor can execute. As a result, they tend to be faster and more efficient to execute than interpreted languages. They also give the developer more control over hardware aspects, like memory management and CPU usage.
-
-Compiled languages need a "build" step - they need to be manually compiled first. You need to "rebuild" the program every time you need to make a change. In our hummus example, the entire translation is written before it gets to you. If the original author decided he wanted to use a different kind of olive oil, the entire recipe would need to be translated again and then sent to you.
-
-Examples of pure compiled languages are C, C++, Erlang, Haskell, Rust, and Go.
-
-### Interpreted Languages
-
-Interpreters will run through a program line by line and execute each command. Now, if the author decided he wanted to use a different kind of olive oil, he could scratch the old one out and add the new one. Your translator friend can then convey that change to you as it happens.
-
-Interpreted languages were once known to be significantly slower than compiled languages. But, with the development of just-in-time compilation , that gap is shrinking.
-
-Examples of common interpreted languages are PHP, Ruby, Python, and JavaScript.
-
-### A Small Caveat
-
-Most programming languages can have both compiled and interpreted implementations. The language itself is not necessarily compiled or interpreted. However, for simplicity's sake, they're typically referred to as such.
-
-Strictly speaking, the terms interpreted language and compiled language are not well defined because, in theory, any programming language can be either interpreted or compiled. In modern programming language implementation it is increasingly popular for a platform to provide both options.
-e.g. Python can be executed either as a compiled program, or as an interpreted language in interactive mode.
-
-**Most command line tools, CLIs, and shells can theoretically be classified as interpreted languages.**
-
-### Advantages and Disadvantages
-
-#### Advantages of Compiled Languages
-Programs compiled into native code at compile time usually tend to be faster than those translated at run time, due to the overhead of the translation process.
-
-#### Disadvantages of Compiled Languages
-The most notable disadvantages are :-
-* Additional time needed to complete the entire compilation step before testing, and
-* Platform dependence of the generated binary code.
-
-#### Advantages of Interpreted Languages
-An Interpreted language gives implementations some additional flexibility over compiled implementations. Because interpreters execute the source program code themselves, the code itself is platform independent (Java's byte code, for example). Other features include dynamic typing, and smaller executable program size.
-
-#### Disadvantages of Interpreted Languages
-The most notable disadvantage is typical execution speed compared to compiled languages.
-
-#### More Information:
-
-Wikipedia - Compiled language
-
-Wikipedia - Interpreted language
-
-programmerinterview.com article - What’s the difference between a compiled and interpreted language?
diff --git a/client/src/guide/english/computer-science/data-structures/stacks/index.md b/client/src/guide/english/computer-science/data-structures/stacks/index.md
deleted file mode 100644
index a2db0683df..0000000000
--- a/client/src/guide/english/computer-science/data-structures/stacks/index.md
+++ /dev/null
@@ -1,114 +0,0 @@
----
-title: Stacks
----
-## Stacks
-
-Stacks is a First In Last Out (FILO) Data Structure. It is a linear data structure.
-
-You can imagine a stack as the way plates were organized in buffet restaurant. You can only pick the plate at the top otherwise the stack will collapse. Generally, the last item to be inserted will be removed first.
-
-Some basics operations of stack are:
-1. Push - Inserts an item at the top of the stack.
-2. Pop - Removes an item at the top of the stack.
-3. isEmpty - Check whether the stack is empty or not
-4. Size - Return the number of items in the stack
-(All the operations can be done in O(1) time)
-
-Implementation of a stack is possible using either arrays or linked lists. The following is a simple array implementation of the stack data structure with its most common operations.
-
-```C++
-//Stack implementation using array in C++
-//You can also include and then use the C++ STL Library stack class.
-
-#include
-
-using namespace std;
-
-class Stack {
- int t;
- int arr[MaxN];
-public:
- Stack() {
- t = 0;
- }
- int size() {
- return t;
- }
- bool isEmpty() {
- return t < 1;
- }
- int top() {
- return arr[t];
- }
- void push(int x) {
- if (++t >= MaxN) {
- cout << "Stack is full" << '\n';
- return;
- }
- arr[t] = x;
- }
- void pop() {
- arr[t--] = 0;
- }
-};
-
-int main() {
- Stack st;
-
- st.push(4);
- st.push(3);
- st.push(5);
- while (!st.isEmpty()) {
- cout << st.size() << ' ' << st.top() << '\n';
- st.pop();
- }
- return 0;
-}
-```
-
-#### Using Arrays as Stacks
-
-In some programming languages an array has stack functionality, allowing the developer to perform **push** and **pop** operations without the need for a custom stack data structure.
-
-For example, an array in JavaScript has **push** and **pop** methods allowing one to easily implement stack functionality in an application.
-
-```js
-stack = [];
-
-let i = 0;
-while(i < 5)
- stack.push(i++);
-
-while(stack.length) {
- stack.pop();
-}
-```
-
-A List in Python can also perform stack functionality in an application. Instead of **push**, one can use the **append** method.
-```python
-stack = []
-
-for i in range(5):
- stack.append(i)
-
-while len(stack):
- stack.pop()
-```
-
-#### Applications
-
-* Turn recursion into loop.
-* Redo-Undo features.
-* Sudoku solver
-* Depth First Search.
-* Tree traversals
-* Infix expression -> Prefix/Postfix expression
-* Valid Parentheses
-
-
-
-#### More Information:
-* [More Info on Stacks - GeeksForGeeks](http://www.geeksforgeeks.org/stack-data-structure/)
-* [Stack - Wikipedia](https://en.wikipedia.org/wiki/Stack_(abstract_data_type)
-* [Tower of Hanoi Problem and how the solution uses stacks and recursions](https://en.wikipedia.org/wiki/Tower_of_Hanoi)
-* [HackerRank Stacks and Queues Video](https://www.youtube.com/watch?v=wjI1WNcIntg)
diff --git a/client/src/guide/english/computer-science/data-structures/trees/index.md b/client/src/guide/english/computer-science/data-structures/trees/index.md
deleted file mode 100644
index 6a5aecd17b..0000000000
--- a/client/src/guide/english/computer-science/data-structures/trees/index.md
+++ /dev/null
@@ -1,97 +0,0 @@
----
-title: Trees
----
-# Trees
-
-A tree data structure can be defined recursively (locally) as a collection of nodes (starting at a root node), where each node is a data structure consisting of a value, together with a list of references to nodes (the "children"), with the constraints that no reference is duplicated, and none points to the root. A tree with no nodes is called a null or empty tree.
-
-A binary tree is a non linear data structure consisting nodes, where each node has the following 3 components:
-
-**Data element**: Stores any kind of data in the node
-**Left pointer**: Points to the sub-tree on the left side of node
-**Right pointer**: Points to the sub-tree on the right side of the node
-As the name suggests, the data element stores any kind of data in the node.
-The left and right pointers point to binary trees on the left and right side of the node respectively.
-
-If a tree is empty, it is represented by a null pointer.
-
-## Terminology used in trees:
-
-**Root** :
-The top node in a tree.
-
-**Child**:
-A node directly connected to another node when moving away from the Root.
-
-**Parent**:
-The converse notion of a child.
-
-**Siblings**:
-A group of nodes with the same parent.
-
-**Descendant**:
-A node reachable by repeated proceeding from parent to child.
-
-**Ancestor**:
-A node reachable by repeated proceeding from child to parent.
-
-**Branch**(internal node):
-A node of a tree that has child nodes.
-
-**Leaf**(less commonly called External node):
-A node with no children.
-
-**Degree**:
-The number of subtrees of a node.
-
-**Edge**:
-The connection between one node and another.
-
-**Path**:
-A sequence of nodes and edges connecting a node with a descendant.
-
-**Level**:
-The level of a node is defined by 1 + (the number of connections between the node and the root).
-
-**Height of tree**:
-The height of a tree is the height of its root node.
-
-**Depth**:
-The depth of a node is the number of edges from the tree's root node to the node.
-
-**Forest**:
-A forest is a set of n ≥ 0 disjoint trees.
-
-### Some Popular Types of Trees:
-
-* Binary Tree
-* Binary Search Tree
-* AVL Tree
-* Red Black Tree
-* Splay Tree
-* Huffmann Tree
-
-### Common uses
-
-* Representing hierarchical data
-* Storing data in a way that makes it easily searchable
-* Representing sorted lists of data
-* Routing algorithms
-
-
-
-###Code of a tree node
-
-``` c_cpp
-struct node
- {
- int data; //Data element
- struct node * left; //Pointer to left node
- struct node * right; //Pointer to right node
- };
-
-```
-#### More Information:
-
-* [CMU lesson notes](http://www.cs.cmu.edu/~clo/www/CMU/DataStructures/Lessons/lesson4_1.htm)
-* [Wikipedia](https://en.wikipedia.org/wiki/Tree_(data_structure))
diff --git a/client/src/guide/english/computer-science/hexcode/index.md b/client/src/guide/english/computer-science/hexcode/index.md
deleted file mode 100644
index 63249e1560..0000000000
--- a/client/src/guide/english/computer-science/hexcode/index.md
+++ /dev/null
@@ -1,88 +0,0 @@
----
-title: Hexadecimal Numbers
----
-
-## The Hexadecimal Numeral System
-
-Hexadecimal numbers, often shortened to "hex numbers" or "hex",
- are numbers represented in base 16 as opposed to base 10 that we use for everyday arithmetic and counting.
-
-In practical terms, this means that each column of a number written in hexadecimal can represent up to 16 values.
-
-Digits in hexadecimal use the standard symbols 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9 to represent the corresponding value,
-and use the first six letters of the alphabet to represent the values 10 through 15 (E.G: A, B, C, D, E, F).
-
-In programming, we prefix hexadecimal constants with `0x`, with some exceptions.
-
-### Examples and explanation
-```
-0x1 == 1
-0xF == 15
-0xFF == 255
-0xFFF == 4095
-0x1000 == 4096
-```
-
-In the standard base 10 system, each column represents increasing powers of 10,
-while in base 16 each column represents increasing powers of 16.
-
-As seen in the table example above, with one hex digit we can represent numbers up to and including 15. Add another column and we can represent numbers up to 255, 4095 with another column, and so on.
-
-## Uses of Hexadecimal in Low Level Programming
-Hexadecimal first found its use in Computer Science as a convenience feature.
-
-Data in our computers has a lowest common storage unit, the Byte.
-Each byte contains 8 bits, and is able to store a number between 0 and 255 inclusive.
-
-Hexadecimal has the advantage of being terse and having well defined boundaries.
-
-A single byte is always represented by two hexadecimal digits
-from 0x00 to 0xFF, the latter being the largest per-byte value of 255.
-
-The terseness and byte-aligned nature of hexadecimal numbers make them a popular choice for software engineers working on low-level code-bases or embedded software.
-
-## Uses of Hexadecimal Numbers in JavaScript
-JavaScript supports the use of hexadecimal notation in place of any integer, but not decimals.
-
-As an example, the number 2514 in hex is 0x9D2, but there is no language-supported way of representing 25.14 as a hex number.
-
-Using hexadecimal in your code is a personal and stylistic choice, and has no effect on the underlying logic your code implements.
-
-## Uses of Hexadecimal Numbers in CSS
-CSS has for a long time used hexadecimal notation to represent color values. Consider the following selector:
-```css
-.my-container {
- background-color: #112233;
- color: #FFFFFF;
-}
-```
-
-The `background-color`'s value is in fact three hex bytes.
-
-The CSS processor treats these as three individual bytes, representing Red, Green, and Blue.
-
-In our example, 11 corresponds to the Red color component, 22 corresponds to the Green color component, and 33 to the Blue color component.
-
-There is currently no way as of CSS3 to define a color with an alpha component using hex.
-The proposed CSS4 Draft1 includes a proposal to allow for an extra byte to specify alpha values.
-
-For now, use of the standard `rgba()` function is the recommended way to add an alpha value to your colors.
-
-#### More Information:
- + [Hexadecimal numeral system on Wikipedia](https://wikipedia.org/wiki/Hexadecimal_numeral_system)
- + [CSS color on the MDN web docs](https://developer.mozilla.org/en-US/docs/Web/CSS/color)
-
-#### References:
- + 1 [CSS Color Module Level 4 - 4.2. The RGB hexadecimal notations: #RRGGBB](https://www.w3.org/TR/css-color-4/#hex-notation)
-
-#### More Information:
-
-* [How Do HEX Color Codes Work? (in 60 seconds)](https://www.youtube.com/watch?v=c56x1aj2CPA) - Good Video which also explains a little bit about Hexadecimal Numbers.
-* [Hex Codes & Color Theory](https://www.youtube.com/watch?v=xlRiLSDdqcY) - A Longer Video which delves into Color theory (Such as what are additive colors and what are subtractive colors etc.) and it also points to other resources for delving deeper into the topic.
-* [Web Colors](https://en.wikipedia.org/wiki/Web_colors) - Wikipedia Article on how colors are used on the web.
-* [Wikipedia article about Hexadecimal code](https://en.wikipedia.org/wiki/Hexadecimal)
-* [Wikipedia article about web colors](https://en.wikipedia.org/wiki/Web_colors)
-* [Hex Colors](http://www.color-hex.com/)
-* [Medium article on hex color code](https://medium.com/webkul-dev/hex-color-codes-27cd0a37c3ce)
-* [More information on colors in CSS](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value)
-* [Explore different Hex colors](http://www.colorhexa.com/)
\ No newline at end of file
diff --git a/client/src/guide/english/computer-science/index.md b/client/src/guide/english/computer-science/index.md
deleted file mode 100644
index a9cd5b8190..0000000000
--- a/client/src/guide/english/computer-science/index.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: Computer Science
----
-## Computer Science
-
-Computer Science is the study of computers and the concepts that make computers possible.
-
-Much of computer science was pioneered in the latter half of the 20th century.
-
-Today, if you attend an undergraduate computer science course, you will learn about both hardware and software. You'll learn how computers work at a low level of abstraction (machine language) and at a high level of abstraction (modern scripting langauges like JavaScript).
-
-# Computer Science Fields
-Computer science is categorized into several fields. The following are among the current established and well-studied fields. Most of the fields are further categorized into sub0fields.
-- Theory of Computing
- - Complexity Theory
- - Formal Methods
- - Distributed Algorithms
-- Security
- - CryptographyArtificial Intelligence
- - Data Mining
- - Machine Learning
- - Computer Vision
-- Software Engineering
-- Data Sciences
- - Big Data
-- Human Computer Interaction
- - Brain Computer Interface
-- Systems
- - Distributed Systems
- - Operating Systems
- - Database Systems
-
-##More Information
-[Visualization of Data Structures](http://www.cs.usfca.edu/~galles/JavascriptVisual/Algorithms.html)
-
diff --git a/client/src/guide/english/computer-science/parallel-computing/index.md b/client/src/guide/english/computer-science/parallel-computing/index.md
deleted file mode 100644
index a0cdadbdde..0000000000
--- a/client/src/guide/english/computer-science/parallel-computing/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Parallel Computing
----
-## Parallel Computing
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/cplusplus/arrays/index.md b/client/src/guide/english/cplusplus/arrays/index.md
deleted file mode 100644
index 622f065189..0000000000
--- a/client/src/guide/english/cplusplus/arrays/index.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: C++ Arrays
----
-
-## What are Arrays?
-An array is a series of elements of the same data type which are stored in contiguous memory locations and can be referenced individually.
-
-For example, an array containing 5 integer values called numbers is declared like so:
-```C++
-int numbers [5];
-```
-
-Initializiation:
-```C++
-//Initialization with entries:
-int numbers [5] = {1, 2, 3, 4, 5};
-
-//Initialization with no values:
-int numbers [5] = {};
-
-//Initialization with declaration:
-int numbers [] = {1, 2, 3, 4, 5};
-//Note that here the number of values defines the size of the array.
-//In the examples above, the size was fixed beforehand
-```
-
-**Note** that arrays in C++ are not permutable in size, which means that once you've declared a array with size 5, it can't be enlarged or made smaller. In case you really need a bigger array with the same entries, you would have to copy all entries to a new array of bigger size.
-
-### Access:
-Elements from an array can be accessed via reference of their position in the array. (Start counting from 0).
-Example:
-```C++
-x = numbers[0]; // = 1. [0] == first position
-numbers[2] = 55; // Sets the third position (3) to the new number 55
-//numbers[] is now: {1, 2, 55, 4, 5}
-```
diff --git a/client/src/guide/english/cplusplus/compilers/index.md b/client/src/guide/english/cplusplus/compilers/index.md
deleted file mode 100644
index d1c11bbce1..0000000000
--- a/client/src/guide/english/cplusplus/compilers/index.md
+++ /dev/null
@@ -1,84 +0,0 @@
----
-title: C++ Compilers
----
-
-# Intro to C++ Compilers
-
-In order to get started with C++, you will need to learn a little about compilers and how C++ runs on your computer.
-
-When all is said and done, computers only understand one language, machine language. Machine language is entirely made up of
-binary bits, or 0s and 1s. While it would be possible to program in binary, it would be incredibly tedious and time consuming.
-So, we humans developed programming languages to make it easier to develop software. Assembly language is a direct 1 to 1 with machine
-language. Languages like C, C++, and COBOL are a little higher and need to be compiled down. It goes even higher. Languages
-like JavaScript and Python have components that get translated into C++ or other low level languages before they get compiled,
-effectively making them "higher" languages than C or C++.
-Because computer architecture is made up of electronic switches and cables that can only work with binary 1s and 0s,
-you need a compiler to translate your code from high level C++ to machine language that the CPU can understand.
-
-Compilers are utility programs that take your code and transform it into executable machine code files. When you run a compiler
-on your code, first, the preprocessor reads the source code (the C++ file you just wrote). The preprocessor searches for any
-preprocessor directives (lines of code starting with a #). Preprocessor directives cause the
-preprocessor to change your code in some way (by usually adding some library or another C++ file).
-Next, the compiler works through the preprocessed code line by line translating
-each line into the appropriate machine language instruction. This will also uncover any syntax errors that are present in your
-source code and will throw an error to the command line. Finally, if no errors are present, the compiler creates an object
-file with the machine language binary necessary to run on your machine. While the object file that the compiler just created
-is likely enough to do something on your computer, it still isn't a working executable of your C++ program. There is a final
-important step to reach an executable program.
-
-C++ contains a vast library to aid in performing difficult tasks like I/O and hardware manipulation. You can include these
-libraries with preprocessor directives, but the preprocessor doesn't automatically add them to your code. In order for you to have
-a final executable program, another utility known as the linker must combine your object files with the library functions
-necessary to run the code. Think of it as having all the necessary blocks
-to build a house. The compiler made all the blocks but the linker is the one that sticks them all together to finally create a house.
-Once this is done, you now have a functioning executable file!
-
-
-## How to Compile a file
-Let's say you have a C++ file called `helloWorld.cpp` ...
-
-### If you are on Windows --
-
-#### Using and IDE like CodeBlocks
-
-It is as simple as clicking the build and run buttons, they will create a file in the project folder.
-
-
-#### Using Command Prompt
-1. Open a Developer Command Prompt - For this step, you will need to have Microsoft Visual Studio or some other IDE that
-enables you to compile your program from the command line. You can also search online for C++ compilers.
-
-2. Navigate to the source code directly
-
-3. Run the Compiler on your source code (assuming you are using the Microsoft Visual Studio compiler)
-`cl /EHsc helloWorld.cpp`
-
-This will now create an object file and automatically link it for you. If you look in that same folder, you will see a
-hellWorld.exe executable file (note the exe extension) is now present.
-
-4. Type `helloWorld` into the prompt to run the executable
-
-Alternatively, many IDEs allow for quick building and viewing of your program. This may be easier since your version of
-windows may not come pre packaged with a compiler utility.
-
-### If you are on Linux or OSX --
-1. Open up a terminal window and navigate to the source code directory
-2. Run the Compiler on your source code
-`g++ helloWorld.cpp -o helloWorld`
-
-This will create an object file and automatically link it for you. Look in the folder and you will see a helloWorld.exe
-executable file (note the exe extension).
-
-3. Type `./helloWorld` in the terminal window to run the executable file
-
-g++ is the standard Linux compiler and is a great utility. It comes packaged with the operating system.
-
-NOTE:
-to compile and execute your code directly, run
-`g++ -o helloWorld helloWorld.cpp; ./helloWorld`
-so when you need to compile and run your code multiple times,
-up arrow-enter
-____________
-
-There are a number of different types of compilers. The two listed are the two that are usually packaged with the Windows
-or Linux/OSX.
diff --git a/client/src/guide/english/cplusplus/conditional-operator/index.md b/client/src/guide/english/cplusplus/conditional-operator/index.md
deleted file mode 100644
index 4e2d9ce15d..0000000000
--- a/client/src/guide/english/cplusplus/conditional-operator/index.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: Conditional Operator
----
-
-## Conditional Operator
-
-Conditional operator is a ternary operator, that is it needs 3 operands.
-It returns one of two values depending on the result of an expression
-Conditional operator is used to replace a simple if-else statements.
-
-Syntax :
-```cpp
- (condition)?(expression-1):(expression-2);
-```
-Here, expression-1 is evaluated when condition is true and expression-2 is evaluated when condtion is false.
-Similar if-else statement would be :
-```cpp
-if(condition)
- {
- expression-1;
- }
-else
- {
- expression-2;
- }
-```
-Hence conditional operator is very handy when you need to write simple if-else statement. It can also be used in #define
-preprocessor when similar condition is to be used in multiple places.
-
-For example, to find maximum of two number conditional operator can be used as follows :
-
-```cpp
-#define big(a,b) (a>=b)?a:b
-
-int maximum,x=5,y=6; // variable to store maximum of two numbers
-maximum=(x>y)?x:y; // directly using conditional operator
-maximum=big(x,y); // using the #define preprocessor defined above as big
-```
- **Good Luck to all of you**
-
- **Happy Coding ! :)**
-
- **Feel free to ask any queries on FreeCodeCamp's GitHub page or [FreeCodeCamp's Forum .](https://forum.freecodecamp.org/)**
diff --git a/client/src/guide/english/cplusplus/dynamic-memory-allocation/index.md b/client/src/guide/english/cplusplus/dynamic-memory-allocation/index.md
deleted file mode 100644
index c51bd7afe6..0000000000
--- a/client/src/guide/english/cplusplus/dynamic-memory-allocation/index.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: Dynamic Memory Allocation
----
-## Dynamic Memory Allocation in C++
-
-### What is Dynamic Memory Allocation in C++?
-* **Memory Allocation** in C++ refers to the memory alloted to the variables you use throughout your program.
-* **Dynamic Memory Allocation** is the memory which is alloted to the variables at the run-time and the amount of memory required is also decided at the run-time.
-* This memory comes from **heap**, whereas _non-static_ variables and _local_ variables get memory from **stack**.
-* In C++, the programmer can perform memory allocations manually, and is called as **_dynamic memory allocation_**.
-* It was possible in C to do dynamic memory allocation, by using _calloc_ and _malloc_ functions to allocate memory and using _free_ function to de-allocate the dynamic memory.
-* In C++, in addition to above, there are two functions, _new_ and _delete_ for performing dynamic memory allocation and de-allocation.
-
-### NEW operator
-* `new` operator can grant the programmer memory from the heap (if available). If the memory which the programmer asks is available, then the `new` operator initializes the memory and then returns the address (reference) of the memory allocated.
-* **Syntax**
- `pointer-variable-type` = **new** `data-type;`
- Example 1: `int *ptr` = **new** `int;`
- Example 2: `int *ptr2` = **new** `int[10];`
- Here, `pointer-variable-type` is a **pointer** of `data type`. The `data-type` can be int, char, etc. or user-defined data-type.
-
-### DELETE operator
-* It is programmer's responsibility to de-allocate the dynamically allocated memory otherwise the memory would not be available to be re-allocated until the end of the program.
-* To deallocate the memory, `delete` operator is available and can be used by the programmer.
-* **Syntax**
- **delete** `pointer-type-variable;`
- For example to free the memory allocated in example 1 above, we type:
- `delete ptr;`
- Similarly, for example 2, the memory can be freed by:
- `delete ptr2`;
-
- ### Memory Leaks
- Leaks are caused when you fail to deallocate dynamic memory you allocated via `New` operator at the end of your program. If you do not deallocate it with the Delete operator, your computer will keep creating new memory in the heap every time the program runs. This causes your computer to slow down because memory is not deleted and your available memory decreases.
-
diff --git a/client/src/guide/english/cplusplus/for-loop/index.md b/client/src/guide/english/cplusplus/for-loop/index.md
deleted file mode 100644
index 2e54d930da..0000000000
--- a/client/src/guide/english/cplusplus/for-loop/index.md
+++ /dev/null
@@ -1,124 +0,0 @@
----
-title: For Loop
----
-
-A For Loop is a repetitive statement that is used to check for some condition and then based upon the condition a block of code is executed repeatedly until the specified condition is satisfied.
-
-The for loop is distinguished from other looping statements through an explicit loop counter or loop variable which allows the body of the loop to know the exact sequencing of each iteration.
-
-Hence a for loop is a repetition control structure that allows you to efficiently write a loop that needs to execute a specific number of times.
-
-## Syntax
-
-```
-for ( init; condition; increment ) {
- statement(s);
-}
-```
-
-It is allowed to place the increment insie the for loop like in a while loop. Meaning a syntax like this can also work.
-
-```
-for ( init; condition;) {
- statement(s);
- increment;
-}
-```
-
-### init
-This step allows you to declare and initialize any loop control variables. This step is performed first and only once.
-
-### condition
-Next the condition is evaluated. If it holds true, the body of the loop is executed. If it holds false, the body of the loop does not execute and flow of control jumps to the next iteration(repetition of a process).
-
-### update
-The update statement is used to alter the loop variable by using simple operations like addition,subtraction,multiplication or division.
-The update statement executes after the execution of the body of the loop.
-
-## IMPLEMENTATION:
-```C++
-#include
-using namespace std; // Here we use the scope resolution operator to define the scope of the standar functions as std::
-
-int main () {
- // for loop execution
- for( int a = 10; a < 20; a = a + 1 ) { // The loop will run till the value of a is less than 20
- cout << "value of a: " << a << endl;
- }
-
- return 0;
-}```
-
-Output:
-value of a: 10
-value of a: 11
-value of a: 12
-value of a: 13
-value of a: 14
-value of a: 15
-value of a: 16
-value of a: 17
-value of a: 18
-value of a: 19
-
-##Single lined loop
-The body of the for loop need not be enclosed in braces if the loop iterates over only one satatement.
-##Example
-```c++
- #include
- using namespace std;
-
- int main () {
- // Single line for loop
- for( int a = 10; a < 20; a = a + 1 )
- cout << "value of a: " << a << endl;
-
-
- return 0;
-}```
-
-This would generate the same output as the previous program.
-i.e
-Output:
-value of a: 10
-value of a: 11
-value of a: 12
-value of a: 13
-value of a: 14
-value of a: 15
-value of a: 16
-value of a: 17
-value of a: 18
-value of a: 19
-
-```
-
-## Explanation
-Here's the initialization condition is first set to a=10. The loop first checks for this condition. It then checks for the condition expression i.e a<20 which holds true as 10<20(for the first case). Now the body of the loop is executed and we get the output "Value of a: 10". Then the update expression is executed which adds the number 1 to 'a' and the value of 'a' gets updated to 11 and the same steps are followed (as above) until the value of v reaches less than 20 i.e 19.
-
-# Range-based for-loop
-C++ also has what we call range-based for loops which iterates through all the elements of a container(e.g. array).
-
-## Syntax
-
-```
-for ( element: container )
- statement(s);
-}
-```
-
-```
-int[5] array = { 1, 2, 3, 4, 5 }
-for ( int i: array )
- cout << i << endl;
-}
-
-Output:
-1
-2
-3
-4
-5
-```
-
-
diff --git a/client/src/guide/english/cplusplus/functions/index.md b/client/src/guide/english/cplusplus/functions/index.md
deleted file mode 100644
index 930b5c9cb4..0000000000
--- a/client/src/guide/english/cplusplus/functions/index.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: Functions in C++
----
-## Definition:
-
-A function is a group of statements that together perform a task. Every C++ program has at least one function, which is main().
-
-A function declaration tells the compiler about a function's name, return type, and parameters. A function definition provides the actual body of the function.
-
-## The general form of a C++ function definition:
-
-```cpp
-return_type function_name( parameter list )
-{
- body of the function
-}
-```
-
-### Return type:
-A function may return a value. The return_type is the data type of the value the function returns. Some functions perform the desired operations without returning a value. In this case, the return_type is the keyword void.
-
-### Function name:
-This is the actual name of the function. The function name and the parameter list together constitute the function signature.
-
-### Parameters:
-A parameter is like a placeholder. When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters.
-
-### Function body:
-The function body contains a collection of statements that define what the function does.
-
-##Example:
-
-```cpp
-int max(int num1, int num2)
-{
- // local variable declaration
- int result;
-
- if (num1 > num2)
- result = num1;
- else
- result = num2;
-
- return result;
-}
-```
-
-## Why are functions important?
-
-Functions support modularity(breaking down of work into smaller pieces called modules) which is an essential feature of OOP which primarily separates C++ from C.
-Having specific functions to perform specific tasks removes confusion and shortens the length of the main function.
-The function also performs reusability of code. So the next time you have to calculate the maximum of two different numbers agaun and again in the same program, you do not need to copy and paste your code. You just have to call the function and it does rest of the work.
-
-## More Information
-
-* [TutorialsPoint](https://www.tutorialspoint.com/cplusplus/cpp_functions.htm)
-
-
diff --git a/client/src/guide/english/cplusplus/input-and-output/index.md b/client/src/guide/english/cplusplus/input-and-output/index.md
deleted file mode 100644
index 9ebcb3d854..0000000000
--- a/client/src/guide/english/cplusplus/input-and-output/index.md
+++ /dev/null
@@ -1,167 +0,0 @@
----
-title: Input and Output
----
-
-## Input and Output with Streams
-
-To print things to the console, or read from it, you use `cout` and `cin`, which are so-called `streams`. This metaphor is used because you use streams like you would use a sink, or a tap: you either flush data into a sink (`cout`), or get data out of a tap (`cin`).
-
-### Output with cout
-
-The "Hello World" program uses `cout` to print "Hello World!" to the console:
-
-```C++
-#include
-using namespace std;
-
-int main()
-{
- cout << "Hello world!" << endl;
-}
-```
-The first two lines at the top are necessary for you to use `cout` and other streams. `#include` makes the stream objects abailable, and `using namespace std;` lets you type `cout` directly instead of having to type `std::cout`, that is, having to specify that we want to use `cout` from the `std` namespace.
-
-`cout` stands for "Console Output", and is a so-called _output stream_ that represents the console. When you want to print something to the console, you can put it into `cout`; imagine it as a hole that leads to the terminal. To put things into this hole, one at a time, you use the `<<` operator, a.k.a. the _insertion operator_1 . The operator can be chained, that is, you can put several things in one after the other. The following will print "The cake is a lie.":
-
-`cout << "The cake " << "is " << "a " << "lie." << endl;`
-
-`endl` stands for "End Line" and is another item that comes from ``. When you put `endl` into `cout`, it will print a newline character ("\n") to the console, and also _flush_ `cout`, which means that it will force `cout` to print everything you have put into it *right now*. If you don't put `endl` into `cout`, `cout` might keep the data you've put into it but wait for more data before actually printing it all. This is called _buffering_ and is very good for performance, but if you've already given it everything it's supposed to print, you want `cout` to print it immediatelly. Therefore it is very good practice to end with `endl` in places where it makes sense.
-
-Almost everything can be put into a stream: strings, numbers, variables, expressions, etc. Here area some examples of valid stream insertions:
-
-```C++
-// Notice we can use the number 42 and not the string "42".
-cout << "The meaning of life is " << 42 << endl;` // Output: The meaning of life is 42
-```
-
-```C++
-string name = "Tim";
-cout << "Except for you, " << name << endl;`// Output: Except for you, Tim
-```
-
-```C++
-string name = "Tim";
-cout << name;
-cout << " is a great guy!" << endl;`
-// Output: Tim is a great guy!
-```
-
-```C++
-int a = 3;
-cout << a*2 + 18/a << endl;`// Output: 12
-```
-
-### A note about whitespace
-
-C++ always puts *you* in control, and only does exactly the things you tell it to do. This can sometimes be surprising, as in the following example:
-
-```C++
-string name = "Sarah";
-cout << "Good morning" << name << "how are you today? << endl;
-```
-You might expect it to print "Good morning Sarah how are you today?", but actually, the output would be "Good morningSarahhow are you today?". The reason for this bug is that you did not write spaces in the strings surrounding `name`, and so, since you didn't specify any spaces, `cout` didn't print any. The correct version would be: `cout << "Good morning " << name << " how are you today? << endl;`.
-
-Line breaks don't happen by themselves, either. You might think this would print a recipe on four lines:
-
-```C++
-cout << "To make bread, you need:";
-cout << "* One egg";
-cout << "* One water";
-cout << "* Two wheat";
-```
-but the output is actually all on one line: "To make bread, you need:* One egg* One water* Two wheat". This is because there are no newline characters at the end of the lines, so naturally, C++ assumes we don't want it to print newline characters.
-
-You could fix this by adding `endl`s after every line, because as discussed earlier, `endl` inserts a newline character into the output stream. However, it also forces the buffer to be flushed, which loses us a little performance since we could have printed all the lines in one go. Therefore the best would be to add actual newline characters at the end of the lines, and only use `endl` at the end:
-```C++
-cout << "To make bread, you need:\n";
-cout << "* One egg\n";
-cout << "* One water\n";
-cout << "* Two wheat" << endl;
-```
-If you're just printing a small recipe, the time you save is miniscule and not worth the hassle, but if you're printing millions of items, the difference could be very noticeable.
-
-### Input with cin
-
-To read from the console, you use the _input stream_ `cin` in the same way as you would `cout`, but instead of putting things into `cin`, you "take them out". The following program reads two numbers from the user and adds them together:
-```C++
-#include
-using namespace std;
-
-int main()
-{
- int a, b; // Variables to hold the two numbers.
-
- cout << "Please enter the first number:" << endl;
- cin >> a;
- cout << "Please enter the second number:" << endl;
- cin >> b;
-
- cout << "The sum of your numbers is: " << a + b << endl;
-}
-```
-
-`cin` stands for "Console Input" and is an _input stream_ that represents input from the console. In the expression `cin >> a;`, data is read from `cin` and saved into the variable `a`, using the operator `>>`, the _extraction operator_2 . The extraction operator reads exactly as much data as required to write into the variable we specify, and skips any whitespace, so if the user types " 6" that will just be read as the value `6`.
-
-It's worth noting that `cin` will stop the whole program to wait for the user to type in their value. The program will not continue until the user has pressed enter, and there is some data to be written into the variable. If the user just presses enter without typing anything, `cin` will keep waiting for a value.
-
-The extraction operator `<<` can be chained too. Here is the same program as last time, but written in a more concise manner:
-```C++
-#include
-using namespace std;
-
-int main()
-{
- int a, b; // Variables to hold the two numbers.
-
- cout << "Please enter two numbers:" << endl;
- cin >> a >> b;
- cout << "The sum of your numbers is: " << a + b << endl;
-}
-```
-When chained, the extraction operator will first read data from `cin` to fill `a`, and then read data to fill `b`.
-
-
-C's standard printf and scanf statements can also be used with c++ by importing '' header file.
-
-#### Error handling with `cin`
-
-Sometimes the process of reading an input fails, commonly because we try to assign a content of certain type to a variable that cannot store it. If not handled properly, an error in input could cause `cin` to stop blocking the program flux, just accepting what remains on its buffer that failed to be read. If for example `cin` is in an infinite loop, it could begin repeating that sequence indefinitely without waiting for the user input, leaving the only choice of force quitting the program.
-
-When `cin` fails to read it raises a `failbit`3 , so we need to handle that, `clear`4 the stream state from errors and `ignore`5 the remaining input, since a failure in reading will not clear the input buffer. Let's see an example:
-
-```C++
-int number;
-cin >> number;
-
-if(cin.fail())
-{
- cin.clear(); // resetting failbit
- cin.ignore(std::numeric_limits::max(), '\n'); // skipping input until line return
- /*
- ...
- Do other needed handling, for
- example asking for new input.
- ...
- */
-}
-```
-
-It is also possible to check the condition with `if (!cin)` instead of `if (cin.fail())`. Furthermore, we can check for errors at the same time we try to assign the input to the variable:
-
-```C++
-int number;
-
-if(!(cin >> number))
-{
- cin.clear();
- cin.ignore(std::numeric_limits::max(), '\n');
- // ...
-}
-```
-
-## Sources
-1. http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/
-2. http://www.cplusplus.com/reference/istream/istream/operator%3E%3E/
-3. https://en.cppreference.com/w/cpp/io/basic_ios/fail
-4. https://en.cppreference.com/w/cpp/io/basic_ios/clear
-5. https://en.cppreference.com/w/cpp/io/basic_istream/ignore
diff --git a/client/src/guide/english/cplusplus/lists/index.md b/client/src/guide/english/cplusplus/lists/index.md
deleted file mode 100644
index 4b1f3bf812..0000000000
--- a/client/src/guide/english/cplusplus/lists/index.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: C++ Lists
----
-
-# What is a STL List?
-
-Lists in C++ are a powerful tool similar to its more well known cousin, C++ Vectors. While Vectors are a sequential container
-where elements are indexed in a continuous chain, Lists are also a sequential container but they are organized differently.
-List elements point to its next element so all elements are ordered in sequence but they don't use indexing.
-How? You may ask. They do this not by indexing but using a special tool called iterators. Iterators are like special pointers
-whose job is to maintain the order of the list elements kind of like the link between two train cars. Here is a nice visual
-of how Lists are organized compared to Vectors and Arrays.
-
-
-
-## How to declare a List
-If you want to declare a List of Numbers you write:
-
-'''std::list Numbers;'''
diff --git a/client/src/guide/english/cplusplus/loops/index.md b/client/src/guide/english/cplusplus/loops/index.md
deleted file mode 100644
index f596ae40f7..0000000000
--- a/client/src/guide/english/cplusplus/loops/index.md
+++ /dev/null
@@ -1,114 +0,0 @@
----
-title: Loops
----
-
-# Loops
-
-## Introduction
-
-Now lets discuss something known as loop. Suppose you want to print the even numbers from 1 to 1000 on the screen. One way
-to do this is to write the following lines
-
-``` c++
-cout << 0 << endl;
-cout << 2 << endl;
-cout << 4 << endl;
-....
-....
-....
-cout << 1000 << endl;
-
-```
-But the problem with this approach is that you have to write the same line again and again. And if suppose you have to print
-prime numbers from 1 to 1000 then this will be more hectic.
-Therefore, in order to solve such problems loops are introduced.
-
-There are different types of loop functions:
-### While and do while loops
-
-While and do while loops allow you to make the loop until a condition finishes.
-The difference between While and Do while is that Do while always executes once.
-Here you can see an example:
-``` c++
-while (condition){
- // Code that will execute while condition is true
-}
-do {
- // Will execute once and until the condition is false
-} while (condition);
-```
-### For loops
-
-For loops are usually used when you know how many times the code will execute.
-The flow can be seen in this [graph](https://www.tutorialspoint.com/cplusplus/images/cpp_for_loop.jpg).
-
-They are declared this way:
-``` c++
-for ( initialize a variable; check a condition; increment the initialized variable ) {
- //Code to execute
-}
-```
-
-Lets write a program which will print numbers from 0 to 1000 including 1000 on the screen using a for loop.
-
-``` c++
-for (int i = 0;i<=1000;i++)
-{
- cout << i << endl;
-}
-```
-
-When you execute this code in a c++ program numbers from 1 to 1000 will be printed.
-Now lets discuss how the for loop works.
-
-* You start a for loop by typing the keyword 'for'. It means you are starting a for loop
-` for `
-* Next you open and close a round bracket. In this brackets you write some conditions which will be discussed later
-` for()`
-* Inside the brackets first you write the initial condition i.e the value from where the loop will start. Like in the
- above program we write int i = 0
- ` for(int i = 0)`
- * Then you write the semicolon and then condition until when the loop will be executed. In the above code you define
- i < 1000. It means until value of i is less then 1000 execuete the loop.
- ` for(int i=0;i<=1000) `
- * Then you define the incremented value that is how much i has to be incremented in each iteration. In the above code
- we write i++. It means value of i will be incremented by 1 every time.
- ` for(int i=0;i<=1000;i++) `
- * If there is only one statement inside the loop then the curly bracket is optional but its better to write loop code
- within brackets so that you don't get confused.
- ``` c++
- for(int i=0;i<=1000;i++)
- {
- }
- ```
- * Then inside the loop you write what do you want to do. In the above program we output the value of i.
-
- So, in this way the for loop works
-
- If you want to print even numbers from 1 to 1000 then your program will look like this
-
-
-``` c++
-for (int i = 0;i<=1000;i=i+2)
-{
- cout << i << endl;
-}
-
-```
-* The difference in first program and second is the increment part. Rest of code is same. This program will print 0 and
- then add 2 to it and print 2 on console and so on upto value of i becomes equal to 1000.
-
- Our final program to print even numbers from 0 to 1000 will look like this.
-
- ``` c++
- #include
-using namespace std;
-int main()
-{
- for (int i = 0;i<=1000;i=i+2)
- {
- cout << i << endl;
- }
- return 0;
-}
- ```
diff --git a/client/src/guide/english/cplusplus/map/index.md b/client/src/guide/english/cplusplus/map/index.md
deleted file mode 100644
index 806e419331..0000000000
--- a/client/src/guide/english/cplusplus/map/index.md
+++ /dev/null
@@ -1,79 +0,0 @@
----
-title: Map
----
-
-## Introduction of map
-
-`map` is an associative container that store elements in key-value pair. Just like in `Java` have collection, associative array in PHP and so on.
-
-## Benefits of using map
-* It stores only unique keys and that too in sorted order based on its assigned sorting criteria.
-* As keys are in sorted order therefore searching element in map through key is very fast i.e. it takes logarithmic time.
-* In `map` there will be only one value attached with the every key.
-* `map` can be used as associative arrays.
-* It might be implemented using balanced binary trees.
-
-Here is an example:
-
-```c++
-#include
-#include
-
-using namespace std;
-
-int main (){
- map first;
-
- //initializing
- first['a']=10;
- first['b']=20;
- first['c']=30;
- first['d']=40;
-
- map::iterator it;
- for(it=first.begin(); it!=first.end(); ++it){
- cout << it->first << " => " << it->second << '\n';
- }
-
- return 0;
-}
-```
-
-Output:
-```
-a => 10
-b => 20
-c => 30
-d => 40
-```
-
-## Creating map object
-` map myMap; `
-
-## Insertion
-Inserting data with insert member function.
-
-```c++
-myMap.insert(make_pair("earth", 1));
-myMap.insert(make_pair("moon", 2));
-```
-
-We can also insert data in std::map using operator [] i.e.
-
-`myMap["sun"] = 3;`
-
-## Accessing map elements
-
-To access map elements, you have to create iterator for it. Here is an example as stated before.
-```c++
-map::iterator it;
-for(it=first.begin(); it!=first.end(); ++it){
- cout << it->first << " => " << it->second << '\n';
-}
-```
-
-Here you can learn more about map: cpluspluc_map
-
-N.B: All code in example are in C++11 version. You can learn more about C++ version Here
-
-
diff --git a/client/src/guide/english/cplusplus/stack/index.md b/client/src/guide/english/cplusplus/stack/index.md
deleted file mode 100644
index 1f550ecc07..0000000000
--- a/client/src/guide/english/cplusplus/stack/index.md
+++ /dev/null
@@ -1,165 +0,0 @@
----
-title: stack
----
-
-## Stacks
-
-`stack` is one of the most used containers in C++. A container is a data structure that stores a collection of objects, some in order, some not. All containers have a different set of functions that allow you to access an object(s) in that collection.
-
-`std::stack` is part of the C++ standard library (hence the prefix `std::`) and allows you to store data in Last In First Out (LIFO) order. NOTE: **All objects within a stack must be of the same data type**
-
-The data type you store within a stack goes within angle brackets next to the stack keyword. For example, if you would like to store a collection of integers the stack would be `std::stack stack_name`
-
-### Stack LIFO Explanation
-
-`stack` allows us to push and pop in specific order. **Push** means inserting an object at the top of the stack. **Pop** means pulling out the last inserted object from the top of the stack. So when you push it is at the top and when you pop you extract the last inserted element.
-
-
-
-### Stack Operations
-
-The stack container supports the following operations:
- - push
- - pop
- - empty
- - size
- - back
-
-#### Push
-
-Allows you to insert a new element at the top of the stack, above the current top element.
-
-```cpp
-//Push operation in Stack
-#include // std::cout
-#include // std::stack
-
-int main ()
-{
- std::stack s;
-
- s.push(1); //Pushing 1 at top of the stack
- s.push(2); //Pushing 2 at top of the stack
-
- return 0;
-}
-```
-
-#### Top
-
-Allows you to access the the top element without removing it from your stack.
-
-```cpp
-//Top operation in Stack
-#include // std::cout
-#include // std::stack
-
-int main ()
-{
- std::stack s;
-
- s.push(1); //Pushing 1 at top of the stack
- s.push(2); //Pushing 2 at top of the stack
-
- std::cout< // std::cout
-#include // std::stack
-
-int main ()
-{
- std::stack s;
-
- s.push(1); //Pushing 1 at top of the stack
- s.push(2); //Pushing 2 at top of the stack
-
- std::cout< // std::cout
-#include // std::stack
-
-int main ()
-{
- std::stack s;
-
- s.push(1); //Pushing 1 at top of the stack
- s.push(2); //Pushing 2 at top of the stack
-
- std::cout< // std::cout
-#include // std::stack
-
-int main ()
-{
- std::stack s;
-
- s.push(1);
- s.push(2);
-
- while(s.empty() != false){
- std::cout<
-using namespace std :
-int main()
-{
- cout << "I Love freeCodeCamp ! ";
-}
-```
-
-The above code returns an error because at line 2, we have used a colon(:) instead of a semicolon(;)
-So, let's debug the error:
-
-```C++
-#include
-using namespace std ;
-int main()
-{
- cout << "I Love freeCodeCamp ! ";
- return 0;
-}
-
-```
-
-Note that now the program runs perfectly.
-The output will be : `I Love freeCodeCamp!`
-
-### Now , let's change the text to something else like this:
-
-```cpp
- cout << "Hello World!\t I love freeCodeCamp!";
-```
-
-The output will be something different this time:
-
-```
-Hello World! I love freeCodeCamp!
-```
-
-If you realised , the `\t` command created a _tab space_ between the two texts . This is one kind of special command in C++. These special commands are known as *Escape Sequences* .
-They are used to print certain special characters a compiler cannot display.
-
-#### Useful escape sequences:
-
-* `\'` to print a single inverted comma
-* `\"` to print a double inverted comma
-* `\n` to print on a new line
-* `\t` for a horizontal tab
-* `\f` for a new page
-* `\\` for a backslash
-* `\?` for a question mark
-
-##### Now, let's try printing numbers and special characters with some escape sequences:
-
-```cpp
- cout << "40158 \t 236708 ! \n \\ @ \?" << endl;
-```
-
-The output changes to:
-```
-40158 236708 !
- \ @ ?
-```
-
-##### Let's try some other ways of printing:
-
-```cpp
- cout << "1+2" << endl;
- cout << 1+2 << endl;
-```
-
-Output:
-
-* The first output statement is `1+2`
-* The second output statement is `3`
-
-This is because we did not add the inverted commas for the second print statement and so, the compiler added the numbers before printing them.
-
-#### Comments:
-
-* Comments are an important feature of many programming languages. They allow the programmer to take notes for self help, and won't affect the running of the program.
-
-**The different types of comments and Syntax of a comment**:
-
- 1 `//` ~ _Single Line Comments_ : The length of these comments is 1 line (the line it is typed on) .
- 2 `/* */` ~ _Multi Line Comments_ : These comments can take up a space of more than one line.
-
-#### Example of using comments:
-
- ```cpp
- cout << "Hello Comment" << endl; //cout<<"Hello Comment"<` greater than
-* `<=` less than or equal to
-* `>=` greater than or equal to
-
-```cpp
- (7==5);
-```
-This evaluates to false
-
-```cpp
- (7!=5);
-```
-This evaluates to true
-
-A summation of all the print statements used in this article. Feel free to tweak around woth the code ! :)
diff --git a/client/src/guide/english/cplusplus/the-auto-feature/index.md b/client/src/guide/english/cplusplus/the-auto-feature/index.md
deleted file mode 100644
index f577b4a949..0000000000
--- a/client/src/guide/english/cplusplus/the-auto-feature/index.md
+++ /dev/null
@@ -1,73 +0,0 @@
----
-title: The Auto Feature
----
-
-## The Auto Feature
-
-`auto` is a C++11 feature that lets the compiler infer the data type for you in a definition. This can save you a lot of typing, especially with complicated types.
-
-Without `auto`:
-```cpp
-double x = 10.425;
-double y = x * x;
-```
-
-With `auto`:
-```cpp
-double x = 10.425;
-auto y = x * x;
-```
-
-While it may seem trivial, it becomes incredibly useful when data types begin to get complicated. For example, assume you want to store a [`vector`](https://guide.freecodecamp.org/cplusplus/vector) of employees, and you are only interested in their name and age. One way to store the name and age could be a `pair` with a `string` and an `unsigned int`. This is declared as `std::vector> employees`. Now suppose you want to access the last employee added:
-
-```cpp
-std::vector> employees;
-
-// without auto, you have to write:
-std::pair> last_employee = employees.back();
-
-// with auto, you just have to write:
-auto last_employee = employees.back();
-```
-
-Once the compiler determines the type on the right side of the `=` it replaces `auto` with that type.
-
-In modern versions of C++ (since C++14), `auto` can also be used in a function declaration as the return type. The compiler will then infer the return type from the return statement inside of the function. Following the example with employees:
-
-```
-std::vector> employees;
-auto get_last_employee() {
- return employees.back(); // Compiler knows the return type from this line.
-}
-```
-The compiler will know from the line with the return statement that the return type from the function should be `std::vector>`.
-
-While quite technical, the [cppreference page on auto](http://en.cppreference.com/w/cpp/language/auto) describes many more usages of `auto` and the details of when it can and can't be used.
-
-### `auto` before C++11
-In some old textbooks containing _very_ old code, the keyword `auto` is used in a very different manner.
-
-This particular `auto` was a keyword borrowed from C, and was probably the least used keyword of all time.
-
-In C++, all variables have _automatic duration_, that is, they are defined until you get out of the function they're defined in.
-
-For example:
-
-```cpp
-#include
-
-int main()
-{
- int a;
- a = 1; //makes sense, as it was defined in the same function
-
- return 0;
- }
- a = 2; //makes no sense, since a isn't defined here
- ```
-
- This is a given in C++, and `auto` specified that the variable should have an _automatic duration_, hence the lack of use.
-
-## Further Reading :
-* http://www.stroustrup.com/C++11FAQ.html#auto
-
diff --git a/client/src/guide/english/cplusplus/the-if-statement/index.md b/client/src/guide/english/cplusplus/the-if-statement/index.md
deleted file mode 100644
index 0532e6b0d5..0000000000
--- a/client/src/guide/english/cplusplus/the-if-statement/index.md
+++ /dev/null
@@ -1,104 +0,0 @@
----
-title: C++ If Statement
----
-
-# The IF statement.
-
-**What does an if statement do?**
-
-* The `if` statement evaluates the test expression present inside the parenthesis.
-* The `if` statement uses relational and logical operators to make logical expressions.
-
- -----------------------------------------------
- The general form of `if` statement:
-
-```cpp
- if (Test Expression / Condition)
- {
- // Block of statements if test expression is True
- }
-```
-
-If the value of the test expression is **true**, then the block of
-code inside the if statement is executed.
-
-If the value of the test expression is **false**, then the block of
-code inside the if statement is skipped and your code continues.
-
-Example `if` statement:
-
-```cpp
- int a = 10;
-
- // true statement
- if (a < 20)
- {
- // execute this block of code
- }
-
- // false statement
- if (a < 0)
- {
- // Skip this block of code.
- }
-```
-
-
-Example In C++ :
-
-```cpp
- // Program to check if number entered by the user is positive
- // If negative, the block of code is skipped
-
- #include
- using namespace std;
-
- int main()
- {
- int no ;
- cout << "Enter a number: ";
- cin >> no;
-
- // if statement to check if the number is positive
- if ( no > 0)
- {
- cout << "You have entered a positive number: " << no << endl;
- }
-
- // If number is not positive, then if statement is skipped a program continues
- cout << "This step is always printed" << endl;
-
- return 0;
- }
-```
-
-
-**Output:**
-
-OUTPUT 1:
-
-```
-Enter a number: 5
-You have entered a positive number: 5
-This step is always printed
- ```
-This is the output when the number entered is positive.
-
-OUTPUT 2:
-
-```
-Enter a number: -1
-This step is always printed
-```
-This is the output when the number entered is negative.
-
-Try the code yourself ! :)
-
-
-_CONGRATULATIONS . This is the end of the article on the IF statement_
-
- **Good Luck to all of you**
-
- **Happy Coding ! :)**
-
- **Feel free to ask any queries on FreeCodeCamp's GitHub page or [FreeCodeCamp's Forum .](https://forum.freecodecamp.org/)**
diff --git a/client/src/guide/english/cplusplus/vector/index.md b/client/src/guide/english/cplusplus/vector/index.md
deleted file mode 100644
index 5ad881cdd2..0000000000
--- a/client/src/guide/english/cplusplus/vector/index.md
+++ /dev/null
@@ -1,216 +0,0 @@
----
-title: Vectors
----
-
-## Vectors
-
-The C++ `vector` is one of the most used containers in C++. A container is a data structure that stores a collection of objects that can vary from being ordered(like `vector`!) to unordered(like `set`). All C++ containers have a different set of functions that allow you to access an object(s) in that collection, modify and loop over the elements in that data structure.
-
-Vectors are similar to ArrayLists in Java since you don't have to specify the length of the container. Compared to an array where you have to define how large it is, its size depends on its contents.
-
-`std::vector` is part of the C++ standard library (hence the prefix `std::`) and allows you to store contiguous data of the same data type. NOTE: **All objects within a vector must be of the same data type**
-
-The data type you store within a vector goes within angle brackets next to the vector keyword. For example, if you would like to store a collection of strings the vector would be `std::vector vector_name`
-
-*NOTE*: You must include the vector library whenever using vectors!
-
-`#include `
-
-### Vector Construction
-There are many convinent ways to construct a vector.
-
-Using an intializer list - where objects are listed inside a set of braces: `{ }`
-```cpp
-std::vector a{1, 2, 3, 4, 5}; // a is a vector of 5 ints: 1, 2, 3, 4 and 5
-std::vector b{"hello", "world"}; // b is a vector of 2 strings: "hello" and "world"
-std::vector v; // v is an empty vector
-```
-
-Constructing it from another vector (this is known as a copy construction)
-```cpp
-std::vector a{1.0, 2.0, 3.0};
-std::vector b(a); // b is a vector of 3 doubles: 1.0, 2.0 and 3.0
-```
-
-Initializing it with the same element:
-```cpp
-std::vector a(100, -1); // a is a vector of 100 elements all set to -1
-```
-
-### Vector Iterators
-
-Iterators can be thought of as pointers specifically used for navigating containers
-(such as vectors). The most important iterators are `begin()` and `end()`.
-`begin()` returns a pointer to the first item in a vector whereas `end()` points
-to one position after the last item in a vector. As such looping through a
-vector can be done as :
-
-```cpp
-std::vector vec{1, 2, 3};
-
-for(auto vec_it = vec.begin(); vec_it != vec.end(); it++){
- // since vec_it is a pointer and points to the memory address of the item
- // inside the vector, vec_it must be dereferenced using '*'
- std::cout << *it << '\n';
-}
-/* Output
- 1
- 2
- 3
-*/
-```
-
-### Modifying a Vector
-
-Pushing items to a vector:
-```cpp
-std::vector vec; // constructs an empty vector
-
-for (int i = 0; i < 10; i = i + 2){
- vec.push_back(i);
-}
-// vec now holds [0, 2, 4, 6, 8]
-```
-
-Inserting an item in a particular position is slightly different. The C++ vector insert
-function works on iterators. It will insert the given item one position before the given
-iterator.
-
-```cpp
-std::vector vec{3, 400, 12, 45};
-
-auto iter = vec.begin() + 2; // iter now points to '12'
-vec.insert(iter, 38); // inserts '38' before '12'
-
-// vec: [3, 400, 38, 12, 45]
-```
-
-### Element Access
-The standard library provides different functions for accessing particular elements in your vector.
-
-```cpp
-std::vector a{"test", "element", "access"};
-
-std::string first_item = a.front(); // gets the first item of the vector ("test")
-std::string last_item = a.back(); // gets the last item in the vector ("access")
-
-// To get an element at a specific index (remember: vector indices start at 0)
-std::string second_item = a.at(2); // gets "element"
-// OR
-std::string second_item = a[2]; // gets "element"
-```
-
-### Looping over elements in a `vector`
-
-Looping over elements in a C++ `std::vector` is pretty different from looping over elements in a vector in JavaScript or Ruby. Due to C++ being a thin abstraction of C, you can only loop over elements using these nifty little variables called iterators to access each element.
-Iterators often come in the form of pointers which are variables that store the memory address of another variable. You can learn more about pointers [here](https://www.tutorialspoint.com/cplusplus/cpp_pointers.htm).
-However, because iterators act as pointers (or vice-versa), in order to see what they point to, you need to dereference it into a variable of the appropirate type.
-How do we do this?
-HERE. WE. GO!
-```cpp
-std::vector a{"test", "element", "access"};
-for(auto it = v.begin(); it != v.end(); it++) { //notice use of auto keyword
- cout<<*it< v;
-//Iterator delcaration for the above vector will correspond to
-std::vector::iterator it;
-```
-Using the iterator to print elements of the vector using for loop
-```cpp
-for(it=v.begin(); it!=v.end(); ++it)
-//std::vector::begin and std::vector::end return iterator pointing to first and last element of the vector respectively.
- cout<<*it;
-```
-
-### Iterating Through a Vector
-There are different ways to iterate through a vector and access its contents. The following forms are equivalent, the first one involves using a range-based expression (since C++11), the second one uses iterators, and the last one is a index-based iteration
-
-``` cpp
-#include
-#include
-
-// First declare the vector
-std::vector myVector{1, 2, 3, 4, 5}; // a is a vector of 5 ints: 1, 2, 3, 4 and 5
-
-// Using a range based loop (since C++11)
-for(int element : myVector ){ // Reads like "for every element in myVector"
- std::cout << "The element is " << element << std::endl;
-}
-
-// Using an iterator
-std::vector::iterator it; // Declare the iterator
-for(it = myVector.begin(); it != myVector.end(); ++it){
- std::cout << "The element is " << *it << std::endl; // Dereference the iterator to access its data
-}
-
-// Using indices
-for(std::vector::size_type i = 0; i != myVector.size(); i++){
- std::cout << "The element is " << myVector[i] << std::endl; // Dereference the iterator to access its data
-}
-
-```
-### Sorting A Vector In Ascending Order
-Sorting a vector based on ascending order can be done with the help of Sort() in C++.
-``` cpp
-#include
-#include
-#include
-using namespace std;
-
-int main(){
-
- vector v{ 10, 5, 82, 69, 64, 70, 3, 42, 28, 0 };
- sort(v.begin(), v.end());
-
- cout << "Vector Contents Sorted In Ascending Order:\n";
- for(int e : v){
- cout << e << " ";
- }
-
- return 0;
-}
-```
-### Sorting Vector In Descending Order
-Sorting Vector in descending order can be done with the help of third argument namely greater() in Sort() in C++.
-``` cpp
-#include
-#include
-#include
-using namespace std;
-
-int main(){
-
- vector v{ 10, 5, 82, 69, 64, 70, 3, 42, 28, 0 };
- sort(v.begin(), v.end(), greater());
-
- cout << "Vector Contents Sorted In Ascending Order:\n";
- for(int e : v){
- cout << e << " ";
- }
-
- return 0;
-}
-```
diff --git a/client/src/guide/english/cplusplus/while-loop/index.md b/client/src/guide/english/cplusplus/while-loop/index.md
deleted file mode 100644
index 6a661e688e..0000000000
--- a/client/src/guide/english/cplusplus/while-loop/index.md
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title:While-loop
----
-
-A while loop statement repeatedly executes a target statement as long as a given condition is true.
-
-Syntax:
-while(condition) {
- statement(s);
-}
-
-A key point of the while loop is that the loop might not ever run.
-When the condition is tested and the result is false, the loop body will be skipped and the first statement after the while loop will be executed.
-
-
-Example:
-
-```C++
-#include
-using namespace std;
-
-int main () {
- // Local variable declaration:
- int a = 10;
-
- // while loop execution
- while( a < 20 ) {
- cout << "value of a: " << a << endl;
- a++;
- }
-
- return 0;
-}
-```
-
-Output:
-
-value of a: 10
-value of a: 11
-value of a: 12
-value of a: 13
-value of a: 14
-value of a: 15
-value of a: 16
-value of a: 17
-value of a: 18
-value of a: 19
-
-
-###Sources
-www.tutorialspoint.com
diff --git a/client/src/guide/english/csharp/array/index.md b/client/src/guide/english/csharp/array/index.md
deleted file mode 100644
index e923f06ed7..0000000000
--- a/client/src/guide/english/csharp/array/index.md
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: Arrays
----
-
-# Arrays
-
-An array is used to store a collection of data of the same type. This can be used as a single variable that holds multiple values, or a collection of variables.
-
-# Rules of Arrays
-
-Arrays start from zero. The first element of an array is 0, the second element is 1, the third element 2, and so on.
-
-Arrays must be of the same data type. You can use any data type in an array (e.g. int, double, float, string, enum)
-
-A new Array must first be declared and initialised before it can be called and accessed.
-
-# Declaring an Array
-
-Use the following format for declaring arrays:
-`dataType [] nameOfArray;`
-
-# Initialising an array
-
-Use the following format for initialising an array. This method also declares the array and states how many values are to be stored into the array.
-
-`dataType [] nameOfArray = new nameOfArray[numberOfElements];`
-
-# Assigning values to an array
-
-You can assign a value into an element directly by using the format below:
-
-`nameOfArray[2] = 50;`
-
-The will assign the value of 50 directly into element [2]
-
-
-You can assign multiple values at once while declaring the array using the format below:
-
-`dataType [] nameOfArray = {5,17,19,92};`
-
-The will assign the value of 5 into element [0], 17 into element [1], 19 into element [2] and 92 into element [3].
-
-You can declare, initilise and assign values in the array all at once by using the format below:
-
-`dataType [] nameOfArray = new nameOfArray[numberOfElements] {value1,value2,value3,value4};`
-
-You can store an array directly into another array by using the format below:
-
-`int [] nameOfArray = new nameOfArray[4] {2,9,56,1280};`
-`int [] nameOfSecondArray = nameOfArray;`
-
diff --git a/client/src/guide/english/csharp/async-await/index.md b/client/src/guide/english/csharp/async-await/index.md
deleted file mode 100644
index 30461b55a2..0000000000
--- a/client/src/guide/english/csharp/async-await/index.md
+++ /dev/null
@@ -1,68 +0,0 @@
----
-title: Async / Await
----
-
-# Async / Await Keywords
-
-The `async`/`await` keywords in C# provide convenient ways of managing resources-intensive applications, which are more common in front-end languages such as Javascript libraries. Methods that return `Task` types can be crowned with the `async` keyword, and when calling these methods in an UI handler or service workflow, we can use the `await` on the methods to tell C# to yield the control back to its caller until the background job is finished. By yielding the control on resources-intensive calls, we are able to allow UI to be more responsive and make the service more elastic.
-
-The core of the `async` and `await` are the `Task` class. When using it along with the `async` keyword as the return type of a method, we indicate that the method has promised to return an object of the `T` type (for methods that wouldn't return any value, use `Task` as the return type instead). `Task` is a sophisticated topic of its own, for more information, please refer to the official documents: [Task Class](https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.task?view=netframework-4.7.1).
-
-Once encountering `async` methods, the work will be queued in a thread-pool for execution, while the caller will continue its execution without waiting on the return values from the `async` methods. However, in most occasions, our UI and service rely on the values returned from the `async` methods: for example, when we query a local database using the `async` methods, we would eventually want to know what are the query results and act on them, synchronously. This is where the `await` keyword shall be used: if using the `await` keyword when invoking an `async` method, the caller will pause the execution until a result is returned from the `async` method, and mean while, the parent method will continue execution without waiting on the caller to finish. With that said, any methods that uses `await` keyword have to be an `async` function themselves -- this is enforced by the C# compiler as well, if using Visual Studio to write your C# code, the IDE will warn you if a method violate the `async-await` contract.
-
-To learn more about using the promise model to handle asynchrony, check out this wikipedia page: [Achieving Asynchrony through Promises](https://en.wikipedia.org/wiki/Futures_and_promises)
-
-## Examples
-
-1. Submit Form to the Server
-```csharp
-private readonly string url = 'http://localhost:3000/api/submit';
-private readonly HttpContent formContent = new HttypContent();
-
-// Update the formContent object while filling up the form.
-
-SubmitButton.Clicked += async (object, event) =>
-{
- // When PostAsync is hit, the button control will release the UI, while the
- // http post method is still waiting on server response.
- HttpClient httpClient = new HttpClient();
- var response = await httpClient.PostAsync(url, formContent);
- Console.WriteLine(response.StatusCode);
-}
-```
-
-2. "Latches" Synchronizer
-```csharp
-public async Task CalcDamage(Player player)
-{
- // CPU-intense method, calculate afflicted damage done to the
- // Boss based on the damage types, Boss stats (from static data),
- // player stats, etc.
- // ...
-}
-
-public static async Task CalcTotalDamage(IEnumerable group)
-{
- var totalDamage = 0;
- foreach (Player player in group)
- {
- // each of the async methods are queued in the thread-pool and move on.
- totalDamage += CalcDamage(player);
- }
-
- // total damage done must be calculated from all players in the group
- // before we return the result.
- return await Task.WhenAll(totalDamage);
-}
-```
-
-## Cheat-sheet
-- await: retrieve the result from a background async call.
-- await Task.WhenAny: continue if any of the queued tasks is complete.
-- await Task.WhenAll: only continue if all of the queued tasks are complete.
-- await Task.Delay: hold for an additional period of time before execution.
-
-## In-depth read:
-- [Asynchronous programming](https://docs.microsoft.com/en-us/dotnet/csharp/async)
-- [Async in depth](https://docs.microsoft.com/en-us/dotnet/standard/async-in-depth)
-- [3 essential tips for asnyc](https://channel9.msdn.com/Series/Three-Essential-Tips-for-Async)
diff --git a/client/src/guide/english/csharp/hello-world/index.md b/client/src/guide/english/csharp/hello-world/index.md
deleted file mode 100644
index b4e840256f..0000000000
--- a/client/src/guide/english/csharp/hello-world/index.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: Hello World
----
-
-# Hello World
-
-To write some text on console we use the `Console.WriteLine()`. This method takes a string as input.
-
-## Example
-```csharp
-using System;
-
-namespace HelloWorld
-{
- class Hello
- {
- static void Main()
- {
- // Write "Hello World!" on console
- Console.WriteLine("Hello World!");
-
- // Keep the console window open in debug mode.
- Console.WriteLine("Press any key to exit.");
- Console.ReadKey();
- }
- }
-}
-
-```
-
-## Output:
-```sh
-> Hello World!
-> Press any key to exit.
-```
diff --git a/client/src/guide/english/csharp/if-else-statement/index.md b/client/src/guide/english/csharp/if-else-statement/index.md
deleted file mode 100644
index acb113f605..0000000000
--- a/client/src/guide/english/csharp/if-else-statement/index.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: If Else Statement
----
-
-# If Else Statement
-
-The If-Else statement executes a block of code depending if your precondition is fullfilled or not.
-
-## Example
-```
-
-if(boolean expression)
-{
-// execute this code block if expression evalutes to true
-}
-else
-{
-// always execute this code block when above if expression is false
-}
-
-
-int Price = 30;
-
-If (Price = 30)
-{
- Console.WriteLine("Price is equal to 30.");
-}
-
-Else
-{
- Console.WriteLine("Price is not equal to 30.");
-}
-```
-
-Since we already declared our int Price to be 30, this will be the expected output.
-
-## Output
-```
-Price is equal to 30.
-```
diff --git a/client/src/guide/english/csharp/switch-case/index.md b/client/src/guide/english/csharp/switch-case/index.md
deleted file mode 100644
index 221dda067e..0000000000
--- a/client/src/guide/english/csharp/switch-case/index.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: Switch Case
----
-
-# Switch Case
-
-Switch is a selection statement that chooses a switch case section depending on the value matched with the expression/value being evaluated.1 If none of the case statements match the value of the switched variable, the default path is chosen. The switch statement is like a set of `if statements`. We exit from the switch by `break`.
-
-## Example
-```
-public enum Colors { Red, Blue, Green, Orange }
-
-Colors myColor;
-
-... myColor is set to one of the enum values ...
-
-switch(myColor){
- case Colors.Red:
- Console.WriteLine("How you like them apples?");
- break;
- case Colors.Blue:
- Console.WriteLine("Ice Ice Baby...");
- break;
- case Colors.Green:
- Console.WriteLine("Fore!");
- break;
- default:
- Console.WriteLine("I have a hard time when I try to rhyme.");
-}
-```
-
-## Output
-```
-If myColor is Colors.Red:
-> How you like them apples?
-
-If myColor is Colors.Blue:
-> Ice Ice Baby...
-
-If myColor is Colors.Green:
-> Fore!
-
-If myColor is Colors.Orange:
-> I have a hard time when I try to rhyme.
-
-```
-
-### Sources:
-- 1 https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/switch
diff --git a/client/src/guide/english/css/background-size/index.md b/client/src/guide/english/css/background-size/index.md
deleted file mode 100644
index cefd4a440c..0000000000
--- a/client/src/guide/english/css/background-size/index.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Background Size
----
-## Background Size
-
-The background-size property specifies the size of the background images. You can set a length or a percentage, with the first value being the width and the second one being the height. You can also use one of the 5 keyword values:
-
-```css
-.auto {background-size: auto;}
-.cover {background-size: cover;}
-.contain {background-size: contain;}
-.initial {background-size: initial;}
-.inherit {background-size: inherit;}
- /* Percentage and pixel can also be used */
-.pixel {background-size: 50px 50px;}
-.percentage {background-size: 50% 50%;}
-```
-
-To set this property on multiple background images separate values by comma:
-```css
-.multiple {
- background-image: url(1.png), url(2.png);
- background-size: 3px 3px, cover;
-}
-```
-
-#### More Information:
-
-Documentation: MDN
-
-CSS-Tricks: background-size
-
-Browser Support: caniuse
diff --git a/client/src/guide/english/css/css-buttons/index.md b/client/src/guide/english/css/css-buttons/index.md
deleted file mode 100644
index 67da850100..0000000000
--- a/client/src/guide/english/css/css-buttons/index.md
+++ /dev/null
@@ -1,108 +0,0 @@
----
-title: CSS Buttons
----
-## CSS Buttons
-
-* You can style any clickable button (HTML `` element)
-
-`Click Me `
-
-* The default button looks like the following:
-
-
-
-## Styling a Button
-
-You can change several properties of a button in order to change its appearance.
-
-To add shadows to the button use `box-shadow` property.
-
-To add transparency to a button for a disabled effect use the property `opacity`.
-
-To remove the margins and create a button group add `float:left/right` property.
-
-To create a button group but with the borders, use `float` property and add a `border property`.
-
-To create a vertical group of buttons use display:`block property`.
-
-### Button Color
-
-To change the background color of a button, use the background-color property:
-
-`button {background-color: #6ba0f4;}`
-
-
-
-To add a colored border to a button, use the border property:
-
-```
-button {
- background-color: #FFF;
- color: #FFF;
- border: 2px solid #6ba0f4;
-}
-```
-
-
-
-### Button Text Size
-
-To change the text font size of a button, use the font-size property:
-
-`button {font-size: 20px;}`
-
-
-
-### Button Padding
-
-To change the padding of a button, use the padding property:
-
-`button {padding: 15px 30px;}`
-
-
-
-### Button Width
-
-To change the width of a button, regardless the text content, use the width property:
-
-`button {width: 250px;}`
-
-
-
-### Rounded Buttons
-
-To create rounded buttons, use the border-radius property:
-
-`button {border-radius: 50%;}`
-
-
-
-### Hoverable Buttons
-
-To change the style of a button when you move the mouse over it, use the :hover selector:
-
-```
-button:hover {
- background-color: #0E2C5B;
- color: #FFF;
-}
-```
-
-
-
-To determine the speed of the hover effect use the property `transition-duration`.
-
-### Disabled Buttons
-
-To disable a button, use the cursor property:
-
-```
-button {
- cursor: not-allowed;
-}
-```
-
-#### More Information:
-* https://www.w3schools.com/css/css3_buttons.asp
-* https://www.w3schools.com/howto/howto_css_animate_buttons.asp
-
diff --git a/client/src/guide/english/css/css-cursors/index.md b/client/src/guide/english/css/css-cursors/index.md
deleted file mode 100644
index 87becff213..0000000000
--- a/client/src/guide/english/css/css-cursors/index.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: CSS Cursors
----
-## CSS Cursors
-
-The cursor property specifies the type of cursor to be displayed when you hover over an element. It has 36 possible values:
-```css
- .auto { cursor: auto; }
- .default { cursor: default; }
- .none { cursor: none; }
- .context-menu { cursor: context-menu; }
- .help { cursor: help; }
- .pointer { cursor: pointer; }
- .progress { cursor: progress; }
- .wait { cursor: wait; }
- .cell { cursor: cell; }
- .crosshair { cursor: crosshair; }
- .text { cursor: text; }
- .vertical-text { cursor: vertical-text; }
- .alias { cursor: alias; }
- .copy { cursor: copy; }
- .move { cursor: move; }
- .no-drop { cursor: no-drop; }
- .not-allowed { cursor: not-allowed; }
- .all-scroll { cursor: all-scroll; }
- .col-resize { cursor: col-resize; }
- .row-resize { cursor: row-resize; }
- .n-resize { cursor: n-resize; }
- .e-resize { cursor: e-resize; }
- .s-resize { cursor: s-resize; }
- .w-resize { cursor: w-resize; }
- .ns-resize { cursor: ns-resize; }
- .ew-resize { cursor: ew-resize; }
- .ne-resize { cursor: ne-resize; }
- .nw-resize { cursor: nw-resize; }
- .se-resize { cursor: se-resize; }
- .sw-resize { cursor: sw-resize; }
- .nesw-resize { cursor: nesw-resize; }
- .nwse-resize { cursor: nwse-resize; }
-```
-
-
-
-You can also set an image as the cursor.
-
-```
-.custom-cursor {
- cursor: url(cursor-image.png);
-}
-```
-
-#### More Information:
-* Check the above cursor values in action: codepen
-* Mozilla Developer Network: MDN
-* Browser Support: caniuse
-* Cursor examples by w3schools: w3schools
diff --git a/client/src/guide/english/css/css-images/index.md b/client/src/guide/english/css/css-images/index.md
deleted file mode 100644
index 009b69043d..0000000000
--- a/client/src/guide/english/css/css-images/index.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: CSS Images
----
-## CSS Images
-This helps in adding an image to a website.
-
-
-####Code Sample
-
-```image-orientationimage-renderingobject-fitobject-positionlinear-gradient()radial-gradient()repeating-linear-gradient()repeating-radial-gradient()element()<image><uri>Linear Gradient - Top to Bottom
-This linear gradient starts at the top. It starts red, transitioning to yellow:
-
-
-
-Note: Internet Explorer 9 and earlier versions do not support gradients.
-
-
-
-```
-
-
-
-##### Linear Gradient - Left to Right
-The following example shows a linear gradient that starts from the left. It starts red, transitioning to yellow:
-
-
-#### Example
-
-```
-
-
-
-
-
-
-
-Linear Gradient - Left to Right
-This linear gradient starts at the left. It starts red, transitioning to yellow:
-
-
-
-Note: Internet Explorer 9 and earlier versions do not support gradients.
-
-
-
-```
-
-
-
-#### Linear Gradient - Diagonal
-
-You can make a gradient diagonally by specifying both the horizontal and vertical starting positions.
-
-The following example shows a linear gradient that starts at top left (and goes to bottom right). It starts red, transitioning to yellow:
-
-
-
-#### Example
-
-```
-
-
-
-
-
-
-
-Linear Gradient - Diagonal
-This linear gradient starts at top left. It starts red, transitioning to yellow:
-
-
-
-Note: Internet Explorer 9 and earlier versions do not support gradients.
-
-
-
-```
-
-
-
-#### More Information:
-
-[MDN Documentatiion](https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient) || [w3schools](https://www.w3schools.com/css/css3_gradients.asp)
\ No newline at end of file
diff --git a/client/src/guide/english/css/css3-grid-layout/index.md b/client/src/guide/english/css/css3-grid-layout/index.md
deleted file mode 100644
index b2dba175ab..0000000000
--- a/client/src/guide/english/css/css3-grid-layout/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: CSS Grid Layout
----
-## CSS Grid Layout
-CSS Grid Layout is the most powerful layout system available in CSS.
-It is a 2-dimensional system, meaning it can handle both columns and rows, unlike flexbox which is largely a 1-dimensional system.
-Though Grid Layout isn't fully supported by all browsers, it's the most advanced and conveniet way to make page layouts.
-
-#### More Information:
-For more information, read
-A Complete Guide to CSS Grid Layout by Chris House.
-
-More info about browser support can be read at https://caniuse.com .
diff --git a/client/src/guide/english/css/css3-media-queries/index.md b/client/src/guide/english/css/css3-media-queries/index.md
deleted file mode 100644
index c0d213afb9..0000000000
--- a/client/src/guide/english/css/css3-media-queries/index.md
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: CSS3 Media Queries
----
-## CSS3 Media Queries
-
-Media Queries allow you to have different styles for different devices/screen sizes. Their introduction in CSS3 has greatly eased the building
-of responsive webpages.
-
-The best approach when designing a responsive website is to think mobile first; meaning that you create your page starting with the design and content
-of the mobile version. You may think that with some scalable sizes ( %, vw or vh ), your page will adapt perfectly to any device. But it will not. Maybe
-for some very basic design, but certainly not for more common or complex pages!
-
-When designing your page for smaller devices, you will focus on the main content. On a bigger screen, you will have to readapt some font-sizes, margins,
-paddings and so on in order to keep your site comfortable and readable, but you will also want/need to add more content, the ones you did not judge
-fundamental, and fill in the space created by the screen size.
-
-The thought process should be:
-1. Which content to show?
-2. How to layout?
-3. Size?
-
-### The basic syntax
-
-```css
- @media only screen and (min-width: 768px) {
- p {padding: 30px;}
- }
-```
-
-The `p` tag will have a padding of 30px as soon as the screen reaches min 768px width.
-
-### The AND syntax
-
-
-```css
- @media only screen and (min-height: 768px) and (orientation: landscape) {
- p {padding: 30px;}
- }
-```
-
-The `p` tag will have a padding of 30px as soon as the screen reaches min 768px height and its orientation is landscape.
-
-### The OR syntax
-
-```css
- @media only screen and (min-width: 768px), (min-resolution: 150dpi) {
- p {padding: 30px;}
- }
-```
-
-The `p` tag will have a padding of 30px as soon as the screen reaches min 768px width or its resolution reaches min 150dpi.
-
-### More Information
-* [MDN - media queries](https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Using_media_queries)
-* [W3 Schools - @media rule](https://www.w3schools.com/cssref/css3_pr_mediaquery.asp)
-* [CSS Tricks Standard Device Widths Atricle](https://css-tricks.com/snippets/css/media-queries-for-standard-devices/)
-* [https://alistapart.com/article/responsive-web-design](Ethan Marcotte A List Apart Atricle on Responsive Web Design)
diff --git a/client/src/guide/english/css/fonts/index.md b/client/src/guide/english/css/fonts/index.md
deleted file mode 100644
index 57dfb3248a..0000000000
--- a/client/src/guide/english/css/fonts/index.md
+++ /dev/null
@@ -1,112 +0,0 @@
----
-title: Fonts
----
-## Fonts
-
-The CSS font properties define the font family, weight, size, variant, line height and style of a text.
-
-### Font family
-
-The font family of a text is simply set by using the `font-family` property.
-
-It works with a *fallback* system, if your browser does not support the first font, it tries with the next one and so on. If the name of the font is more than one word it must be surrounded by quotes.
-
-```css
-p {
- font-family: "Times New Roman", Times, serif;
-}
-```
-In the above example, "Times New Roman" is the of the font, while "serif" is the . Generic names are used as a fallback
-mechanism for preserving style if the family-name is unavailable. A generic name should always be the last item in the list of font family names. Generic
-family names are serif, sans-serif, monospace, cursive, fantasy, system-ui.
-
-### Font style
-
-The `font-style` property can be used to specify italic text.
-
-This property has 3 values:
-
-* normal - Text shown normally
-* italic - Text shown in *italic*
-* oblique - Text shown leaning
-
-```css
-.normal {
- font-style: normal;
-}
-
-.italic {
- font-style: italic;
-}
-
-.oblique {
- font-style: oblique;
-}
-```
-
-### Font size
-
-The `font-size` property sets the size of the text.
-
-There are different types of font size values:
-
-* `px` (pixels) - The default size of text being `16px`
-* `em` - `1em` = the current font size, so `1em` = `16px` (recommended by the W3C)
-* `small`, `medium`, `large` - known as absolute size values
-* `%` - percentages
-
-```css
-.with-pixels {
- font-size: 14px;
-}
-
-.with-ems {
- font-size: 0.875em;
-}
-
-.with-absolute {
- font-size: large;
-}
-
-.with-percentage {
- font-size: 80%;
-}
-```
-
-### Font weight
-
-The `font-weight`property specifies the weight (or boldness) of the font. Accepts keywords (`bold`, `normal`, `bolder`, `lighter`) or numeric keywords (`100`, `200`, `300`, `400` etc.) `400` is the same as `normal`.
-
-```css
-p {
- font-weight: bold
-}
-```
-
-### Font responsiveness
-
-The text size can be set with a vw(viewport width) unit.
-That way the text size will follow the size of the browser window.
-
-```html
-Hello World
-```
-`Viewport is the browser window size. 1vw = 1% of viewport width. If the viewport is 50cm wide, 1vw is 0.5cm.`
-
-
-
-### Font variant
-
-The `font-variant` property specifies if a text should be displayed in a small-caps font (where all lowercase letters are converted to uppercase letters while appearing in a smaller font-size than the original uppercase letters in the text).
-
-```css
-p.small {
- font-variant: small-caps;
-}
-```
-
-#### More Information:
-
-- [W3 Schools - CSS Font](https://www.w3schools.com/css/css_font.asp)
-- [MND - CSS Font](https://developer.mozilla.org/en-US/docs/Web/CSS/font)
-- [CSSFontStack](https://www.cssfontstack.com/)
diff --git a/client/src/guide/english/css/forms/index.md b/client/src/guide/english/css/forms/index.md
deleted file mode 100644
index 0f126036a8..0000000000
--- a/client/src/guide/english/css/forms/index.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: Forms
----
-## Forms
-
-HTML Form element defines a form that is used to collect user input.
-Examples:
-```html
-
-```
-An HTML form contains form elements.
-
-Form elements are different types of input elements, like text fields, checkboxes, radio buttons, submit buttons, and more.
-
-Inside the form tags there are also some important attribute which are:
--action : the page that the data will sent to
--method : type of request which are: 'GET' and 'POST'
-
-
-
-
diff --git a/client/src/guide/english/css/graceful-degradation/index.md b/client/src/guide/english/css/graceful-degradation/index.md
deleted file mode 100644
index 07aa038899..0000000000
--- a/client/src/guide/english/css/graceful-degradation/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Graceful Degradation
----
-## Graceful Degradation
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/css/progressive-enhancement/index.md b/client/src/guide/english/css/progressive-enhancement/index.md
deleted file mode 100644
index 614786429f..0000000000
--- a/client/src/guide/english/css/progressive-enhancement/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Progressive Enhancement
----
-## Progressive Enhancement
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/css/properties/font-property/index.md b/client/src/guide/english/css/properties/font-property/index.md
deleted file mode 100644
index 8f37aa84c3..0000000000
--- a/client/src/guide/english/css/properties/font-property/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Font Property
----
-## Font Property
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/guide/english/css/structure-of-css/index.md b/client/src/guide/english/css/structure-of-css/index.md
deleted file mode 100644
index 7bc52c8d2c..0000000000
--- a/client/src/guide/english/css/structure-of-css/index.md
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title: Structure of CSS
----
-## CSS Structure
-A CSS rule follows this basic structure:
-```CSS
-selector {
- property: value;
- property: value;
-}
-```
-Everything inside the curly brackets styles whatever is selected by the [selector]. Inside a CSS rules is a set of [property]/value pairs.
-
-You can have different selectors seperated with comas:
-```CSS
-selector1,
-selector2 {
- property: value;
-}
-```
-
-Multiple CSS rules can be put in one CSS file - here is an example:
-```CSS
-h1 {
- color: red;
-}
-
-div {
- text-align: center;
- color: blue;
-}
-
-img {
- margin-left: 2px;
- margin-top: 100px;
-}
-```
-
-#### More Information:
-- [CSS Syntax on Code The Web](https://codetheweb.blog/2017/11/11/css-syntax/)
-- More on [CSS selectors][selector]
-- More on [CSS properties][property]
-
-
-[selector]: https://guide.freecodecamp.org/css/selectors
-[property]: https://guide.freecodecamp.org/css/properties
diff --git a/client/src/guide/english/css/styling-tables/index.md b/client/src/guide/english/css/styling-tables/index.md
deleted file mode 100644
index fadd0c9f9e..0000000000
--- a/client/src/guide/english/css/styling-tables/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Styling Tables
----
-## Styling Tables
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/guide/english/css/text-indent/index.md b/client/src/guide/english/css/text-indent/index.md
deleted file mode 100644
index 96b7c7e71b..0000000000
--- a/client/src/guide/english/css/text-indent/index.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: Text Indent
----
-## Text Indent
-
-This CSS property creates an indentation of the first line in a text block.
-
-### Values:
-The `text-indent` property can be specified using `%`, `px`, `em` or measurement units such as `cm` and `in`.
-
-For example:
-- `text-indent: 20%;`
-- `text-indent: 15px;`
-- `text-indent: 5em;`
-- `text-indent: 2in;`
-
-The `text-indent` property can also inherit from its parent element using `inherit` value.
-
-For example:
-- `text-indent: inherit;`
-
-#### More Information:
-- MDN Web Docs - CSS text-indent
diff --git a/client/src/guide/english/d3/set-up-d3/index.md b/client/src/guide/english/d3/set-up-d3/index.md
deleted file mode 100644
index 55baa9899c..0000000000
--- a/client/src/guide/english/d3/set-up-d3/index.md
+++ /dev/null
@@ -1,88 +0,0 @@
----
-title: Set Up D3
----
-
-## HTML Setup
-
-For now, you will just use a text file and the web browser. You will start with with a static page of HTML. Then you will add d3.js.
-Create a folder named d3js_projects. Create an HTML file in the folder named project_1.html.
-
-Start with a basic HTML webpage:
-
-```html
-
-
-
-
-
- Hello!
-
-
-```
-
-Which shows up in the browser:
-
-
-
-### D3.js Setup
-
-To get the main D3.js JavaScript file go to the D3.js Website. After the first paragraph on the page, you will see a section with links to the latest version. Download the latest version d3.v2.min.js. Save this file in the d3js_projects folder.
-
-The file d3.v2.min.js is saved in the same folder as the HTML file so that it can be referenced it easily. We reference the JavaScript file from the head of the HTML file. Our updated HTML file now looks like this:
-
-```html
-
-
-
-
-
-
- Hello!
-
-
- ```
-
- Source File Setup Test
-
- To test our D3.js setup we open the inspect element tool kit. In the Element tab of the Webkit Inspector, we open all of the elements so that we can see the whole HTML structure. We then hover over the d3.vs.min.js src.
-
- 
-
- When we click on the link, it takes us to the sources tab. This will show the D3.js minified code.
-
- 
-
- ### JavaScript Console Setup Test
-
- The last test will take place in the JavaScript Console. This test tells us if D3.js is loaded correctly for our use in the JavaScript Console.
- In this snapshot, locate the "Console" tab in the Webkit Inspector:
-
- 
-
- When you click on the tab, it will show you a blank screen where you can type and evaluate JavaScript.
-
- 
-
- In the JavaScript console, type the following:
-
- ```javascript
- alert("hello");
- ```
-
- This will cause a popup alert to pop up and say "Hello!". This is what it looks like:
-
- 
-
- Now to test if D3.js is loaded correctly. Type a lowercase "d3" into the Console followed by a period:
-
- ```javascript
- d3
- ```
-
- If we have D3.js installed correctly, the following should appear:
-
- 
-
- If all the tests passed and you were able to load D3.js correctly, you are ready to get started.
-
- #### More Information
diff --git a/client/src/guide/english/data-science-tools/Tableau/index.md b/client/src/guide/english/data-science-tools/Tableau/index.md
deleted file mode 100644
index 99e8c5c3aa..0000000000
--- a/client/src/guide/english/data-science-tools/Tableau/index.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
- title: Tableau
----
-
-# Tableau
-Tableau is a data visualization software for business intelligence. Tableau is a commerically available thought the Tableau Software foundation. Capabilites include highly interactive visualizations, mapping capabilites, and dashbaords. A roboust community for tableau visualizations exists online, where many individauls publically publish their dashboards.
-
-### Links:
- * [Tableau Website](https://www.tableau.com)
- * [Tableau Public Gallery](https://public.tableau.com/en-us/s/gallery)
-
diff --git a/client/src/guide/english/data-science-tools/detail/index.md b/client/src/guide/english/data-science-tools/detail/index.md
deleted file mode 100644
index 4d9cbcc5ec..0000000000
--- a/client/src/guide/english/data-science-tools/detail/index.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: detail
----
-## What is Data Science
-
-### Data Science is a multi-disciplinary field that combines skills in
- software engineering and statistics with domain experience to
- support the end-to-end analysis of large and diverse data sets,
- ultimately uncovering value for an organization and then
- communicating that value to stakeholders as actionable results.
-
-## Data Scientist
- Person who is better at statistics than any software engineer and
- better at software engineering than any statistician.
-
-## What Skills Do You Need?
- * Mathematics - Calculus, Linear Algebra
- * Statistics - Hypothesis, Testing, Regression
- * Programming - SQL, R/Python
- * Machine Learning - Supervised and Unsupervised Learning, Model Fitting
- * Business/Product Intuition - Interpret and communicate results to non-technical audience
-
-## Life Cycle
- 1 - Identify or Formulate Problem
- 2 - Data Preparation
- 3 - Data Exploration
- 4 - Transform and Select
- 5 - Build Model
- 6 - Validate Model
- 7 - Deploy Model
- 8 - Evalute or Monitor Results
\ No newline at end of file
diff --git a/client/src/guide/english/data-science-tools/index.md b/client/src/guide/english/data-science-tools/index.md
deleted file mode 100644
index 3771a30aec..0000000000
--- a/client/src/guide/english/data-science-tools/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Data Science Tools
----
-## Data Science Tools
-
-In this section, we'll have guides to a wide variety of tools used by data scientists.
-
-Data scientists are inquisitive and often seek out new tools that help them find answers. They also need to be proficient in using the tools of the trade, even though there are dozens upon dozens of them. Overall, data scientists should have a working knowledge of statistical programming languages for constructing data processing systems, databases, and visualization tools. Many in the field also deem a knowledge of programming an integral part of data science; however, not all data scientist students study programming, so it is helpful to be aware of tools that circumvent programming and include a user-friendly graphical interface so that data scientists’ knowledge of algorithms is enough to help them build predictive models.
-
-R remains the leading tool, with 49% share, but Python grows faster and almost catches up to R. RapidMiner remains the most popular general Data Science platform. Big Data tools used by almost 40%, and Deep Learning usage doubles.
-Data Science is OSEMN (**O**btain, **S**crub, **M**odel, i**N**terpret) the Data.
-There is one good resource for Data Science and Machine Learning by Open Source Data Science Masters. Follow on github datasciencemasters!!!
-* [Resources for Data Science](https://github.com/datasciencemasters/go)
diff --git a/client/src/guide/english/data-science-tools/scikit/index.md b/client/src/guide/english/data-science-tools/scikit/index.md
deleted file mode 100644
index 639f57b1b1..0000000000
--- a/client/src/guide/english/data-science-tools/scikit/index.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: scikit-learn
----
-## Scikit-learn
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-Scikit-learn reference page
diff --git a/client/src/guide/english/designer-tools/index.md b/client/src/guide/english/designer-tools/index.md
deleted file mode 100644
index 7b050d6c10..0000000000
--- a/client/src/guide/english/designer-tools/index.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: Designer Tools
----
-## Designer Tools
-
-In this section, we'll have guides to a wide variety of tools used by designers.
-
-These are some of them:
-
-[Sketch](https://www.sketchapp.com) - [Guide](https://github.com/freeCodeCamp/guides/blob/master/src/pages/designer-tools/sketch/index.md)
-
-[Adobe Experience Design](www.adobe.com/products/experience-design.html) - [Guide](https://github.com/freeCodeCamp/guides/blob/master/src/pages/designer-tools/Experience-design/index.md)
-
-[Adobe Photoshop](http://adobe.com/Photoshop) - [Guide](https://github.com/freeCodeCamp/guides/blob/master/src/pages/designer-tools/photoshop/index.md)
-
-[Adobe Illustrator](http://adobe.com/Illustrator) - [Guide](https://github.com/freeCodeCamp/guides/blob/master/src/pages/designer-tools/illustrator/index.md)
-
-[Figma](https://www.figma.com) - [Guide](https://github.com/freeCodeCamp/guides/blob/master/src/pages/designer-tools/Figma/index.md)
-
-[Framer](https://framer.com) - [Guide](https://github.com/freeCodeCamp/guides/blob/master/src/pages/designer-tools/framer/index.md)
-
-[CLIP STUDIO PAINT](https://www.clipstudio.net/en)
-
-[Moqups](https://moqups.com/)
-
-[Krita] (https://krita.org/en/homepage/)
-
-[MediBang Paint] (https://medibangpaint.com/en/)
-
-[Autodesk Sketchbook] (https://www.sketchbook.com/)
-
-In this section, you can see popular Firefox plug-ins used by designers.
-
-These are some of them:
-
-- [Color Picker](https://addons.mozilla.org/en-us/firefox/addon/colorzilla/?src=collection&collection_id=90e68e6a-f13f-5921-3412-5228262ca9db)
-- [React Developer Tools](https://addons.mozilla.org/en-US/firefox/addon/react-devtools/)
diff --git a/client/src/guide/english/developer-tools/certbot/index.md b/client/src/guide/english/developer-tools/certbot/index.md
deleted file mode 100644
index 48dc12faff..0000000000
--- a/client/src/guide/english/developer-tools/certbot/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Certbot
----
-## Certbot
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-https://certbot.eff.org/
-Automatically enable HTTPS on your website with EFF's Certbot, deploying Let's Encrypt certificates.
diff --git a/client/src/guide/english/developer-tools/npm-cheatsheet/index.md b/client/src/guide/english/developer-tools/npm-cheatsheet/index.md
deleted file mode 100644
index b86d6990af..0000000000
--- a/client/src/guide/english/developer-tools/npm-cheatsheet/index.md
+++ /dev/null
@@ -1,108 +0,0 @@
----
-title: npm Cheat Sheet
----
-
-## npm Cheat Sheet
-
-A list of terminal commands and flags to help use `npm`
-
-## install `package.json` dependencies
-
-```shell
-npm install
-```
-
-**Shorthand**
-
-```shell
-# install
-npm i
-# uninstall
-npm un
-# update
-npm up
-```
-
-## List globally installed packages.
-
-```shell
-npm list -g --depth=0
-
-```
-
-## Uninstall global package
-
-```shell
-npm -g uninstall
-```
-
-## Upgrade NPM on Windows
-
-After trying several times to upgrade npm on Windows I found this whilst poking around in the npm folders.
-
-```shell
-npm-windows-upgrade
-```
-
-## Updating global packages
-
-To see which packages need updating, use:
-
-```shell
-npm outdated -g --depth=0
-```
-
-To update global packages individually you can use:
-
-```shell
-npm update -g
-```
-
-## list available scripts to run
-
-```shell
-npm run
-```
-
-## update npm
-
-```shell
-npm install -g npm@latest
-# using windows? Then use
-npm-windows-upgrade
-```
-
-## flags
-
-`-S` is the same as `--save` not needed in npm 5+
-`-D` is the same as `--save-dev`
-
-## installed version
-
-```shell
-npm list # for local packages
-```
-
-## Node Version Manager `nvm`
-
-Say you want to install Node v6.9.1 you would write on the terminal:
-
-```shell
-nvm install 6
-```
-
-If you have multiple versions of Node.js installed on your workspace, you can switch to a specific version by writing:
-
-```shell
-nvm use 4.8.4
-```
-
-### Making a node version default.
-
-In order to set a default version of node for your workspace, just type:
-
-```shell
-nvm alias default 6
-```
-
-Where 6 was the version you wanted to be used as default.
diff --git a/client/src/guide/english/documentation/index.md b/client/src/guide/english/documentation/index.md
deleted file mode 100644
index e10bf28003..0000000000
--- a/client/src/guide/english/documentation/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Code documentation
----
-## Code Documentation
-
-Code documentation is a way developers write their code to create the best versions of their functions possible. Code Documentations lets the newbie to get comfortable with the custom of the particular module, function etc for a particular programming language.It is always recommended to go with the Documentation before debugging your code, this helps you to debug effectively.For example, you should be able to pass along your code to an absolute beginner and they should be able to follow along through comments, appropriate variable names and structuring code in a spaced, readable manner.
-
-It may become an extremely important idea to make a habit out of commenting your functions, loops, and declarations and treating comments as a part of the source code, just as regular code should be.
-
-
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/electron/index.md b/client/src/guide/english/electron/index.md
deleted file mode 100644
index b10404fd15..0000000000
--- a/client/src/guide/english/electron/index.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: Electron
----
-## Electron - Build Cross Platform Desktop Apps with JavaScript, HTML, and CSS
-
-Electron lets you build cross-platform desktop apps using web technology. You
-can build desktop apps for Windows, Mac, and most common flavors of Linux.
-
-Electron is built on Chromium (the open-sourced version of Google Chrome). You
-use web technologies like HTML, JavaScript, and CSS to build Electron apps. That
-means you can use most any web technology you want to build your native desktop app. For example, you could use [React](https://medium.freecodecamp.org/building-an-electron-application-with-create-react-app-97945861647c) or [Angular](https://scotch.io/tutorials/creating-desktop-applications-with-angularjs-and-github-electron) to build your first desktop app.
-
-Additionally, Electron comes with support for auto-updating, crash reporting,
-and native menus.
-
-Core features can be explored using the [Electron API demos](https://github.com/electron/electron-api-demos)
-
-Some apps built using Electron include:
-* [Atom](https://atom.io/) (GitHub's open-source text-editor)
-* [Visual Studio Code](https://code.visualstudio.com) (Microsoft's open-source text-editor)
-* [Skype](https://www.skype.com/) (Microsoft's popular video chat application)
-* [Slack](https://slack.com/) (A messaging app for teams)
-* [Discord](https://discordapp.com) (A popular messaging app for gamers)
-* [Github Desktop](https://desktop.github.com/) (Official Github Desktop Client)
-
-### Additional info references
-- [Official site](https://electronjs.org/)
-- [Video - What is Electron](https://www.youtube.com/watch?v=8YP_nOCO-4Q&feature=youtu.be)
-- [Electron and Vue]: https://medium.com/@kswanie21/electron-vue-js-f6c40abeb625
-- [Electron and React]: https://medium.freecodecamp.org/building-an-electron-application-with-create-react-app-97945861647c
-- [Electron and Angular]: https://scotch.io/tutorials/creating-desktop-applications-with-angularjs-and-github-electron
diff --git a/client/src/guide/english/elm/arrays/index.md b/client/src/guide/english/elm/arrays/index.md
deleted file mode 100644
index d223f3657c..0000000000
--- a/client/src/guide/english/elm/arrays/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Arrays
----
-## Arrays
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/elm/index.md b/client/src/guide/english/elm/index.md
deleted file mode 100644
index 2aaf5d5cc3..0000000000
--- a/client/src/guide/english/elm/index.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Elm
----
-## Elm
-
-Elm is a domain-specific, purely functional programming language that compiles into Javascript. This programming language is statically typed, and was developed with an emphasis on usability, performance, and robustness. Elm was built by Evan Czaplicki in 2012, and was influenced by Haskell, Standard ML, and OCaml among others. It also helped to inspire the popular state management tool, Redux.
\ No newline at end of file
diff --git a/client/src/guide/english/erlang/index.md b/client/src/guide/english/erlang/index.md
deleted file mode 100644
index 6a6748ae25..0000000000
--- a/client/src/guide/english/erlang/index.md
+++ /dev/null
@@ -1,81 +0,0 @@
----
-title: Erlang
----
-## Erlang
-
-Erlang is a functional programming language, developed by Ericsson for use in telecom applications. Because they felt that it's unacceptable for a telecom system to have any significant downtime, Erlang was built to be (among other things):
-
-* distributed and fault-tolerant _(a piece of failing software or hardware should not bring the system down)_
-* concurrent _(it can spawn many processes, each executing a small and well-defined piece of work, and isolated from one another but able to communicate via messaging)_
-* hot-swappable _(code can be swapped into the system while it's running, leading to high availability and minimal system downtime)_
-
-### Syntax
-
-Erlang makes heavy use of **recursion**. Since data is immutable in Erlang, the use of `while` and `for` loops (where a variable needs to keep changing its value) is not allowed.
-
-Here's an example of recursion, showing how a function repeatedly strips the first letter from the front of a name and prints it, only stopping when the last letter has been encountered.
-
-```erlang
--module(name).
-
--export([print_name/1]).
-
-print_name([RemainingLetter | []]) ->
- io:format("~c~n", [RemainingLetter]);
-print_name([FirstLetter | RestOfName]) ->
- io:format("~c~n", [FirstLetter]),
- print_name(RestOfName).
-```
-
-Output:
-
-```
-> name:print_name("Mike").
-M
-i
-k
-e
-ok
-```
-
-There is also a heavy emphasis on **pattern-matching**, which frequently eliminates the need for an `if` structure or `case` statement. In the following example, there are two matches for specific names, followed by a catch-all for any other names.
-
-```erlang
--module(greeting).
-
--export([say_hello/1]).
-
-say_hello("Mary") ->
- "Welcome back Mary!";
-say_hello("Tom") ->
- "Howdy Tom.";
-say_hello(Name) ->
- "Hello " ++ Name ++ ".".
-```
-
-Output:
-
-```
-> greeting:say_hello("Mary").
-"Welcome back Mary!"
-> greeting:say_hello("Tom").
-"Howdy Tom."
-> greeting:say_hello("Beth").
-"Hello Beth."
-```
-
-### Try it out
-
-There are websites where you can try running Erlang commands without having to install anything locally, like these:
-
-* [Give it a try! (a hands-on tutorial)](http://www.tryerlang.org/)
-* [TutorialsPoint CodingGround](https://www.tutorialspoint.com/compile_erlang_online.php)
-
-If you'd like to install it on your (or a virtual) machine, you can find installation files at [Erlang.org](https://www.erlang.org/downloads) or on [Erlang Solutions](https://www.erlang-solutions.com/resources/download.html).
-
-#### More Information:
-
-* [About Erlang](https://www.erlang.org/about)
-* [Learn You Some Erlang for Great Good!](http://learnyousomeerlang.com/)
-* [Spawned Shelter!](http://spawnedshelter.com/) _(a collection of articles, videos and books for learning Erlang)_
-* [Erlang (programming language)](https://en.wikipedia.org/wiki/Erlang_(programming_language))
diff --git a/client/src/guide/english/game-development/index.md b/client/src/guide/english/game-development/index.md
deleted file mode 100644
index 67123f7a2d..0000000000
--- a/client/src/guide/english/game-development/index.md
+++ /dev/null
@@ -1,64 +0,0 @@
----
-title: Game Development
----
-
-## Game Development
-
-Game Development is the art of creating games and describes the design, development and release of a game. It may involve concept generation, design, build, test and release. While you create a game, it is important to think about the game mechanics, rewards, player engagement and level design.
-
-A game developer could be a programmer, a sound designer, an artist, a designer or many other roles available in the industry.
-
-Game Development can be undertaken by a large Game Development Studio or by a single individual. It can be as small or large as you like. As long as it lets the player interact with content and is able to manipulate the game's elements, you can call it a 'game'.
-
-To get involved in the Game Development process, you do not need to write code. Artists may create and design assets, while a Developer might focus on programming a health bar. A Tester may get involved to see that the game works as expected.
-
-
-
-To resolve problems that game frameworks had, tools like libGDX and OpenGL were developed. They helped game development to be a lot faster and easier, providing lots of pre-made functions and features. However, it was still hard to enter the industry or understand a framework for someone coming from a non-programmer background, a common case in the game development scene.
-
-
-
-That was when game engines like Construct, Game Maker, Unity and Unreal were developed. Generally, an engine has everything that a framework had, but with a more friendly approach by using a graphic user interface (GUI) and helping with the graphic development of the game.
-
-In some cases, like Game Maker and Construct, the amount of pre-made functions are so big that people with no previous programming skills could build a game from scratch, really expanding the scene and making game development accessible for almost anyone.
-
-### Game Engines
-
-
-
-Many developers choose to develop a game using a Game Development Engine.
-
-Game Engines can make the process of creating a game much easier and enable developers to reuse lots of functionality. It also takes care of rendering for 2D and 3D Graphics, physics and collision detection, sound, scripting and much more.
-
-Some Game Engines have a very steep learning curve such as CryEngine or Unreal Engine. Yet, other tools are very accessible to beginners and some do not even need you to be able to write code to create your game, e.g. Construct 2.
-
-The Unity Game Engine ranges somewhere in the middle, while it is beginner friendly, some popular and commercial games have been built using Unity (e.g. Overcooked, Superhot).
-
-The BuildBox game engine is basically for developing hypercasual games.
-
-### Typical Game Engines
-
-- CryEngine
-- Unreal Engine
-- Unity Game Engine
-- Game Maker
-- Construct 2 or 3
-- Twine
-- Source
-- Frostbite
-- Buildbox
-
-
-
-
-### More Information
-
-* [Awesome-List of GameDev resources](https://github.com/Kavex/GameDev-Resources)
-* [Game Programming Books](http://www.fromdev.com/2013/07/game-development-books.html)
-* libGDX Framework OpenGL Framework Construct Game Engine Game Maker Engine Unity3D Engine Unreal Engine
-* BuildBox Git push and Git pull for more details.
-
-Git only pulls the remote's main branch onto your computer. This branch is usually named "master" by convention but may be defined differently depending on the project.
-
-Also, Git automatically sets up your local main branch to track the remote branch. When you run `git status`, you'll see information about whether your local branch is up-to-date with the remote. Here's an example output:
-
-```shell
-myCommandPrompt (master) >> git status
-On branch master
-Your branch is up-to-date with 'origin/master'.
-nothing to commit, working tree clean
-myCommandPrompt (master) >>
-```
-
-If your local `master` branch has three commits that you haven't pushed up to the remote server yet, the status would say "Your branch is ahead of 'origin/master' by 3 commits."
-
-### Git Clone Mirror
-
-If you want to host mirror of a repository you can use mirror parameter.
-
-```shell
-git clone URL-OF-REPOSITORY --mirror
-```
-
-After mirroring a repository, you can clone your local mirror from your server.
-
-```shell
-git clone NAME-OF-DIRECTORY-ON-COMPUTER
-```
-
-### More Information:
-- Git documentation: [clone](https://git-scm.com/docs/git-clone)
diff --git a/client/src/guide/english/go/go-playground/index.md b/client/src/guide/english/go/go-playground/index.md
deleted file mode 100644
index f939047fb2..0000000000
--- a/client/src/guide/english/go/go-playground/index.md
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: Go Playground
----
-
-# The Golang Playground
-The Golang playground is a website where you can write Go code online, so that you don't have to set up any developmet environment.
-
-Just open a new browser window clinking [Playground](https://play.golang.org).
-
-Once there you'll get the buttons:
-1. Run
-2. Format
-3. Imports
-4. Share
-
-The Run button just send the instruction of compile the code you wrote to the google servers that run the golang Backend.
-
-The Format button implements the idiomatic formatting style of the language, you can read more [here.](https://golang.org/pkg/fmt/)
-
-Imports just check what packages you have declared within import(). An import path is a string that uniquely identifies a package. A package's import path corresponds to its location inside a workspace or in a remote repository (explained below). [More](https://golang.org/doc/code.html#ImportPaths)
-
-With Share you get an URL where the code you just wrote is saved. Useful when asking for help showing your code.
-
-#### More Information:
-
-* [The Go Playground](https://play.golang.org/)
-* [A Tour of Go](https://tour.golang.org/welcome/4)
diff --git a/client/src/guide/english/go/go-structs/index.md b/client/src/guide/english/go/go-structs/index.md
deleted file mode 100644
index 6c0fcf1dd1..0000000000
--- a/client/src/guide/english/go/go-structs/index.md
+++ /dev/null
@@ -1,129 +0,0 @@
----
-title: Go Structs
----
-## Go Structs
-
-In Go, structs are used to store data and related functions. An example might be a struct to represent a User:
-
-```go
-type User struct {
- FirstName string
- LastName string
- Email string
- Age int
-}
-```
-
-Here we can store a user's first name, last name, email address, and age. The name of the property is followed by the type of data we want to store. For example, the `FirstName` property is a `string` whereas the `Age` property is an `int`.
-
-### Creating objects
-
-To initialise a new object, we can use the Go shorthand syntax for creating and assigning variables. We can either pass the data in at this point or set the data at a later time:
-
-```go
-func main() {
- // Create a user and set both the first and last name properties
- user1 := User{
- FirstName: "John",
- LastName: "Wick",
- }
-
- // Now we have our user object, we can set the data like this
- user1.Email = "john@wick.com"
- user1.Age = 30
-}
-```
-
-### Object methods
-
-Go enables assigning methods to structs. This enables grouping of relevant operations to the data it affects. In this example we will write a method on the `User` struct to generate the full name of the user:
-
-```go
-func (u User) FullName() string {
- return strings.Join([]string{u.FirstName, u.LastName}, " ")
-}
-```
-
-This method will join the first and last name of the user with a space in between. Calling the method might look like this:
-
-```go
- println(user1.FullName())
-```
-
-### Struct Tags
-
-Struct tags are used to modify how encoders handle the data. For example, setting the key names when encoding to JSON:
-
-```go
-type User struct {
- FirstName string `json:"first_name"`
- LastName string `json:"last_name"`
- Email string `json:"email"`
- Age int `json:"age"`
-}
-```
-
-### Exported Data
-
-Structs can contain both exported (public) and unexported (private) properties. This is set by either having an uppercase first letter for exported or a lowercase first letter for unexported. In this example, we will make the email property private:
-
-```go
-type User struct {
- // Exported Data
- FirstName string
- LastName string
- Age int
-
- // Unexported Data
- email string
-}
-```
-
-Doing this will make the following code throw an error at build time as it is trying to interact with an unexported property:
-
-```go
- user1.email = "john@wick.com"
-```
-
-This also applies to methods:
-
-```go
-// Exported method. This can be called from anywhere
-func (u User) Email() {
- return u.email
-}
-
-// Unexported method. This can only be called by other methods on this struct
-func (u User) updateLoginCount {
- // code to update login count...
-}
-```
-
-### Modifying properties via methods
-
-To modify the data of an object from within one of it's methods, the object must be a pointer. An example might look like this:
-
-```go
-// SetEmail sets the user's email address
-func (u *User) SetEmail(email string) {
- u.email = email
-}
-
-// Email accessor
-func (u *User) Email() string {
- return u.email
-}
-
-func main() {
- // Creating the user1 pointer
- user1 = &User{
- FirstName: "John",
- LastName: "Wick",
- }
-
- // Set the user's email address
- user1.SetEmail("john@wick.com")
-
- // Access and print the user's email address
- println(user1.Email())
-}
diff --git a/client/src/guide/english/go/goroutines/index.md b/client/src/guide/english/go/goroutines/index.md
deleted file mode 100644
index aec7c034dc..0000000000
--- a/client/src/guide/english/go/goroutines/index.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Goroutines
----
-## Goroutines
-
-This is a stub. [Help our community expand it](https://github.com/freecodecamp/guides/tree/master/src/pages/go/goroutines/index.md).
-
-[This quick style guide will help ensure your pull request gets accepted](https://github.com/freecodecamp/guides/blob/master/README.md).
-
-
-
-#### More Information:
-* [A Tour of Go](https://tour.golang.org/concurrency/1)
-* [Go By Example](https://gobyexample.com/goroutines)
-* [Golang Book](https://www.golang-book.com/books/intro/10)
-* [The Go Programming Language Specification](https://golang.org/ref/spec#Go_statements)
diff --git a/client/src/guide/english/go/receive-data-with-your-webserver/index.md b/client/src/guide/english/go/receive-data-with-your-webserver/index.md
deleted file mode 100644
index d8fdf5eb73..0000000000
--- a/client/src/guide/english/go/receive-data-with-your-webserver/index.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: Receive data with your web server
----
-Once you've set up your web server and made sure it can serve some useful content, you might want to make it more interactive by letting it accept data. Let's get started by writing some code:
-```go
-package main
-
-import (
- "net/http"
- "html/template"
-)
-
-type PAGE struct {
- NAME string
-}
-
-var page PAGE
-
-func main() {
- http.HandleFunc("/", servePage)
- http.ListenAndServe(":8080", nil)
-}
-
-func servePage(writer http.ResponseWriter, reqest *http.Request) {
- page.NAME = request.FormValue("name")
- template := template.New("sayHello")
- template, _ = template.Parse("Hello {{.NAME}}!")
- template.Execute(writer, page)
-}
-```
-Let's break this code down. First off all, we start by importing `net/http` for the web server and `html/template` for the templating. This article assumes you already know how to template in Go. If you don't know this yet, you should read the article on templating first.
-
-Then we create a type called `PAGE`, with one slot in it called `NAME` (this is a `string`). We also create a global variable called `page` which is of type `PAGE`: the struct we just made.
-
-In the `servePage` function there is one thing that is really important for this article: the `FormValue` method we run on the `request`.
-
-Before we continue you first need to know how a `URL` is built. Let's take the following `URL` as an example:
-```
-https://google.com/search?q=free+code+camp
-```
-If you enter the `URL` above in your browser, it will perform a Google search for `free code camp`. The `URL` is built like this:
-1. `https://` - this is the protocol
-2. `google.com` - this is the domain name and port (in this case there is no port mentioned - so the browser uses the default port for the protocol)
-3. `/search` - this is the path
-4. `q=free+code+camp` - this is the `query`
-
-The query is the part we talk about in this article. The Google server sees this `URL` and because of the attribute `q` in the query and the value of `q` - in this case `free+code+camp` - it knows where it should search for.
-
-We can also apply this to our server. Let's fire up the program and navigate the browser to:
-```
-http://localhost:8080/?name=world
-```
-The response will be:
-```
-Hello world!
-```
-How does this work? Well, we gave the `FormValue` a parameter of `name`. This way `FormValue` knows we want the value of the `name` attribute in the query. In this case that is `world`, so the method returns `world`. That string is then put in the `page` variable and the template does the rest.
-
-This is of course a really simple implementation of this function, but you could do a lot of things with it. For example: you could accept email addresses and let the program store those in a file.
diff --git a/client/src/guide/english/haskell/index.md b/client/src/guide/english/haskell/index.md
deleted file mode 100644
index 7ddaa2426f..0000000000
--- a/client/src/guide/english/haskell/index.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: Haskell
----
-
-## What is Haskell?
-Haskell is a standardized, general-purpose, purely functional programming language with declarative and strong static typing.
-
-Haskell has deep roots in mathematics, and you will soon learn to appreciate the implications of it.
-
-## Version
-Currently the latest version of GHC is 8.6 (as of 12 Oct 2018)
-
-
-## Installation
-The recommended way to install Haskell is by using stack : stack download
-Stack is a cross-platform program for developing Haskell projects. It is aimed at Haskellers both new and experienced.
-
-To actually start using Haskell you need the GHC (The Glasgow Haskell Compiler), so to setup : stack setup
-
-```shell
-stack new my-project
-cd my-project
-stack setup
-stack build
-stack exec my-project-exe
-```
-
-A word of cautious, try not to use stack install even though it will install package globally, this is not recommended as different versions of packages are compatible with different versions of GHC. Hence using local copy of package using stack build is best way to follow.
-
-## Hello World
-
-```haskell
-main :: IO ()
-main = print "Hello Haskell :)"
-```
-Save above code in a file named "hello.hs" and save.
-
-To compile the Hello World example, this will convert our haskell code to machine understandable bytecodes.
-```shell
-stack ghc hello.hs
-./hello
-```
-
-## Documentation
-Hackage provides documentation for Haskell
-
-
-## Want to learn more?
-* Haskell wiki link
diff --git a/client/src/guide/english/haskell/monad/index.md b/client/src/guide/english/haskell/monad/index.md
deleted file mode 100644
index 285822ca7d..0000000000
--- a/client/src/guide/english/haskell/monad/index.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: Monad
----
-
-# Monad Laws
-There are 3 laws which must be satisfied by a data type to be considered as monad
-
-
-
-# Maybe Monad
-
-```haskell
-justHead :: Maybe Char
-justHead = do
- (x:xs) <- Just ""
- return x
-```
-
-# List Monad
-
-
-
-
-return is same as pure of applicative
-
-
-instance Monad [] where
- return x = [x]
- xs >>= f = concat (map f xs)
- fail _ = []
-
-
diff --git a/client/src/guide/english/html/attributes/a-href-attribute/index.md b/client/src/guide/english/html/attributes/a-href-attribute/index.md
deleted file mode 100644
index 42cba59cab..0000000000
--- a/client/src/guide/english/html/attributes/a-href-attribute/index.md
+++ /dev/null
@@ -1,69 +0,0 @@
----
-title: A Href Attribute
----
-
-## A Href Attribute
-
-The `` attribute refers to a destination provided by a link. The `a` (anchor) tag is dead without the `` attribute. Sometimes in your workflow, you don't want a live link or you won't know the link destination yet. In this case, it's useful to set the `href` attribute to `"#"` to create a dead link. The `href` attribute can be used to link to local files or files on the internet.
-
-For instance:
-
-```html
-
-
- Href Attribute Example
-
-
- Href Attribute Example
-
- The freeCodeCamp Contribution Page shows you how and where you can contribute to freeCodeCamp's community and growth.
-
-
-
-
-```
-The `` attribute is supported by all browsers.
-
-#### More attributes:
- `hreflang` : Specifies the language of the linked resource.
- `target` : Specifies the context in which the linked resource will open.
- `title` : Defines the title of a link, which appears to the user as a tooltip.
-
-### Examples
-```html
- This is a dead link
-This is a live link to freeCodeCamp
-more with a href attribute
-
-```
-### In-page anchors
-
-It's also possible to set an anchor to certain place of the page. To do this you should first place a tab at location on the page with tag and necessary attribute "name" with any keyword description in it, like this:
-
-```html
- with necessary attribute "href" with symbol # (sharp) and key-word description of the anchor, like this:
-
-```html
- Go to Top
-```
-
-### Image Links
-
-The `` may also be applied to images and other HTML elements.
-
-### Example
-
-```html
-
-``` tag.
-
-### Syntax:
- ``html
-
- ```
-
-### Important:
-This attribute is not supported in HTML5. Instead, this [freeCodeCamp article](https://guide.freecodecamp.org/css/colors) specifies a CSS method, which can be used.
-
-### Note:
-A color can also be specified using a 'hex code' or an 'rgb code', instead of using a name.
-
-### Example:
-1. Color name attribute
-```html
-
-
- Font color example using color attribute
-
-
-```
-2. Hex code attribute
-```html
-
-
- Font color example using color attribute
-
-
-```
-3. RGB attribute
-```html
-
-
- Font color example using color attribute
-
-
-```
\ No newline at end of file
diff --git a/client/src/guide/english/html/attributes/required/index.md b/client/src/guide/english/html/attributes/required/index.md
deleted file mode 100644
index d8669a4368..0000000000
--- a/client/src/guide/english/html/attributes/required/index.md
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: Required
----
-## Required
-
-
-The HTML required attribute is used in an input element to make the input field in a form required to submit the form.
-If the user does not fill in the input field the form will not submit and it will give a message asking the user to fill out the field.
-The `< Required>` attribute is applicable to `` , `
- MDN article on the input element
-
diff --git a/client/src/guide/english/html/comments-in-html/index.md b/client/src/guide/english/html/comments-in-html/index.md
deleted file mode 100644
index e9cd850ba1..0000000000
--- a/client/src/guide/english/html/comments-in-html/index.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: Comments in HTML
----
-## Comments in HTML
-
-The comment tag is an element used to leave notes, mostly related to the project or the website. This tag is frequently used to explain something in the code or leave some recommendations about the project. The comment tag also makes it easier for the developer to come back and understand the code he's written at a later stage. Comments can also used for commenting out lines of code for debugging purposes.
-
-It is good practice to add comments to your code, especially when working with a team or at a company.
-
-Comments are started with ``, and can span multiple lines. They can contain code or text, and won't appear on the front-end of the website when a user visits a page. You can view comments through the Inspector Console, or by viewing Page Source.
-
-### Example
-```html
-
-
-Read more: https://html.com/tags/comment-tag/#ixzz4vtZHu5uR
-
-
-
- FreeCodeCamp web
-
- FreeCodeCamp is an open-source project that needs your help
-
-
-
-```
-## Conditional Comments
-Conditional Comments defines some HTML tags to be excuted when a certain codition is fullfilled.
-
-Conditional Comments are only recognised by Internet Explorer Version 5 through to Version 9 - IE5 - IE9.
-
-### Example
-```html
-
-
-
-
-
-
-```
-
-### IE Conditional Comments
-
-These comments are only available in Internet Explorer and can be used up to IE9. In the current times, there is a good change you will never see them, but it is good to know about their existance. Conditional comments are a way to serve a different experience for different client browsers. For example:
-
-```html
-
-
-
-```
-
-[About conditional comments](https://msdn.microsoft.com/en-us/library/ms537512(v=vs.85).aspx)
diff --git a/client/src/guide/english/html/css-classes/index.md b/client/src/guide/english/html/css-classes/index.md
deleted file mode 100644
index 06847a2f33..0000000000
--- a/client/src/guide/english/html/css-classes/index.md
+++ /dev/null
@@ -1,72 +0,0 @@
----
-title: CSS Classes
----
-## CSS Classes
-
-Classes are an efficient way of grouping HTML elements so that they can share the same styles. CSS (Cascading Style Sheets) classes can be used to arrange and decorate web page elements.
-
-When writing HTML, you can add classes to an element. Just add the attribute `class="myclass"` to the element. Multiple elements can have the same class, and one element can have multiple classes. You can assign multiple classes to an element by adding all the desired class names separated by a space to the `class` attribute in HTML.
-
-```html
-"Here I come to save the day!"
-is a popular catchphrase that Super Man often said.
-```
-
-You can then style these elements with CSS. Classes are referenced with period (.) before them in CSS, but you should not put periods in your HTML.
-
-```css
-.super-man {
- color: red;
- background-color: blue;
-}
-```
-
-This code give a blue background and a red text color to all the elements that have the `super-man` class.
-[View this example on CodePen](https://codepen.io/Tlandis/pen/RLvomV).
-
-You can also declare more than one class to your element, like:
-
-```html
-
-
- We're going to save you.
-
-
-```
-
-Then in your css file:
-
-```css
-
-.ironMan{
-color:red;
-}
-
-.alfred{
-background-color: black;
-}
-
-```
-
-**Note:** class names are traditionally all lowercase, with each word in a multi-word class name separated by hyphens (e.g. "super-man").
-
-You can also combine classes in the same line:
-```css
-.superMan .spiderMan {
-color: red;
-background-color: blue;
-}
-```
-
-You can see the result of the above code here .
-Learn how to combine css classes using selectors here .
-
-#### More Information:
-
-
-
-- [CSS Class Selector, w3 schools](https://www.w3schools.com/cssref/sel_class.asp)
-- [HTML Classes, w3 Schools](https://www.w3schools.com/html/html_classes.asp)
-- [css-tricks](https://css-tricks.com/how-css-selectors-work/)
-- [How to Code in HTML5 and CSS3](http://howtocodeinhtml.com/chapter7.html)
-- [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class)
diff --git a/client/src/guide/english/html/layouts/index.md b/client/src/guide/english/html/layouts/index.md
deleted file mode 100644
index b712c7524e..0000000000
--- a/client/src/guide/english/html/layouts/index.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: Layouts
----
-## Layouts
-
-Layouts organize different areas of the web page.
-
-Almost every web page we see can be divided into boxes, that can be arranged into specific order to create that web page. The image below is one such example.
-
-
-
-> Websites often display content in multiple columns (like a magazine or newspaper).
-
-And the HTML layout techniques help us put the needed information into the needed order or design.
-
-
-### Techniques to Implement Layouts
-
-#### HTML Tables
-One the most basic tools to implement layouts in a webpage, these are provided by HTML. But as the layout gets complicated HTML tables quickly lose their ease, because of the increase in markup text.
-
-
-
-#### CSS Float
-If you are to design a 2-column based page with left navigation pane and center content viewing area, its easy to do it with CSS floats. Simply set the left navigation page into a `` with style property `float: left;`. And voila you get that design. But what if you had 4 columns in a single section. Sure, one can do it with floats, but the syntax of HTML you would be writing would be easy to comprehend.
-
-
-
-#### CSS Frameworks
-This is where CSS Frameworks such as [Bootstrap](http://getbootstrap.com/) and [Materialize](http://materializecss.com/) come in. These frameworks provide a grid functionality that lets to divide each section of your webpage into 12 columns, which you can order to design.
-
-
-> Sample Bootstrap Grid
-
-### HTML Semantic Elements
-Websites often display content in multiple columns (like a magazine or newspaper).
-
-HTML5 offers new semantic elements that define the different parts of a web page:
-```
-
- Defines a header for a document or a section
- - Defines a container for navigation links
- - Defines a section in a document
- - Defines an independent self-contained article
- - Defines content aside from the content (like a sidebar)
- - Defines a footer for a document or a section
- - Defines additional details
- - Defines a heading for the element
-```
-
-#### More Information:
-
-- [W3 Schools - Layout](https://www.w3schools.com/html/html_layout.asp)
-- [CodeMentorTeam](https://www.codementor.io/codementorteam/4-different-html-css-layout-techniques-to-create-a-site-85i9t1x34) - Layout Techniques to Create a Site
-
diff --git a/client/src/guide/english/html/lists/index.md b/client/src/guide/english/html/lists/index.md
deleted file mode 100644
index 475d1c06b2..0000000000
--- a/client/src/guide/english/html/lists/index.md
+++ /dev/null
@@ -1,102 +0,0 @@
----
-title: Lists
----
-
-# Lists
-Lists are used to display items. There are 3 types of lists.
-
-## Ordered lists
-An _ordered list_ is used to describe an ordered collection of data. Browsers usually display an ordered list as a numbered list. Create an ordered list using the `` tag.
-
-## Unordered lists
-An _unordered list_ is used to describe an unordered collection of data. Browsers usually display an unordered list as a bulleted list. Create an unordered list using the `` tag.
-
-## List items
-The direct children of ordered and unordered lists must be list items. Each list item is wrapped in an `` tag. A list item tag can contain [flow content](https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/Content_categories#Flow_content).
-
-## Examples
-
-An ordered list is written as
-```HTML
-
- January
- February
- March
-
-```
-and is displayed as:
-1. January
-1. February
-1. March
-
-An unordered list is written as
-
-
-```HTML
-
- Macintosh
- Fuji
- Gala
-
-```
-and is displayed as:
-- Macintosh
-- Fuji
-- Gala
-
-## Styling Bulletpoints
-
-An ordered list can be used for a variety of functions and in a number of styles. Since changing the encompassing tag colors doesn't change the color of the bullets themselves, you can style them by first removing the traditional black bullets and inserting your own:
-
-Remove bullets:
-```CSS
-ul {
- list-style: none;
- }
-```
-
-Insert your own:
-```CSS
-ul li::before {
- content: "\2022";
- color: orange;
- display: inline-block;
- width: 1em;
- }
-```
-
-The content style adds a new bulletpoint while display and width style create a space between the bullet and the word. Regular font styles can apply here if you would like to make the bullet larger or bolder.
-
-
-
-## Description lists
-
-A description list is a list of terms, with a description of each term. A description list is made using the `` tag.
-Each item in the list is made up of two tags: a term ``, and a description of that term ` `.
-They are called definition lists in HTML 4.
-
-Here is an example of a description list:
-```HTML
-
- Programming
- The process of writing computer programs.
- freeCodeCamp
- An awesome non-profit organization teaching people how to code.
-
-```
-
-which would end up looking like:
-
-
- Programming
- The process of writing computer programs.
- freeCodeCamp
- An awesome non-profit organization teaching people how to code.
-
-
-
-## More Information:
-
-
-* [HTML lists on w3schools](https://www.w3schools.com/html/html_lists.asp)
-
diff --git a/client/src/guide/english/html/optional-tags/index.md b/client/src/guide/english/html/optional-tags/index.md
deleted file mode 100644
index 6a86699457..0000000000
--- a/client/src/guide/english/html/optional-tags/index.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: Optional Tags
----
-## HTML5 Optional Tags
-
-In HTML5, you can omit certain opening and closing tags under specific conditions. For example, the following HTML code...
-
-```html
-
-Hello World.
-```
-
-Will automatically evaluate to...
-
-```html
-
-
-
-
- Hello world.
-
-
-
-```
-
-The optional tag specifications for the most common HTML5 tags are as follows:
-
-- An `html` element's start tag may be omitted if the first thing inside the `html` element is not a comment.
-- An `html` element's end tag may be omitted if the `html` element is not immediately followed by a comment.
-- A `head` element's start tag may be omitted if the element is empty, or if the first thing inside the `head` element is an element.
-- A `head` element's end tag may be omitted if the `head` element is not immediately followed by a space character or a comment.
-- A `body` element's start tag may be omitted if the element is empty, or if the first thing inside the `body` element is not a space character or a comment, except if the first thing inside the `body` element is a `meta`, `link`, `script`, `style`, or `template` element.
-- A `body` element's end tag may be omitted if the body element is not immediately followed by a comment.
-
-### More Information
-
-To learn more about the HTML5 optional tags, please visit .
diff --git a/client/src/guide/english/html/page-structure/index.md b/client/src/guide/english/html/page-structure/index.md
deleted file mode 100644
index 078819e93a..0000000000
--- a/client/src/guide/english/html/page-structure/index.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: Page Structure
----
-## Page Structure
-
-To create your pages in `HTML`, you need to know how to structure a page in `HTML`, basically, the structuring a page follows the order below:
-
-```HTML
-
-
-
- Title of the Page
-
-
-
-
-
-```
-1º - The `` statement must always be the first to appear on an `HTML` page and tell the browser which version of the language is being used. In this case, we are working with `HTML5`.
-
-2º - The `` and `` tags tell the web browser where the `HTML` code starts and ends.
-
-3º - The `` and `` tags contains informations about the web site, exemple: style, meta-tags, scripts, etc...
-
-4º - The `` and ` ` tags tell the browser what the page title is. The title can be seen by identifying the tab in your internet browser. The text that is defined between these tags is also the text that is used as title by the search engines when they present the pages in the results of a search.
-
-5º - Between the `` and `` tags the page content is placed, which is what is displayed in the browser.
-
-### Changes in HTML5
-
-#### Introduction of semantic tags
-Instead of using `` for every other container several semantic(these tags help screenreaders which are used by visually
-impaired) tags such as `
` `` . So it is advisable to use these tags instead of generic ``.
-
-#### More Information:
-[HTML: Introduction](https://www.w3schools.com/html/html_intro.asp)
diff --git a/client/src/guide/english/html/symbols/index.md b/client/src/guide/english/html/symbols/index.md
deleted file mode 100644
index c3192cc040..0000000000
--- a/client/src/guide/english/html/symbols/index.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: Symbols
----
-
-## Symbols
-
-HTML symbol entities are characters that are not represented on a user's keyboards. Many mathematical, scientific, and currency symbols
-are not present on a normal keyboard; therefore, to add such symbols to a page using HTML, the HTML entity name can be used.
-It is important to note that these will not effect the html code themselves, and will always be interpreted as text. For example, if we wanted to type <div> as text on a webpage, we may need to use these symbol entities.
-
-If no entity name exists, either the entity number or hexadecimal reference can be used.
-
-
-
-#### More Information:
-
-* 
-* 
diff --git a/client/src/guide/english/html/tables/index.md b/client/src/guide/english/html/tables/index.md
deleted file mode 100644
index d1c1688a4f..0000000000
--- a/client/src/guide/english/html/tables/index.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-title: Tables
----
-### Defining an HTML Table
-
-An HTML table is defined with the `
` tag.
-
-Each table row is defined with the `` tag. Inside a row there may be table headers or table data.
-
-* A table header is defined with the `` tag. By default, table headings are bold and centered.
-* A table data/cell is defined with the tag.
-
-A more complex HTML table may also include ``, ` `, ` `, ` `, and ` ` elements in it.
-
-### Simple Table Example
-```html
-
-
- Firstname
- Lastname
- Age
-
-
- Jill
- Smith
- 50
-
-
- Eve
- Jackson
- 94
-
-
-```
- DEMO
-
-### Table Example with more semantic information
-```html
-
-
-
-
-
-
- Item
- Amount
-
-
-
-
- Apple
- 10
-
-
-
-
- Peach
- 15
-
-
- Watermelon
- 3
-
-
-
-
-
-```
-Result:
-
-
-
- Item
- Amount
-
-
-
-
- Apple
- 10
-
-
-
-
- Peach
- 15
-
-
- Watermelon
- 3
-
-
-
-
-
-#### More Information:
-
-MDN Article on the HTML tag
diff --git a/client/src/guide/english/html/tutorials/embedding-youtube-videos/index.md b/client/src/guide/english/html/tutorials/embedding-youtube-videos/index.md
deleted file mode 100644
index c3864454f9..0000000000
--- a/client/src/guide/english/html/tutorials/embedding-youtube-videos/index.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Embedding Youtube Videos
----
-## Embedding Youtube Videos
-
-Probably a lot of times you have seen embedded videos on your favorite websites. Today we will talk about embedding YouTube videos, what is very easy to do, even if you don't have any knownledge about it. For this action we will use `` element. It makes words bold, which function is singling out the fragment of sequence. For example:
-
-```
-The most important part of your code is the end , because if you don't close the element, it will affect to everything !
-```
-
-You can also use `` as well - it adds also semantic "strong" importance. Your browser doesn't recognize a difference between those two elements, but it exists.
-
-### Italic and Emphasized
-Usually used when quote something or putting a translate of word in a lot of articles. It makes them italic - just imagine a little kicked in the right letters. For example:
-
-```
-Theatre - teatos , teates and teatron .
-```
-
-You can also use `` as well - it adds also semantic "emphasized" importance. Your browser doesn't recognize a difference between those two elements, but it exists.
-
-### Small
-It makes your text smaller than normal size of used font. This element's meaning was changed in HTML5 - it represents side-comments and small print.
-
-```
-Normal, small , normal, small !
-```
-
-### Marked
-Element `` makes your text marked - in different words, it makes your text highlighted. You can use it to tell readers that is one of important things in your article. For example:
-
-```
-HTML is full of things and it's our journey to get known them better!
-```
-
-### Deleted
-The element `` makes your text striked in the center. It's useful to show changes in your documents.
-
-```
-WWI started in 1913 1914 year.
-```
-
-### Inserted
-Tag `` makes your text inserted to the article. Using other words that makes it much easier to understand - added. It shows a line under inserted text.
-
-```
-HTML isn't boring. You can make a lot of combinations of elements!
-```
-
-### Subscripted
-Using element `` gives you a useful formatting as subscripted text (showing it smaller on the bottom). There is an example code:
-
-```
-This was in 2003 year (needs a link).
-```
-
-### Superscripted
-If you want to make an opposite to subscripted text, you can easily use `` element. It shows a smaller text on the top.
-
-```
-10x+y = 1000
-```
diff --git a/client/src/guide/english/html/url-encoding-reference/index.md b/client/src/guide/english/html/url-encoding-reference/index.md
deleted file mode 100644
index 60963ae9af..0000000000
--- a/client/src/guide/english/html/url-encoding-reference/index.md
+++ /dev/null
@@ -1,220 +0,0 @@
----
-title: Url Encoding Reference
----
-## Url Encoding Reference
-
-A URL is an address for a website. Just like postal addresses have to follow a specific format to be understood by the postman, URLS have to follow a format to be understood and get you to the right location.
-
-There are only certain characters that are allowed in the URL string, alphabetic characters, numerals, and a few characters `; , / ? : @ & = + $ - _ . ! ~ * ' ( ) #` that can have special meanings.
-
-#### Reserved Characters:
-
-| Character | Meaning |
-| --- | --- |
-| : | Separate protocol (http) from address |
-| / | Separate domain and directories |
-| # | Separate anchors |
-| ? | Separate query string |
-| & | Separate query elements |
-| @ | Separate username and password from domain |
-| % | Indicates an encoded character |
-| + | Indicates a space |
-
-#### Encoding:
-
-Any character that is not an alphabetic character, a number, or a reserved character being used needs to be encoded.
-
-URLs use the ASCII ("American Standard Code for Information Interchange") character-set and so encoding must be to a valid ASCII format.
-
-There are functions in most web languages to do this encoding for you, for example in JavaScript `encodeURI()` and in PHP `rawurlencode()`.
-
-| Character | Encoded |
-| --- | --- |
-| space | %20 |
-| ! | %21 |
-| " | %22 |
-| # | %23 |
-| $ | %24 |
-| % | %25 |
-| & | %26 |
-| ' | %27 |
-| ( | %28 |
-| ) | %29 |
-| * | %2A |
-| + | %2B |
-| , | %2C |
-| - | %2D |
-| . | %2E |
-| / | %2F |
-| 0 | %30 |
-| 1 | %31 |
-| 2 | %32 |
-| 3 | %33 |
-| 4 | %34 |
-| 5 | %35 |
-| 6 | %36 |
-| 7 | %37 |
-| 8 | %38 |
-| 9 | %39 |
-| : | %3A |
-| ; | %3B |
-| < | %3C |
-| = | %3D |
-| > | %3E |
-| ? | %3F |
-| @ | %40 |
-| A | %41 |
-| B | %42 |
-| C | %43 |
-| D | %44 |
-| E | %45 |
-| F | %46 |
-| G | %47 |
-| H | %48 |
-| I | %49 |
-| J | %4A |
-| K | %4B |
-| L | %4C |
-| M | %4D |
-| N | %4E |
-| O | %4F |
-| P | %50 |
-| Q | %51 |
-| R | %52 |
-| S | %53 |
-| T | %54 |
-| U | %55 |
-| V | %56 |
-| W | %57 |
-| X | %58 |
-| Y | %59 |
-| Z | %5A |
-| [ | %5B |
-| \ | %5C |
-| ] | %5D |
-| ^ | %5E |
-| _ | %5F |
-| ` | %60 |
-| a | %61 |
-| b | %62 |
-| c | %63 |
-| d | %64 |
-| e | %65 |
-| f | %66 |
-| g | %67 |
-| h | %68 |
-| i | %69 |
-| j | %6A |
-| k | %6B |
-| l | %6C |
-| m | %6D |
-| n | %6E |
-| o | %6F |
-| p | %70 |
-| q | %71 |
-| r | %72 |
-| s | %73 |
-| t | %74 |
-| u | %75 |
-| v | %76 |
-| w | %77 |
-| x | %78 |
-| y | %79 |
-| z | %7A |
-| { | %7B |
-| | | %7C |
-| } | %7D |
-| ~ | %7E |
-| ¢ | %A2 |
-| £ | %A3 |
-| ¥ | %A5 |
-| | | %A6 |
-| § | %A7 |
-| « | %AB |
-| ¬ | %AC |
-| ¯ | %AD |
-| º | %B0 |
-| ± | %B1 |
-| ª | %B2 |
-| , | %B4 |
-| µ | %B5 |
-| » | %BB |
-| ¼ | %BC |
-| ½ | %BD |
-| ¿ | %BF |
-| À | %C0 |
-| Á | %C1 |
-| Â | %C2 |
-| Ã | %C3 |
-| Ä | %C4 |
-| Å | %C5 |
-| Æ | %C6 |
-| Ç | %C7 |
-| È | %C8 |
-| É | %C9 |
-| Ê | %CA |
-| Ë | %CB |
-| Ì | %CC |
-| Í | %CD |
-| Î | %CE |
-| Ï | %CF |
-| Ð | %D0 |
-| Ñ | %D1 |
-| Ò | %D2 |
-| Ó | %D3 |
-| Ô | %D4 |
-| Õ | %D5 |
-| Ö | %D6 |
-| Ø | %D8 |
-| Ù | %D9 |
-| Ú | %DA |
-| Û | %DB |
-| Ü | %DC |
-| Ý | %DD |
-| Þ | %DE |
-| ß | %DF |
-| à | %E0 |
-| á | %E1 |
-| â | %E2 |
-| ã | %E3 |
-| ä | %E4 |
-| å | %E5 |
-| æ | %E6 |
-| ç | %E7 |
-| è | %E8 |
-| é | %E9 |
-| ê | %EA |
-| ë | %EB |
-| ì | %EC |
-| í | %ED |
-| î | %EE |
-| ï | %EF |
-| ð | %F0 |
-| ñ | %F1 |
-| ò | %F2 |
-| ó | %F3 |
-| ô | %F4 |
-| õ | %F5 |
-| ö | %F6 |
-| ÷ | %F7 |
-| ø | %F8 |
-| ù | %F9 |
-| ú | %FA |
-| û | %FB |
-| ü | %FC |
-| ý | %FD |
-| þ | %FE |
-| ÿ | %FF |
-
-#### Example:
-
-```js
-encodeURI(Free Code Camp);
-// Free%20Code%20Camp
-```
-
-#### More Information:
-
-[MDN encodeURI()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURI)
-
-[https://www.w3schools.com/tags/ref_urlencode.asp](HTML URL Encoding Reference)
diff --git a/client/src/guide/english/java/abstract-class/index.md b/client/src/guide/english/java/abstract-class/index.md
deleted file mode 100644
index 75aaff22f0..0000000000
--- a/client/src/guide/english/java/abstract-class/index.md
+++ /dev/null
@@ -1,48 +0,0 @@
----
-title: Abstract Classes in Java
----
-
-Lets discuss abstract classes. Before diving into this tutorial it is better that you have understood concepts of classes
-and inheritance.
-
-Abstract classes are classes that can be subclassed (i.e. extended) but cannot be instantiated. You can think of them as a **class version** of interfaces, or as an interface with actual code attached to the methods.
-
-Consider the following example to understand abstract classes:
-You have a class Vehicle which defines certain basic functionality (methods) and certain components (object variables) that a machinery should have, to be classified as a vehicle. You cannot create an object of Vehicle because a vehicle in itself is an abstract concept. You can however extend the functionality of the vehicle class to create a Car or a Motorcycle.
-
-``` java
-abstract class Vehicle
-{
- //variable that is used to declare the no. of wheels in a vehicle
- private int wheels;
-
- //Variable to define the type of motor used
- private Motor motor;
-
- //an abstract method that only declares, but does not define the start
- //functionality because each vehicle uses a different starting mechanism
- abstract void start();
-}
-
-public class Car extends Vehicle
-{
- ...
-}
-
-public class Motorcycle extends Vehicle
-{
- ...
-}
-```
-
-You cannot create an object of Vehicle class anywhere in your program. You can however, extend the abstract vehicle class and create objects of the child classes;
-
-``` java
-Vehicle newVehicle = new Vehicle(); // Invalid
-Vehicle car = new Car(); // valid
-Vehicle mBike = new Motorcycle(); // valid
-
-Car carObj = new Car(); // valid
-Motorcycle mBikeObj = new Motorcycle(); // valid
-```
-
diff --git a/client/src/guide/english/java/arraylist/index.md b/client/src/guide/english/java/arraylist/index.md
deleted file mode 100644
index 7eb2641603..0000000000
--- a/client/src/guide/english/java/arraylist/index.md
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: ArrayList
----
-# ArrayList
- ArrayList is a part of something called the *Collection framework*.
-
- The *Collection framework* consists of all interfaces and classes that can hold a set of values (similar to [arrays](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html)). **ArrayList** is a class that is in this hierarchy and known as a _**Collection object**_. It implements the *List* interface which in turn implements the *Collection* interface. This *Collection* interface can be found in the `java.util` package. You will need to import this package.
-
- ArrayList is a class that is used to create dynamic arrays. It is slower than regular arrays but allows for a lot of manipulation. It can be initialized to have a specific size or it will have a default size of 10 units.
-
- ```java
- ArrayList names = new ArrayList<>();
- ArrayList ages = new ArrayList<>(5);
- ```
-
- In the above snippet, the angle breackets `<>` take a generic data type as argument specifying data type of the elements in the ArrayList. The first ArrayList `names` is specified as containing *String* elements. Thus, it will only be allowed to contain String elements. Its size is not specified so it will have a default size of 10. The second ArrayList `ages` has specified that it will only hold integers. But ArrayList cannot hold primitives, it only holds objects. Thus to make it store integers, floats, etc., we can use wrapper classes. `names` will have a specified size of 5.
-
-Since ArrayList implements *List*, an ArrayList can be created using the following syntax:
- ```java
- List students = new ArrayList<>();
- ```
-
- An ArrayList is dynamic, meaning it will grow in size if required and similarly shrink in size if elements are deleted from it. This is what makes it better to use than normal arrays.
-
- An ArrayList allows us to randomly access elements. ArrayList is similar to *Vector* in a lot of ways. But it is faster than Vectors. The main thing to note is that - Vectors are faster than arrays but ArrayLists are not.
-
- So when it comes down to choosing between the two - if speed is critical then Vectors should be considered, otherwise ArrayLists are better when it comes to storing large number of elements and accessing them efficiently.
diff --git a/client/src/guide/english/java/built-in-functions/index.md b/client/src/guide/english/java/built-in-functions/index.md
deleted file mode 100644
index 16c3e43e72..0000000000
--- a/client/src/guide/english/java/built-in-functions/index.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: Built-In Functions
----
-# Built-In Functions
-
-Java also has many built-in or pre-defined functions which are usually stored in the java.lang and java.io packages,
-which are automatically imported in editors like BlueJ or can be imported using the following Syntax-
-```java
-import java.lang.*;
-import java.io.*;
-```
-
-These comprise functions which make an otherwise long and hard task easier to do.
-
-Some examples of ```java.lang.* ``` are:
-
-Generating a random number using Math. In this example a random integer from 1 - 10
-```java
-int randomNumber = (int) (Math.random() * 10) + 1;
-```
-Usage of primitive types such as double, float, int boolean
-
-```java
-int integerNumber = 1;
-double doubleNumber = 0.1d;
-float floatNumber = 0.2f;
-boolean trueOrFalse = false;
-```
-
-
-Classes in ```java.io.* ``` are mainly used for reading and writing of files with diffrent methods such as Input / output streams and buffered readers/ writers.
-And example using a buffered reader is below:
-
-```java
- File file = new File("C:\\Users\\Desktop\\test.txt");
- BufferedReader br = new BufferedReader(new FileReader(file));
- String st;
- while ((st = br.readLine()) != null)
- System.out.println(st);
-```
-
diff --git a/client/src/guide/english/java/finally-keyword/index.md b/client/src/guide/english/java/finally-keyword/index.md
deleted file mode 100644
index 4c759ee4be..0000000000
--- a/client/src/guide/english/java/finally-keyword/index.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: Finally
----
-
-## finally
-The finally block always executes when the try block exits. This ensures that the finally block is executed even if an unexpected exception occurs. But finally is useful for more than just exception handling — it allows the programmer to avoid having cleanup code accidentally bypassed by a return, continue, or break. Putting cleanup code in a finally block is always a good practice, even when no exceptions are anticipated.
-
-***Example:***
-```java
-try {
- // Normal execution path
- throw new EmptyStackException();
-} catch (ExampleException ee) {
- // deal with the ExampleException
-} finally {
- // This optional section is executed upon termination of any of the try or catch blocks above,
- // except when System.exit() is called in "try" or "catch" blocks;
-}
-```
diff --git a/client/src/guide/english/java/inheritance/index.md b/client/src/guide/english/java/inheritance/index.md
deleted file mode 100644
index 597e0058a7..0000000000
--- a/client/src/guide/english/java/inheritance/index.md
+++ /dev/null
@@ -1,191 +0,0 @@
----
-title: Inheritance
----
-# Inheritance
-
-Java inheritance refers to the ability of a Java Class to `inherit` the properties from some other Class. Think of it like a child inheriting properties from its parents, the concept is very similar to that. In Java lingo, it is also called _extend_-ing a class. Some simple things to remember :
-
-* The Class that extends or inherits is called a **subclass**
-* The Class that is being extended or inherited is called a **superclass**
-
-Thus, inheritance gives Java the cool capability of _re-using_ code, or sharing code between classes!
-
-Let's describe it with the classic example of a `Vehicle` class and a `Car` class :
-
-```java
-public class Vehicle {
- public void start() {
- // starting the engine
- }
-
- public void stop() {
- // stopping the engine
- }
-}
-
-public class Car extends Vehicle {
- int numberOfSeats = 4;
-
- public int getNumberOfSeats() {
- return numberOfSeats;
- }
-}
-```
-
-Here, we can see the `Car` class inheriting the properties of the `Vehicle` class. So, we don't have to write the same code for the methods `start()` and `stop()` for `Car` as well, as those properties are available from its parent or superclass. Therefore, objects created from the `Car` class will _also_ have those properties!
-
-```java
-Car tesla = new Car();
-
-tesla.start();
-
-tesla.stop();
-```
-
- Run Code
-
-But, does the parent class have the methods of the child? No, it doesn't.
-
-Therefore, whenever you need to share some common piece of code between multiple classes, it is always good to have a parent class, and then extend that class whenever needed! Reduces the number of lines of code, makes code modular, and simplifies testing.
-
-## What can be inherited ?
-
-* All `protected` and `public` fields and methods from parent
-
-## What cannot be inherited ?
-
-* `private` fields and methods
-* Constructors. Although, the subclass constructor _has_ to call the superclass constructor if its defined (More on that later!)
-* Multiple classes. Java supports only **single inheritance**, that is, you can only inherit one class at a time.
-* Fields. Individual fields of a class cannot be overriden by the subclass.
-
-## Type Casting & Reference
-
-In Java, it is possible to reference a subclass as an _instance_ of its superclass. It is called _Polymorphism_ in Object Oriented Programming (OOP), the ability for an object to take on many forms. For example, the `Car` class object can be referenced as a `Vehicle` class instance like this :
-
-```java
-Vehicle car = new Car();
-```
-
-Although, the opposite is not possible :
-
-```java
-Car car = new Vehicle(); // ERROR
-```
-
- Run Code
-
-Since you can reference a Java subclass as a superclass instance, you can easily cast an instance of a subclass object to a superclass instance. It is possible to cast a superclass object into a subclass type, but _only if the object is really an instance of the subclass_. So keep this in mind :
-
-```java
-Car car = new Car();
-Vehicle vehicle = car; // upcasting
-Car car2 = (Car)vechile; //downcasting
-
-Bike bike = new Bike(); // say Bike is also a subclass of Vehicle
-Vehicle v = bike; // upcasting, no problem here.
-Car car3 = (Car)bike; // Compilation Error : as bike is NOT a instance of Car
-```
-
- Run Code
-
-Now you know how to share code through a parent-child relationship. But, what if, you do not like the implementation of a particular method in the child class and want to write a new one for it? What do you do then?
-
-## Override it!
-
-Java lets you _override_ or redefine the methods defined in the superclass. For example, your `Car` class has a different implementation of `start()` than the parent `Vehicle`, so you do this :
-
-```java
-public class Vehicle {
- public void start() {
- System.out.println("Vehicle start code");
- }
-}
-
-public class Car extends Vehicle {
- public void start() {
- System.out.println("Car start code");
- }
-}
-
-Car car = new Car();
-car.start(); // "Car start code"
-```
-
- Run Code
-
-So, it's pretty simple to override methods in the subclass. Although, there is a _catch_. Only that superclass method with the _exact same method signature_ as the subclass method will be overriden. That means the subclass method definition must have the exact same name, same number and type of parameters, and in the exact same sequence. Thus, `public void start(String key)` would not override `public void start()`.
-
-**Notes** :
-
-* You cannot override private methods of the superclass. (Quite obvious, isn't it?)
-* What if the method of superclass which you are overriding in the subclass suddenly gets obliterated or methods changed? It would fail in runtime! So Java provides you a nifty annotation `@Override` which you can place over the subclass method, which will warn the compiler of those incidents!
-
-Annotations in Java is a good coding practice, but they are not a necessity. The compiler is smart enough to figure out overriding on its own though. Unlike other OOP languages, Annotations in Java it doesn't necessarily modify the method or add extra functionality.
-
-## How to call super class methods?
-
-Funny you ask about it! Just use the keyword `super` :
-
-```java
-public class Vehicle() {
- public void start() {
- System.out.println("Vehicle start code");
- }
-}
-
-public class Car extends Vehicle {
- public void run() {
- super.start();
- }
-}
-
-Car car = new Car();
-car.run(); // "Vehicle start code"
-```
-
- Run Code
-
-**N.B.** : Although you can call the parent method by using a `super` call, you cannot go up the inheritance hierarchy with chained `super` calls.
-
-## How to know the type of a class?
-
-Using the `instanceof` keyword. Having lots of classes and subclasses it would be a little confusing to know which class is a subclass of which one in runtime. So, we can use `instanceof` to determine whether an object is an instance of a class, an instance of a subclass, or an instance of an interface.
-
-```java
-Car car = new Car();
-
-boolean flag = car instanceof Vehicle; // true in this case!
-```
-
-## Constructors & Inheritance
-
-As mentioned earlier, constructors cannot be directly inherited by a subclass. Although, a subclass is _required_ to call its parent's constructor as the first operation in its own constructor. How? You guessed it, using `super` :
-
-```java
-public class Vehicle {
- public Vehicle() {
- // constructor
- }
- public void start() {
- System.out.println("Vehicle start code");
- }
-}
-
-public class Car extends Vehicle {
- public Car() {
- super();
- }
- public void run() {
- super.start();
- }
-}
-```
-
- Run Code
-
-Remember, if the superclass does not have any constructors defined, you don't have to call it explicitely in the subclass. Java handles that internally for you! Invocation to `super` constructor is done in the case when the super class is to be called with any other constructor other than the _default constructor_.
-
-If no other constructors are defined, then Java invokes the default super class constructor (_even if not defined explicitly_).
-
-Congrats, now you know all about Inheritance! Read more about advanced ways to inherit things in Abstract Classes and [Interfaces](//forum.freecodecamp.com/t/java-docs-interfaces)!
diff --git a/client/src/guide/english/java/javafx/index.md b/client/src/guide/english/java/javafx/index.md
deleted file mode 100644
index 1a4353ca51..0000000000
--- a/client/src/guide/english/java/javafx/index.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: JavaFX
----
-## Introduction
-JavaFX is a graphics framework created by Sun Microsystems used for developing rich desktop and Internet applications. JavaFX was created to replace the much older Swing and Abstract Window Toolkit (AWT) libraries and serve as the Java language's standard graphics API for Java Standard Edition.
-
-## Development Tools
-
-### Gulon SceneBuilder
-Gulon Scene Builder is an application used for user interface (UI) design in JavaFX. The application uses drag-and-drop for rapid UI design that allows you to visualize the interface you are creating while designing it.
-
-#### Screeenshots:
-
-
-### FXML
-FXML is an XML-based markup language used for defining structures in JavaFX. The FXML document lays out the various objects in the class in a tree similar to tag nesting in XML documents.
-
-#### Example:
-```XML
- // Creates an HBox Object
-
-```
-
-### References:
-[FXML Documentation](https://docs.oracle.com/javase/8/javafx/api/javafx/fxml/doc-files/introduction_to_fxml.html)
-
-[Scene Builder Tutorial](https://docs.oracle.com/javase/8/scene-builder-2/get-started-tutorial/overview.htm#JSBGS164)
-
-[Official JavaFX Documentation](https://docs.oracle.com/javase/8/javase-clienttechnologies.htm)
diff --git a/client/src/guide/english/java/lambda-expressions/index.md b/client/src/guide/english/java/lambda-expressions/index.md
deleted file mode 100644
index b73e402e75..0000000000
--- a/client/src/guide/english/java/lambda-expressions/index.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-title: Lambda Expressions
----
-## Lambda Expressions
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-The Stream Api is used in java to allow chaining of sequential and aggregate operations. Stream operations are either intermediate or terminal in nature.
-
-In this small example you can see that one of the utilities of a stream is to receive a certain property of all objects in a list and return it in another list using intermediate and terminal operations.
-
-Assume you have an object class of Student.
-``java
-public class Student {
- int studentId;
- String studentName;
-
- public String getStudentName() {
- return this.studentName;
- }
-
- public int getStudentId() {
- return this.studentId;
- }
- // setters
-}
-``
-
-Now assume in some method you have a list of all the students and want to get a list of all the student names.
-Traditionally this can looks something like this.
-
-``java
-List students = some list of student objects
-
-List studentNames = new ArrayList<>();
-for(Student student: students) {
- studentNames.add(student.getStudentName());
-}
-``
-While this isn't terrible it can be simplified.
-Using streams this is possible with one line of code.
-
-``java
-List students = some list of student objects
-
-List studentNames = students.stream().map(String::getStudentName).collect(Collectors.toList());
-``
-
-The students stream api goes over the list of students and uses the intermediate map function to return a new list of streams using whatever method is on the right of the ::
-
-The terminal collect operation collects the stream as a list of strings.
-
-This is only one use of the Streams Api used in java 8. There are many other applications of streams utilizing the other operations as seen here in the documentation.
- [Streams api doc](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html)
-
-#### More Information:
-
diff --git a/client/src/guide/english/java/methods/index.md b/client/src/guide/english/java/methods/index.md
deleted file mode 100644
index bd7a15dad7..0000000000
--- a/client/src/guide/english/java/methods/index.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-title: Methods
----
-# Methods
-The most recognizable method in Java is probably `public static void main(String[]args)` where `public` means that users have access to the method, `static` means that the method is based on a "class" rather than an "instance," `void` means that nothing will be returned from the method to another (higher level) method, and `main` which is the name of this particular method.
-
-`getName()` and `getManufacturerName()` are two "Getter" methods we have used here. Generally, methods in Java consist of these parts -
-
-* Access Modifer (Optional) - `public`, `private`, or `protected`. Defaults to package private if omitted
-* Return Type - This is required, it denotes what value the method returns, or `void` if nothing is returned
-* Method Name - follows camelCase convention
-* Parameter List - List of parameters with their name and type, empty if no parameters are accepted
-* Method body surrounded by `{ }`
-
-Methods can also optionally have the `static` keyword, meaning it is associated with the class itself, rather than an instance of the class, ex - `public static void main()`.
-
-Notice, unlike JavaScript, we **have** to define the return type of any method we write, otherwise it will fail at compile time. If you do not want a method to return anything, use `void` return type.
-
-Each method has a signature, which is the combination of the data type, the name, and the number of arguments the method takes. In `public static void main` the method does not have a specified data type and instead uses `void` to declare that no data is returned. In a method named `public static double ave(double val, double val)` the data type is "double" (0.0), the name is "ave" (average) and the method takes 2 arguments. Each method **must** have a unique signature.
-
-```java
-public class Car {
- private String name;
- private String manufacturersName;
-
- public void changeName() {
- name = "Tesla";
- }
-
- public String getName(){
- return name;
- }
-
- public String getManufacurername(){
- return manufacturersName;
- }
-
-}
-```
-Parameters can be passed into methods. Parameters are declared just after the name of the method, inside brackets.
-Syntax for parameter declaration is [Data Type] [Name].
-```java
-public class Car {
- private String name;
-
- public void changeName(String newName) {
- name = newName;
- }
-}
-```
-
-As with any other language, methods (or functions, if you are here from JS world) are used often for their modularity and reusability.
-
-Methods often serve many purposes such as updating information in an object or providing data back to the caller. Here are some examples.
-
-```java
-public class Car {
- private int numberOfWheels;
-
- public void setNumberOfWheels(int newNumberOfWheels) {
- numberOfWheels = newNumberOfWheels;
- }
-
- public int getNumberOfWheels() {
- return numberOfWheels;
- }
-}
-```
-
-In the case of `getNumberOfWheels()` the return type is `int` which is a whole number. The keyword `return` tells java to pass back the value of the instance variable `numberOfWheels`. `setNumberOfWheels(int newNumberOfWheels)` however has no return type as it is a setter method as previously seen. In this case though it takes in an argument of type `int` and makes the instance varible `numberOfWheels` equal to `newNumberOfWheels`.
-
-There is also a special method called a constructor that allows for data to be set or operations to be performed when the class is instantiated. This constructor has no return type.
-
-```java
-public class Car {
- private String model;
- private int numberOfWheels;
-
- public Car(String model, int numberOfWheels) {
- this.model = model;
- this.numberOfWheels = numberOfWheels;
- }
-}
-```
-
-The `Car` class and the `Car(String model, int numberOfWheels)` method have to have the same name in order for java to know that it is the constructor. Now anytime you instantiate a new `Car` instance with the `new` keyword you will need to call this constructor and pass in the needed data.
diff --git a/client/src/guide/english/java/multithreading/index.md b/client/src/guide/english/java/multithreading/index.md
deleted file mode 100644
index 7d8f749c44..0000000000
--- a/client/src/guide/english/java/multithreading/index.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: Multithreading
----
-
-## Multithreading
-
-Multithreading is a process of executing multiple processes simultaneously. Java starts the program with a main thread and further threads are added upon main thread whenever any user creates it. main thread is the first user thread in any Java program. Also, JVM makes sure that all the user threads are closed before the program ends.
-
-A thread has both advantages and disadvantages.
-
-## Advantages:
-
-* Running code independently of other threads.
-* Creation of a modular design.
-
-## Disadvantages:
-
-Race conditions and Deadlocks if threads are not syncrhronized properly.
-
-Threads can further be divided into two classes:
- * User Threads
- * Daemon Threads
-
-
-A thread can be created in 2 ways:
-1. implementing Runnable interface:
-There is only one method in Runnable interface i.e. public void run(). Implementing this method will make sure that whenever this thread starts the code inside run() executes.
-
-2. extending thread class.
-This class also contains public void run() which we need to override in order to run our own code. The disadvantage of using this method is that we have a superclass in Thread and cannot extend any other class which we may want to.
-
-The code for both can be found here: http://ide.geeksforgeeks.org/k7GjcA.
-
-You will notice that if this code is ran multiple times, the results may differ. and that is decided by the OS upon which it is run. The OS can pick any thread from a runnable state and can run it. We hsve NO CONTROL over that. If there are multiple threads in runnable state (ready to run), anyone can be picked. It even does not depend upon priority.
-
-Further details: https://www.ntu.edu.sg/home/ehchua/programming/java/J5e_multithreading.html
diff --git a/client/src/guide/english/java/regular-expressions/index.md b/client/src/guide/english/java/regular-expressions/index.md
deleted file mode 100644
index 2d02139213..0000000000
--- a/client/src/guide/english/java/regular-expressions/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Regular Expressions
----
-## Regular Expressions
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/java/resources/index.md b/client/src/guide/english/java/resources/index.md
deleted file mode 100644
index 313b5c2866..0000000000
--- a/client/src/guide/english/java/resources/index.md
+++ /dev/null
@@ -1,48 +0,0 @@
----
-title: Resources
----
-# Resources
-
-Java is trademarked and licensed by Oracle. Most of the following are un-official resources, unless hosted by Oracle.
-
-## Tutorials
-
-* [Oracle Official Java Tutorial](http://docs.oracle.com/javase/tutorial/index.html)
-* [Think Java](http://greenteapress.com/wp/think-java/)
-* [Jenkov's Java Tutorials](http://tutorials.jenkov.com/java/index.html)
-* [Mkyong's Java & Spring Tutorials](http://www.mkyong.com/)
-* [Vogella's Java Tutorials](http://www.vogella.com/tutorials/java.html)
-* [Java 8 Tutorial](https://github.com/winterbe/java8-tutorial)
-* [Better Java](https://github.com/cxxr/better-java)
-* [Java Programming notes by NTU](http://www3.ntu.edu.sg/home/ehchua/programming/index.html#Java)
-* [HackerRank's 30 days of Code Challenge with video tutorials in Java<](https://www.hackerrank.com/domains/tutorials/30-days-of-code)
-* [Princeton's Introduction to Programming in Java](http://introcs.cs.princeton.edu/java/home/)
-* [Introduction to Programming Using Java](http://math.hws.edu/javanotes/)
-* [Java Practices](http://javapractices.com/home/HomeAction.do)
-* [Java Design Patterns](https://github.com/iluwatar/java-design-patterns/)
-* [Algorithms in Java](https://github.com/pedrovgs/Algorithms)
-* [Spring Official Guides](https://spring.io/guides)
-* [TutorialsPoint - Java](http://www.tutorialspoint.com/java/)
-* [Java for Small Teams](https://www.gitbook.com/book/ncrcoe/java-for-small-teams/details)
-
-## Challenges
-
-* [Java Koans](https://github.com/matyb/java-koans)
-* [Coding Bat Java Challenges](http://codingbat.com/java)
-* [Excercism Java Challenges](http://exercism.io/languages/java)
-* [Project Euler](https://projecteuler.net/)
-* [Practice It! - Java Challenges](http://practiceit.cs.washington.edu/)
-* [Codewars - Java Katas](https://www.codewars.com/?language=java)
-* [HackerRank Java Challenges](https://www.hackerrank.com/domains/java/java-introduction)
-* [LeetCode](https://leetcode.com/)
-* [CodeAbbey](http://www.codeabbey.com/)
-
-## Community
-
-* [Oracle Java Community](http://www.oracle.com/technetwork/java/community/index.html)
-* [Awesome Java](https://github.com/akullpp/awesome-java)
-* [/r/Java](https://www.reddit.com/r/Java)
-* [/r/LearnJava](https://www.reddit.com/r/learnjava)
-* [Java Ranch](http://www.javaranch.com/)
-* [Java Code Geeks](https://www.javacodegeeks.com/)
-* [Java 8 API Search](http://javasearch.org)
diff --git a/client/src/guide/english/java/strings/index.md b/client/src/guide/english/java/strings/index.md
deleted file mode 100644
index 9b5ff6b204..0000000000
--- a/client/src/guide/english/java/strings/index.md
+++ /dev/null
@@ -1,143 +0,0 @@
----
-title: Strings
----
-# Strings
-
-Strings are sequences of characters. In Java, a `String` is an `Object`. Strings should not be confused with `char` as characters are literally 1 value rather than a sequence of characters. You can still use 1 value within a String, however it is preferred to use `char` when you are checking for 1 character.
-
-```java
-String course = "FCC";
-System.out.println(course instanceof Object);
-```
-
-Output:
-```
-true
-```
-
-You can create a String Object in the following ways:
-
-1. `String str = "I am a String"; //as a String literal`
-1. `String str = "I am a " + "String"; //as a constant expression`
-1. `String str = new String("I am a String"); //as a String Object using the constructor`
-
-You might be thinking: What's the difference between the three?
-
-Well, using the `new` keyword guarantees that a new `String` object will be created and a new memory location will be allocated in the `Heap`
-memory [(click here to learn more)](https://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/geninfo/diagnos/garbage_collect.html). String
-literals and constant String expressions are cached at compile time. The compiler puts them in the String Literal Pool to prevent duplicates
-and improve memory consumption. Object allocation is expensive and this trick increases performance while instantiating Strings. If you use
-the same literal again, the JVM uses the same object. Using the contructor like above is almost always a worse choice.
-
-In this code snippet, how many String objects are created?
-
-```java
-String str = "This is a string";
-String str2 = "This is a string";
-String str3 = new String("This is a string");
-```
-
-The answer is: 2 String objects are created. `str` and `str2` both refer to the same object. `str3` has the same content but using `new` forced
-the creation of a new, distinct, object.
-
-When you create a String literal, the JVM internally checks, what is known as the `String pool`, to see if it can find a similar (content wise)
-String object. If it finds it, it returns the same reference. Otherwise, it just goes ahead and creates a new String object in the pool so that
-the same check can be performed in the future.
-
-You can test this using the swallow, fast Object comparison `==` and the implemented `equals()`.
-
-```java
-System.out.println(str == str2); // This prints 'true'
-System.out.println(str == str3); // This prints 'false'
-System.out.println(str.equals(str3)); // This prints 'true'
-```
-
-Here's another example on how to create a string in Java using the different methods:
-
-```java
-public class StringExample{
-
- public static void main(String args[]) {
- String s1 = "java"; // creating string by Java string literal
- char ch[] = {'s','t','r','i','n','g','s'};
- String s2 = new String(ch); // converting char array to string
- String s3 = new String("example"); // creating Java string by new keyword
- System.out.println(s1);
- System.out.println(s2);
- System.out.println(s3);
- }
-}
-```
-
-#### Comparing Strings
-If you want to compare the value of two String variables, you can't use ==. This is due to the fact that this will compare the references of the variables
-and not the values that are linked to them. To compare the stored values of the Strings you use the method equals.
-
-```java
-boolean equals(Object obj)
-```
-
-It returns true if two objects are equal and false otherwise.
-```java
-String str = "Hello world";
-String str2 = "Hello world";
-
-System.out.println(str == str2); // This prints false
-System.out.println(str.equals(str2); // This prints true
-```
-The first comparison is false because "==" looks at the references and they aren't the same.
-
-The second comparison is true because the variables store the same values. In this case "Hello world".
-
-We have several inbuilt methods in String. The following is an example of the String Length() method .
-
-```java
-public class StringDemo {
-
- public static void main(String args[]) {
- String palindrome = "Dot saw I was Tod";
- int len = palindrome.length();
- System.out.println( "String Length is : " + len );
- }
-}
-```
-This will result in - `String Length is : 17`
-
-The answer is: 2 String objects are created.
-**Notes**
-
-1. String methods use zero-based indexes, except for the second argument of `substring()`.
-2. The String class is final - it's methods can't be overridden.
-3. When the String literal is found by JVM, it is added to string literal pool.
-4. String class posses a method name `length()`, while arrays have an attribute naming length.
-5. In java, string objects are immutable. Immutable simply means unmodifiable or unchangeable. Once string object is created its data or state can't be changed but a new string object is created.
-
-
-String Length
-
-The "length" of a string is just the number of chars in it. So "hi" is length 2 and "Hello" is length 5. The length() method on a string returns its length, like this:
-
-```java
-String a = "Hello";
-int len = a.length(); // len is 5
-```
-#### Other comparison methods which can also be used on the String are :
-
-1. equalsIgnoreCase() :- compares the string without taking into consideration the case sensitivity.
-
-```java
-String a = "HELLO";
-String b = "hello";
-System.out.println(a.equalsIgnoreCase(b)); // It will print true
-```
-
-2. compareTo :- compares the value lexicographically and returns an integer.
-
-```java
-String a = "Sam";
-String b = "Sam";
-String c = "Ram";
-System.out.println(a.compareTo(b)); // 0
-System.out.prinltn(a.compareTo(c)); // 1 since (a>b)
-System.out.println(c.compareTo(a)); // -1 since (cJavaScript for Cats
-* The Modern JavaScript Tutorial
-* Professor Frisby's Mostly Adequate Guide to Functional Programming
-* Eloquent Javascript (_annotated_ )
-* Speaking Javascript
-* Exploring ES6
-* Udemy - Javascript Understanding the Weird Parts (_first 3.5 hrs_)
-* Functional programming in JavaScript
-* Introduction to JavaScript: First Steps
-* Douglas Crockford's Videos
-* Modern JS Cheatsheet
-* The 50 Best Websites to Learn JavaScript
-* Codementor JavaScript tutorial
-* You Might Not Need jQuery
-
-## References
-
-* DevDocs
-* OverAPI JavaScript Cheat Sheet
-* ECMA-262
-* Mozilla Developer Network (MDN)
-
-Find javascript libraries at http://jster.net
-
-## Quick JavaScript
-
-* REPL (_node_ )
-* JSBin
-* JSFiddle
-* CodePen
-* CoderPad (_pair programming_)
-* C9 (_IDE_, _pair programming_)
-* Object Playground (_visualize objects_)
-* Plunker
-
-## Challenges
-
-* Code Wars
-* Hacker Rank
-* Coding Game
-* CodeFights
-* ES6 Katas
-
-## Tutorials
-
-* Codecademy
-* RithmSchool
-
-## Exercises
-
-* Codility
-* Coderbyte
-* Exercism
-* JavaScript30
-* Javascript.com (Pluralsight)
-
-## Editors
-
-* Visual Studio Code
-
- Visual Studio Code includes built-in support for IntelliSense code completion, rich semantic code understanding and navigation, and code refactoring. It comes with a built-in debugger and git support and has a plethora of extensions.
-
-* Webstorm
-
- A full-feature IDE for Javascript, including code completion and support for live linting, version control, and testing. Made by Jet Brains and modelled after their IntelliJ Java IDE.
-* Brackets
-* Atom
-
- Open source text editor made by GitHub.
-
-* Sublime Text
-
-## Blogs
-
-* Perfection Kills
-* 2ality
-* JS collection on Medium
-* David Walsh
-* superheroJS
-
-
-
-## Podcasts
-* JS Jabber
-
-
-
-## Video Tutorials
-
-* Derek Banas' Learn JS In One Video
-* Derek Banas' Object Oriented JavaScript
-
-## Books
-
-* Secrets of the JavaScript Ninja
-* Programming JavaScript Applications
-* Maintainable JavaScript
-* Learning JavaScript Design Patterns
-* Airbnb JavaScript Style Guide
-* JSDoc
-* Javascript Allonge Six
-* You Don't Know JS
-
- 6 books on JavaScript by Kyle Simpson. From beginner to advanced.
-
-* Eloquent Javascript
-
- Fantastic, thorough introduction to the basics and features of Javascript, complete with in-browser interactive code
-
-
-* Professor Frisby's Mostly Adequate Guide to Functional Programming
-
- Quite in-depth guide to Functional Programming in Javascript
-
-* The JavaScript Way
-
-* Functional Light JS
-
- This book aims to be a useful companion for anyone wishing to (re)discover the many facets of JavaScript. From the very basics of programming up to front-end and back-end web development, a lot of topics are covered in a simple and accessible way. No prior knowledge needed!
diff --git a/client/src/guide/english/javascript/advantages-and-disadvantages-of-javascript/index.md b/client/src/guide/english/javascript/advantages-and-disadvantages-of-javascript/index.md
deleted file mode 100644
index b2bd2e9fe1..0000000000
--- a/client/src/guide/english/javascript/advantages-and-disadvantages-of-javascript/index.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: Advantages and Disadvantages of JavaScript
----
-# Advantages and Disadvantages of JavaScript
-Like all computer languages, JavaScript has certain advantages and disadvantages. Many of the pros and cons are related to JavaScript executing often in a client's browser, but there are other ways to use JavaScript now that allow it to have the same benefits of server-side languages.
-
-## Advantages of JavaScript
-
-* **Speed**. Client-side JavaScript is very fast because it can be run immediately within the client-side browser. Unless outside resources are required, JavaScript is unhindered by network calls to a backend server. It also has no need to be compiled on the client side which gives it certain speed advantages (granted, adding some risk dependent on that quality of the code developed).
-* **Simplicity**. JavaScript is relatively simple to learn and implement.
-* **Popularity**. JavaScript is used everywhere in the web. The resources to learn JavaScript are numerous. StackOverflow and GitHub have many projects that are using Javascript and the language as a whole has gained a lot of traction in the industry in recent years especially.
-* **Interoperability**. JavaScript plays nicely with other languages and can be used in a huge variety of applications. Unlike PHP or SSI scripts, JavaScript can be inserted into any web page regardless of the file extension. JavaScript can also be used inside scripts written in other languages such as Perl and PHP.
-* **Server Load**. Being client-side reduces the demand on the website server.
-* **Rich interfaces**. Drag and drop components or slider may give a rich interface to your website.
-* **Extended Functionality**. Third party add-ons like Greasemonkey enable JavaScript developers to write snippets of JavaScript which can execute on desired web pages to extend its functionality.
-* **Versatility**. Nowadays, there are many ways to use JavaScript through Node.js servers. If you were to bootstrap node.js with Express, use a document database like mongodb, and use JavaScript on the front-end for clients, it is possible to develop an entire JavaScript app from front to back using only JavaScript.
-* **Updates**. Since the advent of EcmaScript 5 (the scripting specification that Javascript relies on), Ecma International has dedicated to updating JavaScript annually. So far, we have received browser support for ES6 in 2017 and look forward to ES7 being supported in future months.
-
-## Disadvantages of JavaScript
-
-* **Client-Side Security**. Because the code executes on the users' computer, in some cases it can be exploited for malicious purposes. This is one reason some people choose to disable Javascript.
-* **Browser Support**. JavaScript is sometimes interpreted differently by different browsers. Whereas server-side scripts will always produce the same output, client-side scripts can be a little unpredictable. Don't be overly concerned by this though - as long as you test your script in all the major browsers you should be safe. Also, there are services out there that will allow you to test your code automatically on check in of an update to make sure all browsers support your code.
diff --git a/client/src/guide/english/javascript/arithmetic-operation/index.md b/client/src/guide/english/javascript/arithmetic-operation/index.md
deleted file mode 100644
index 57ede6aa0a..0000000000
--- a/client/src/guide/english/javascript/arithmetic-operation/index.md
+++ /dev/null
@@ -1,119 +0,0 @@
----
-title: Arithmetic Operation
----
-JavaScript provides the user with five arithmetic operators: `+`, `-`, `*`, `/` and `%`. The operators are for addition, subtraction, multiplication, division and remainder respectively.
-
-## Addition
-
-**Syntax**
-
-`a + b`
-
-**Usage**
-
- 2 + 3 // returns 5
- true + 2 // interprets true as 1 and returns 3
- false + 5 // interprets false as 0 and returns 5
- true + "bar" // concatenates the boolean value and returns "truebar"
- 5 + "foo" // concatenates the string and the number and returns "5foo"
- "foo" + "bar" // concatenates the strings and returns "foobar"
-
-_Hint:_ There is a handy increment ) operator that is a great shortcut when you're adding numbers by 1.
-
-## Subtraction
-
-**Syntax**
-
-`a - b`
-
-**Usage**
-
- 2 - 3 // returns -1
- 3 - 2 // returns 1
- false - 5 // interprets false as 0 and returns -5
- true + 3 // interprets true as 1 and returns 4
- 5 + "foo" // returns NaN (Not a Number)
-
-_Hint:_ There is a handy decrement ) operator that is a great shortcut when you're subtracting numbers by 1.
-
-## Multiplication
-
-**Syntax**
-
-`a * b`
-
-**Usage**
-
- 2 * 3 // returns 6
- 3 * -2 // returns -6
- false * 5 // interprets false as 0 and returns 0
- true * 3 // interprets true as 1 and returns 3
- 5 * "foo" // returns NaN (Not a Number)
- Infinity * 0 // returns NaN
- Infinity * Infinity // returns Infinity
-
-## Division
-
-**Syntax**
-
-`a / b`
-
-**Usage**
-
- 3 / 2 // returns 1.5
- 3.0 / 2/0 // returns 1.5
- 3 / 0 // returns Infinity
- 3.0 / 0.0 // returns Infinity
- -3 / 0 // returns -Infinity
- false / 5 // interprets false as 0 and returns 0
- true / 2 // interprets true a 1 and returns 0.5
- 5 + "foo" // returns NaN (Not a Number)
- Infinity / Infinity // returns NaN
-
-## Remainder
-
-**Syntax**
-
-`a % b`
-
-**Usage**
-
- 3 % 2 // returns 1
- true % 5 // interprets true as 1 and returns 1
- false % 4 // interprets false as 0 and returns 0
- 3 % "bar" // returns NaN
-
-## Increment
-
-**Syntax**
-
-`a++ or ++a`
-
-**Usage**
-
- // Postfix
- x = 3; // declare a variable
- y = x++; // y = 4, x = 3
-
- // Prefix
- var a = 2;
- b = ++a; // a = 3, b = 3
-
-## Decrement
-
-**Syntax**
-
-`a-- or --a`
-
-**Usage**
-
- // Postfix
- x = 3; // declare a variable
- y = x--; // y = 3, x = 3
-
- // Prefix
- var a = 2;
- b = --a; // a = 1, b = 1
-_!Important!_ As you can see, you **cannot** perform any sort of operations on `Infinity`.
-
-Source: The amazing MDN .
diff --git a/client/src/guide/english/javascript/arrow-functions/index.md b/client/src/guide/english/javascript/arrow-functions/index.md
deleted file mode 100644
index 1166aea85d..0000000000
--- a/client/src/guide/english/javascript/arrow-functions/index.md
+++ /dev/null
@@ -1,66 +0,0 @@
----
-title: Arrow Functions
----
-
-Arrow functions are a new ES6 syntax for writing JavaScript function expressions. The shorter syntax saves time, as well as simplifying the function scope.
-
-## What are arrow functions?
-
-An arrow function expression is a more concise syntax for writing function expressions using a "fat arrow" token (`=>`).
-
-### The basic syntax
-
-Below is a basic example of an arrow function:
-
-```javascript
-// ES5 syntax
-var multiply = function(x, y) {
- return x * y;
-};
-
-// ES6 arrow function
-var multiply = (x, y) => { return x * y; };
-
-// Or even simpler
-var multiply = (x, y) => x * y;
-```
-
-You no longer need the `function` and `return` keywords, or even the curly brackets.
-
-### A simplified `this`
-
-Before arrow functions, new functions defined their own `this` value. To use `this` inside a traditional function expression, we have to write a workaround like so:
-
-```javascript
-// ES5 syntax
-function Person() {
- // we assign `this` to `self` so we can use it later
- var self = this;
- self.age = 0;
-
- setInterval(function growUp() {
- // `self` refers to the expected object
- self.age++;
- }, 1000);
-}
-```
-
-An arrow function doesn't define it's own `this` value, it inherits `this` from the enclosing function:
-
-```javascript
-// ES6 syntax
-function Person(){
- this.age = 0;
-
- setInterval(() => {
- // `this` now refers to the Person object, brilliant!
- this.age++;
- }, 1000);
-}
-
-var p = new Person();
-```
-
-#### Further Reading
-
-MDN link
\ No newline at end of file
diff --git a/client/src/guide/english/javascript/assignment-operators/index.md b/client/src/guide/english/javascript/assignment-operators/index.md
deleted file mode 100644
index 90b29e3c0b..0000000000
--- a/client/src/guide/english/javascript/assignment-operators/index.md
+++ /dev/null
@@ -1,63 +0,0 @@
----
-title: Assignment Operators
----
-
-# Assignment Operators
-
-Assignment operators, as the name suggests, assign (or re-assign) values to a variable. While there are quite a few variations on the assignment operators, they all build off of the basic assignment operator.
-
-## Syntax
-
-`x = y;` | Description | Necessity
-:---------:|:---------------------:|:---------:
-`x` | Variable | Required
-`=` | Assignment operator | Required
-`y` | Value to assign to variable | Required
-
-## Examples
-
- let initialVar = 5; // Variable initialization requires the use of an assignment operator
-
- let newVar = 5;
- newVar = 6; // Variable values can be modified using an assignment operator
-
-## Variations
-
-The other assignment operators are a shorthand for performing some operation using the variable (indicated by x above) and value (indicated by y above) and then assigning the result to the variable itself.
-
-For example, below is the syntax for the addition assignment operator:
-
- x += y;
-
-This is the same as applying the addition operator and reassigning the sum to the original variable (i.e., x), which can be expressed by the following code:
-
- x = x + y;
-
-To illustrate this using actual values, here is another example of using the addition assignment operator:
-
- let myVar = 5; // value of myVar: 5
- myVar += 7; // value of myVar: 12 = 5 + 7
-
-## Complete list of Javascript's assignment operators
-
-Operator | Syntax | Long version
-------------------------------- | --------- | -------------
-Assignment | x = y | x = y
-Addition assignment | x += y | x = x + y
-Subtraction assignment | x -= y | x = x - y
-Multiplication assignment | x *= y | x = x * y
-Division assignment | x /= y | x = x / y
-Remainder assignment | x %= y | x = x % y
-Exponentiation assignment | x **= y | x = x ** y
-Left shift assignment | x <<= y | x = x << y
-Right shift assignment | x >>= y | x = x >> y
-Unsigned right shift assignment | x >>>= y | x = x >>> y
-Bitwise AND assignment | x &= y | x = x & y
-Bitwise XOR assignment | x ^= y | x = x ^ y
-Bitwise OR assignment | x |= y | x = x | y
-
-### More Information:
-
-MDN link
-
-MSDN link
diff --git a/client/src/guide/english/javascript/booleans/index.md b/client/src/guide/english/javascript/booleans/index.md
deleted file mode 100644
index 2face334c3..0000000000
--- a/client/src/guide/english/javascript/booleans/index.md
+++ /dev/null
@@ -1,103 +0,0 @@
----
-title: Boolean
----
-
-## Boolean
-
-Booleans are a primitive datatype commonly used in computer programming languages. By definition, a boolean has two possible values: `true` or `false`.
-
-In Javascript, there is often implicit type coercion to boolean. If for example you have an if statement which checks a certain expression, that expression will be coerced to a boolean:
-
-```javascript
-var a = 'a string';
-if (a) {
- console.log(a); // logs 'a string'
-}
-```
-
-There are only a few values that will be coerced to false:
-- false (not really coerced as it already is false)
-- null
-- undefined
-- NaN
-- 0
-- '' (empty string)
-
-All other values will be coerced to true.
-When a value is coerced to a boolean, we also call that either 'falsy' or 'truthy'.
-
-One way that type coercion is used is with the use of the or (`||`) and and (`&&`) operators:
-
-```javascript
-var a = 'word';
-var b = false;
-var c = true;
-var d = 0
-var e = 1
-var f = 2
-var g = null
-
-console.log(a || b); // 'word'
-console.log(c || a); // true
-console.log(b || a); // 'word'
-console.log(e || f); // 1
-console.log(f || e); // 2
-console.log(d || g); // null
-console.log(g || d); // 0
-console.log(a && c); // true
-console.log(c && a); // 'word'
-```
-As you can see, the *or* operator checks the first operand. If this is true or truthy, it returns it immediately (which is why we get 'word' in the first case & true in the second case). If it is not true or truthy, it returns the second operand (which is why we get 'word' in the third case).
-
-With the and operator it works in a similar way, but for 'and' to be true, both operands need to be truthy. So it will always return the second operand if both are true/truthy, otherwise it will return false. That is why in the fourth case we get true and in the last case we get 'word'.
-
-## The Boolean Object
-
-There is also a native JavaScript object that wraps around a value. The value passed as the first parameter is converted to a boolean value, if necessary. If value is omitted, 0, -0, null, false, NaN, undefined, or the empty string (""), the object has an initial value of false. All other values, including any object or the string "false", create an object with an initial value of true.
-
-Do not confuse the primitive Boolean values true and false with the true and false values of the Boolean object.
-
-## More Details
-
-Any object whose value is not undefined or null, including a Boolean object whose value is false, evaluates to true when passed to a conditional statement. If true, this will execute the function. For example, the condition in the following if statement evaluates to true:
-
-```javascript
-var x = new Boolean(false);
-if (x) {
- // this code is executed
-}
-```
-
-This behavior does not apply to Boolean primitives. For example, the condition in the following if statement evaluates to false:
-
-```javascript
-var x = false;
-if (x) {
- // this code is not executed
-}
-```
-
-Do not use a Boolean object to convert a non-boolean value to a boolean value. Instead, use Boolean as a function to perform this task:
-
-```javascript
-var x = Boolean(expression); // preferred
-var x = new Boolean(expression); // don't use
-```
-
-If you specify any object, including a Boolean object whose value is false, as the initial value of a Boolean object, the new Boolean object has a value of true.
-
-```javascript
-var myFalse = new Boolean(false); // initial value of false
-var g = new Boolean(myFalse); // initial value of true
-var myString = new String('Hello'); // string object
-var s = new Boolean(myString); // initial value of true
-```
-
-Do not use a Boolean object in place of a Boolean primitive.
-
-### Resources
-
-- Boolean Object
-- Boolean Object
-
-
diff --git a/client/src/guide/english/javascript/callback-functions/index.md b/client/src/guide/english/javascript/callback-functions/index.md
deleted file mode 100644
index 52bd2cf6e0..0000000000
--- a/client/src/guide/english/javascript/callback-functions/index.md
+++ /dev/null
@@ -1,79 +0,0 @@
----
-title: Callback Functions
----
-This article gives a brief introduction to the concept and usage of callback functions in the Javascript programming language.
-
-## Functions are Objects
-
-The first thing we need to know is that in Javascript, functions are first-class objects. As such, we can work with them in the same way we work with other objects, like assigning them to variables and passing them as arguments into other functions. This is important, because it's the latter technique that allows us to extend functionality in our applications.
-
-## Callback Functions
-
-A **callback function** is a function that is passed _as an argument_ to another function, to be "called back" at a later time. A function that accepts other functions as arguments is called a **higher-order function**, which contains the logic for _when_ the callback function gets executed. It's the combination of these two that allow us to extend our functionality.
-
-To illustrate callbacks, let's start with a simple example:
-
-```javascript
-function createQuote(quote, callback){
- var myQuote = "Like I always say, " + quote;
- callback(myQuote); // 2
-}
-
-function logQuote(quote){
- console.log(quote);
-}
-
-createQuote("eat your vegetables!", logQuote); // 1
-
-// Result in console:
-// Like I always say, eat your vegetables!
-```
-
-In the above example, `createQuote` is the higher-order function, which accepts two arguments, the second one being the callback. The `logQuote` function is being used to pass in as our callback function. When we execute the `createQuote` function _(1)_, notice that we are _not appending_ parentheses to `logQuote` when we pass it in as an argument. This is because we do not want to execute our callback function right away, we simply want to pass the function definition along to the higher-order function so that it can be executed later.
-
-Also, we need to ensure that if the callback function we pass in expects arguments, that we supply those arguments when executing the callback _(2)_. In the above example, that would be the `callback(myQuote);` statement, since we know that `logQuote` expects a quote to be passed in.
-
-Additionally, we can pass in anonymous functions as callbacks. The below call to `createQuote` would have the same result as the above example:
-
-```javascript
-createQuote("eat your vegetables!", function(quote){
- console.log(quote);
-});
-```
-
-Incidentally, you don't _have_ to use the word "callback" as the name of your argument, Javascript just needs to know that it's the correct argument name. Based on the above example, the below function will behave in exactly the same manner.
-
-```javascript
-function createQuote(quote, functionToCall) {
- var myQuote = "Like I always say, " + quote;
- functionToCall(myQuote);
-}
-```
-
-## Why use Callbacks?
-
-Most of the time we are creating programs and applications that operate in a **synchronous** manner. In other words, some of our operations are started only after the preceding ones have completed. Often when we request data from other sources, such as an external API, we don't always know _when_ our data will be served back. In these instances we want to wait for the response, but we don't always want our entire application grinding to a halt while our data is being fetched. These situations are where callback functions come in handy.
-
-Let's take a look at an example that simulates a request to a server:
-
-```javascript
-function serverRequest(query, callback){
- setTimeout(function(){
- var response = query + "full!";
- callback(response);
- },5000);
-}
-
-function getResults(results){
- console.log("Response from the server: " + results);
-}
-
-serverRequest("The glass is half ", getResults);
-
-// Result in console after 5 second delay:
-// Response from the server: The glass is half full!
-```
-
-In the above example, we make a mock request to a server. After 5 seconds elapse the response is modified and then our callback function `getResults` gets executed. To see this in action, you can copy/paste the above code into your browser's developer tool and execute it.
-
-Also, if you are already familiar with `setTimeout`, then you've been using callback functions all along. The anonymous function argument passed into the above example's `setTimeout` function call is also a callback! So the example's original callback is actually executed by another callback. Be careful not to nest too many callbacks if you can help it, as this can lead to something called "callback hell"! As the name implies, it isn't a joy to deal with.
diff --git a/client/src/guide/english/javascript/comparison-operators/index.md b/client/src/guide/english/javascript/comparison-operators/index.md
deleted file mode 100644
index 07471598a0..0000000000
--- a/client/src/guide/english/javascript/comparison-operators/index.md
+++ /dev/null
@@ -1,186 +0,0 @@
----
-title: Comparison Operators
----
-JavaScript has both **strict** and **type–converting** comparisons.
-
-* A strict comparison (e.g. ===) is only true if the operands are of the same type.
-
-* The more commonly used abstract comparison (e.g. ==) converts the operands to the same Type before making the comparison.
-
-* For relational abstract comparisons (e.g., <=), the operands are first converted to primitives, then to the same type, before comparison.
-
-* Strings are compared based on standard lexicographical ordering, using Unicode values.
-
-## Features of comparisons:
-
-* Two strings are strictly equal when they have the same sequence of characters, same length, and same characters in corresponding positions.
-
-* Two numbers are strictly equal when they are numerically equal (have the same number value). NaN is not equal to anything, including NaN. Positive and negative zeros are equal to one another.
-
-* Two Boolean operands are strictly equal if both are true or both are false.
-
-* Two distinct objects are never equal for either strict or abstract comparisons.
-
-* An expression comparing Objects is only true if the operands reference the same Object.
-
-* Null and Undefined Types are strictly equal to themselves and abstractly equal to each other.
-
-## Equality operators
-
-### Equality (==)
-
-The equality operator converts the operands if they are **not of the same type**, then applies strict comparison. If **both operands are objects**, then JavaScript compares internal references which are equal when operands refer to the same object in memory.
-
-#### Syntax
-
- x == y
-
-#### Examples
-
- 1 == 1 // true
- "1" == 1 // true
- 1 == '1' // true
- 0 == false // true
- 0 == null // false
-
- 0 == undefined // false
- null == undefined // true
-
-### Inequality (!=)
-
-The inequality operator returns true if the operands are not equal. If the two operands are **not of the same type**, JavaScript attempts to convert the operands to an appropriate type for the comparison. If **both operands are objects**, then JavaScript compares internal references which are not equal when operands refer to different objects in memory.
-
-#### Syntax
-
- x != y
-
-#### Examples
-
- 1 != 2 // true
- 1 != "1" // false
- 1 != '1' // false
- 1 != true // false
- 0 != false // false
-
-### Identity / strict equality (===)
-
-The identity operator returns true if the operands are strictly equal **with no type conversion**.
-
-#### Syntax
-
- x === y
-
-#### Examples
-
- 3 === 3 // true
- 3 === '3' // false
-
-### Non-identity / strict inequality (!==)
-
-The non-identity operator returns true if the operands **are not equal and/or not of the same type**.
-
-#### Syntax
-
- x !== y
-
-#### Examples
-
- 3 !== '3' // true
- 4 !== 3 // true
-
-## Relational operators
-
-### Greater than operator (>)
-
-The greater than operator returns true if the left operand is greater than the right operand.
-
-#### Syntax
-
- x > y
-
-#### Examples
-
- 4 > 3 // true
-
-### Greater than or equal operator (>=)
-
-The greater than or equal operator returns true if the left operand is greater than or equal to the right operand.
-
-#### Syntax
-
- x >= y
-
-#### Examples
-
- 4 >= 3 // true
- 3 >= 3 // true
-
-### Less than operator (<)
-
-The less than operator returns true if the left operand is less than the right operand.
-
-#### Syntax
-
- x < y
-
-#### Examples
-
- 3 < 4 // true
-
-### Less than or equal operator (<=)
-
-The less than or equal operator returns true if the left operand is less than or equal to the right operand.
-
-#### Syntax
-
- x <= y
-
-#### Examples
-
- 3 <= 4 // true
-
-_You can find more information at MDN ._
-
-
-## Comparing null and undefined
-
-When we compare null and undefined we see different behaviour. Lets check different scenario through examples
-#### Example - strict equality check (===)
-
-console.log( null === undefined ); // O/P - false
-
-Otuput is false and that's correct because we know "null" and "undefined" are different types.
-
-#### Example - non-strict equality check (==)
-
-console.log( null == undefined ); // O/P: - true
-
-How? This is because there is a special rule for "null" and "undefined". Due to which they are equal in case of non-strict check (==) but are not equal to any other value.
-
-If we use comparison operators like <, >, <=, >= etc., "null" and "undefined" are converted to number and in such cases "null" will become 0 and "undefined" will be NaN. Lets check some of those examples.
-
-#### Example - compare null with 0(zero)
-
-console.log( null > 0 ); // O/P - false
-console.log( null >= 0 ); // O/P - true
-console.log( null == 0 ); // O/P - false
-
-Strange? As per the first statement null is not greater than 0 and from the second statement null is either greater than or equal to 0. So, if we think mathematically and compare both statements, will come to the result that null is equal to 0. But, as per third statement it's not true. Why?
-
-The reason is "comparison" and "equality check" both works in different way.
-In comparison, "null/undefined" is first converted to number so, in first two cases "null" become 0 and hence case1) (null > 0) -> false and case2) (null >= 0) -> true.
-But, in equality check (==), "null/undefined" works without any conversion and as explained above (special rule), in equality check "null/undefined" are only equal to each other and are not equal to anything else. Hence (null == 0) -> false.
-
-#### Example - compare undefined with 0(zero)
-
-console.log( undefined > 0 ); // O/P - false
-console.log( undefined >= 0 ); // O/P - false
-console.log( undefined == 0 ); // O/P - false
-
-Here, we test the same cases as we did for null but again result is different. Why?
-
-The reasons are as follow.
-In first two cases, we are comparing undefined with 0 and as mentioned above in comparison undefined gets converted to NaN. NaN is a special value which always return false when compared with any number and that's why we got false as output in first two cases.
-For third statement, reason is same as mentioned for "null". In equality check "null/undefined" are only equal to each other and not equal to anything else. Hence (undefined == 0) -> false.
-
-
diff --git a/client/src/guide/english/javascript/es6/arrow-functions/index.md b/client/src/guide/english/javascript/es6/arrow-functions/index.md
deleted file mode 100644
index 0132ee6f95..0000000000
--- a/client/src/guide/english/javascript/es6/arrow-functions/index.md
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: Arrow Functions
----
-
-## Arrow functions
-
-Functions in ES6 have changed a bit. I mean the syntax.
-
-```javascript
-// Old Syntax
-function oldOne() {
- console.log("Hello World..!");
-}
-
-// New Syntax
-var newOne = () => {
- console.log("Hello World..!");
-}
-```
-
-The new syntax may be confusing a little bit. But I will try to explain the syntax.
-There are two parts of the syntax.
-
-1. var newOne = ()
-2. => {}
-
-The first part is just declaring a variable and assigning the function (i.e) () to it. It just says the variable is actually a function.
-
-Then the second part is declaring the body part of the function. The arrow part with the curly braces defines the body part.
-
-Another example with parameters:
-
-```javascript
-let NewOneWithParameters = (a, b) => {
- console.log(a+b); // 30
-}
-NewOneWithParameters(10, 20);
-```
-
-Parentheses are optional when there's only one parameter name:
-
-```javascript
-let newOneWithOneParam = a => {
- console.log(a);
-}
-```
-
-### advantages of arrow sytnax
-1. It will always be called with the context in which it was defined. Therefore there is no existence of the this keyword.
-
-```javascript
- // Old Syntax
- axios.get(url).then(function(response) {
- this.data = response.data;
- }).bind(this);
-
- // New Syntax
- axios.get(url).then(response => {
- this.data = response.data;
- });
- ```
- * before arrow functions each function had it's own this contect
-2. shorter more readable functions
-```javascript
- // Old Syntax
- const sumValues = function (a, b) {
- return a+b;
- }
-
- // New Syntax
- const sumValues = (a,b) => a+b;
-```
- * since it's a one line return we can ommit the brackets
-
-
diff --git a/client/src/guide/english/javascript/es6/default-parameters/index.md b/client/src/guide/english/javascript/es6/default-parameters/index.md
deleted file mode 100644
index da482fed8d..0000000000
--- a/client/src/guide/english/javascript/es6/default-parameters/index.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: Default Parameters
----
-
-## Default Parameters
-
-If you are familiar with other programming languages like Ruby, Python then default parameters isn’t new to you.
-
-Default parameters are parameters which are given by default while declaring a function. But it’s value can be changed when calling the function.
-
-Example
-
-```
-let Func = (a, b = 10) => {
- return a + b;
-}
-Func(20); // 20 + 10 = 30
-```
-
-In the above example, we are passing only one parameter. The function makes use of the default parameter and executes the function.
-
-Consider another example:
-
-```
-Func(20, 50); // 20 + 50 = 70
-```
-
-In the above example, the function takes two parameters and the second parameter replaces the default parameter.
-
-Consider another example:
-
-```
-let NotWorkingFunction = (a = 10, b) => {
- return a + b;
-}
-NotWorkingFunction(20); // NAN. Not gonna work.
-```
-
-When you are calling the function with parameters they get assigned in the order. (i.e) the first value gets assigned to the first parameter and the second value gets assign to the second parameter and so on..
-
-In the above example, the value 20 gets assigned to parameter ‘a’ and ‘b’ is not having any value. So we are not getting any output.
-
-But,
-
-```
-NotWorkingFunction(20, 30); // 50;
-```
-
-Works fine.
diff --git a/client/src/guide/english/javascript/es6/destructuring/index.md b/client/src/guide/english/javascript/es6/destructuring/index.md
deleted file mode 100644
index 304b17e7f3..0000000000
--- a/client/src/guide/english/javascript/es6/destructuring/index.md
+++ /dev/null
@@ -1,65 +0,0 @@
----
-title: Destructuring Assignment
----
-
-## Destructuring Assignment
-
-Destructuring Assignment syntax is a Javascript expression that makes it possible to unpack values or properties from arrays or objects.
-
-Lets say that you have an array that contains a first name and last name as it's two values, but you want to reassign those values to something more descriptive. You can use Destructuring to accomplish this.
-
-**ES5 Destructuring**
-
-```js
-var fullName = ["John", "Smith"];
-var firstName = fullName[0];
-var lastName = fullName[1];
-
-console.log(firstName, lastName); // John Smith
-
-```
-
-**ES6 Destructuring**
-
-
-```js
-const fullName = ["John", "Smith"];
-const [firstName, lastName] = fullName;
-
-console.log(firstName, lastName); // John Smith
-
-```
-
-The examples above show the benefit of using the ES6 Destructuring Assignment.
-
-You can also use Destructuring on objects using a similar syntax
-
-```js
-const fullName = { first: "John", last: "Smith"};
-const {first, last} = fullName;
-
-console.log(first, last); // John Smith
-```
-
-Object Destructuring Assignment is a little bit different because the object must have properties with the names you are assigning. Therefore the code below would not work as intended.
-
-```js
-const fullName = { first: "John", last: "Smith"};
-const {firstName, lastName} = fullName;
-
-console.log(firstName, lastName); // undefined undefined
-```
-
-You can still achieve the desired result using the following syntax.
-```js
-const obj = {propertyName: value}
-{propertyName: desiredVariableName} = obj
-```
-
-Our previous example would be rewritten as follows:
-```js
-const fullName = { first: "John", last: "Smith"};
-const {first: firstName, last: lastName} = fullName;
-
-console.log(firstName, lastName); // John Smith
-```
diff --git a/client/src/guide/english/javascript/es6/spread-operator/index.md b/client/src/guide/english/javascript/es6/spread-operator/index.md
deleted file mode 100644
index b29b924c80..0000000000
--- a/client/src/guide/english/javascript/es6/spread-operator/index.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: Spread Operator
----
-## Spread Operator
-
-The spread operator (`...`), allows to get the elements of a collection.
-
-One of the most commom uses is for `Node` Objects, when using query selectors in the browser, in order to make them iterable Array Objects:
-```javascript
-const paragraphs = document.querySelectorAll('p.paragraph');
-const arr = [...paragraphs];
-```
-
-Another use of the spread operator is for Array concatenation:
-```javascript
-const arr_1 = [1, 2, 3, 4]
-const arr_2 = [5, 6, 7, 8]
-const arr_final = [...arr_1, ...arr_2]
-// arr_final = [1, 2, 3, 4, 5, 6, 7, 8]
-```
\ No newline at end of file
diff --git a/client/src/guide/english/javascript/event-handling/index.md b/client/src/guide/english/javascript/event-handling/index.md
deleted file mode 100644
index 6a7fe07359..0000000000
--- a/client/src/guide/english/javascript/event-handling/index.md
+++ /dev/null
@@ -1,163 +0,0 @@
----
-title: Event Handling
----
-
-## Event Handling
-
-Events are (in the context of JavaScript) actions or incidents which happen inside the browser window, such as
-
-* the user clicks on something or hovers over it
-* the user presses a key
-* the user drags and drops something
-* the user submits a form
-* content finishes loading
-* a video starts or stops playing
-* an error occurrs
-
-and many more.
-
-When an event happens it sends a signal which your code can react to.
-
-Events usually occur on a specific item in the browser window, such as an element, a group of elements, the HTML document in your current tab, or the browser window itself.
-
-You can use JavaScript to attach an event handler (also called an event listener) to these items to "listen" for a particular event and run some code when the event happens.
-
-Inside the event handler, you specify two things: the type of event you are listening for, and the code you want to run when the event occurs.
-
-```html
-Click Me!
-```
-
-```js
-const button = document.querySelector("button");
-
-button.addEventListener("click", () => console.log("Clicked!"));
-```
-
-Here you are listening for a click on the button, and when it happens you are logging "Clicked!" to the browser console.
-
-### Avoid inline event handlers
-
-The earliest way of handling events was inline event handlers where you write your JavaScript as the element's attribute value.
-
-```html
-**truthy** | Blog Post - Truthy & Falsey
-
-- [ Falsy | Glossary | MDN](https://developer.mozilla.org/en-US/docs/Glossary/Falsy)
-
-- [Truthy and Falsy: When All is Not Equal in JavaScript](https://www.sitepoint.com/javascript-truthy-falsy/)
diff --git a/client/src/guide/english/javascript/higher-order-functions/index.md b/client/src/guide/english/javascript/higher-order-functions/index.md
deleted file mode 100644
index 5246f0b6ce..0000000000
--- a/client/src/guide/english/javascript/higher-order-functions/index.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: Higher Order Functions
----
-## Higher Order Functions
-
-A Higher Order Function is any function that returns a function when executed, takes a function as one or more of its arguments, or both. If you have used any of the `Array` methods like `map` or `filter`, or passed a callback function to jQuery's `$.get`, you have already worked with Higher Order Functions.
-
-When you use `Array.map`, you provide a function as its only argument, which it applies to every element contained in the array.
-
-```javascript
-var arr = [ 1, 2, 3 ];
-
-var arrDoubled = arr.map(function(num) {
- return num * 2;
-});
-
-console.log(arrDoubled); // [ 2, 4, 6 ]
-```
-
-Higher order functions can also return a function. For example, you can make a function called `multiplyBy` that takes a number and returns a function that multiplies another number you provide by the first number provided. You can use this approach to create a `multiplyByTwo` function to pass to `Array.map`. This will give you the same result you saw above.
-
-```javascript
-function multiplyBy(num1) {
- return function(num2) {
- return num1 * num2;
- }
-}
-
-var multiplyByTwo = multiplyBy(2);
-
-var arr = [ 1, 2, 3 ];
-
-var arrDoubled = arr.map(multiplyByTwo);
-
-console.log(arrDoubled); // [ 2, 4, 6 ]
-```
-
-See the guide on Closures for more information on how `multiplyByTwo` keeps a reference to `num1` in the example above.
-
-More info about Closures
diff --git a/client/src/guide/english/javascript/popup-boxes/index.md b/client/src/guide/english/javascript/popup-boxes/index.md
deleted file mode 100644
index 0edb05c75f..0000000000
--- a/client/src/guide/english/javascript/popup-boxes/index.md
+++ /dev/null
@@ -1,63 +0,0 @@
----
-title: Popup Boxes
----
-## Popup Boxes
-Popup boxes (or dialog boxes) are modal windows used to notify or warn the user, or to get input from the user.
-
-Popup boxes prevent the user from accessing other aspects of a program until the popup is closed, so they should not be overused.
-
-There are three different kinds of popup methods used in JavaScript: window.alert() , window.confirm() and window.prompt() .
-
-### Alert
-The alert method displays messages that don't require the user to enter a response. Once this function is called, an alert dialog box will appear with the specified (optional) message. Users will be required to confirm the message before the alert goes away.
-
-### Example:
-`window.alert("Welcome to our website");`
-
-
-
-### Confirm
-The confirm method is similar to `window.alert()`, but also displays a cancel button in the popup. The buttons return boolean values: true for OK and false for Cancel.
-
-### Example:
-```javascript
-var result = window.confirm('Are you sure?');
-if (result === true) {
- window.alert('Okay, if you're sure.');
-} else {
- window.alert('You seem uncertain.');
-}
-```
-
-
-
-### Prompt
-The prompt method is typically used to get text input from the user. This function can take two arguments, both of which are optional: a message to display to the user and a default value to display in the text field.
-
-### Example:
-`var age = prompt('How old are you?', '100');`
-
-
-
-### Other Design Options:
-If you are unhappy with the default JavaScript popups, you can substitute in various UI libraries. For example, SweetAlert provides a nice replacement for standard JavaScript modals. You can include it in your HTML via a CDN (content delivery network) and begin use.
-```HTML
-
-```
-The syntax is as such: ```swal(title, subtitle, messageType)```
-
-```javascript
-swal("Oops!", "Something went wrong on the page!", "error");
-```
-The above code will produce the following popup:
-
-SweetAlert is by no means the only subsitute for standard modals, but it is clean and easy to implement.
-
-
-
-
-#### More Information:
-
-* MDN window.alert()
-* MDN window.confirm()
-* MDN window.prompt()
diff --git a/client/src/guide/english/javascript/singleton-in-javscript/index.md b/client/src/guide/english/javascript/singleton-in-javscript/index.md
deleted file mode 100644
index f43b6b2813..0000000000
--- a/client/src/guide/english/javascript/singleton-in-javscript/index.md
+++ /dev/null
@@ -1,60 +0,0 @@
----
-title: Creating Singleton In JavaScript
----
-
-## Creating Singleton In Javascript Guide
-
-This Article is about creating the Singletons in Native(Pure) Javascript. This concept can be useful to maintain clean code.
-
-
-If you want to maintain your code or somedata should remain same for through out your application this is the way you can get it done.
-
-
-**Prior knowledge**
-This is just to help you understand concept more easily otherwise you can always copy-paste code and change it accordingly.
-
-- Basic Javascript Syntax
-- Javascript Functions
-- IIFE in Javascript
-
-
-
-### Let's Get Started
-
-Let's create object with IIFE function that will get executed instantly to give us effect of Singleton.
-
-```
-var singletonFn = (function(){ //Created IIFE Function
- var dataCounter = 0;
- return { //Any code inside this return stuff will be accessible directly using objectname.
-
- getDataCounter: function(){
- return dataCounter;
- },
-
- setDataCounter: function(val){
- dataCounter = val;
- },
-
- fishNames: ["SimpleFish"] //Can create variables, Arrays, etc.
- }
-})();
-```
-
-Now to execute or use your singleton. in browser after saving this to js file and loading it.
-
-```
-console.log(singletonFn.getDataCounter()); //0 as bydefault it will be 0.
-
-singletonFn.setDataCounter(20);
-
-console.log(singletonFn.getDataCounter()); //20 as we assigned.
-
-console.log(fishNames); //will Print array with "SimpleFish".
-```
-
-
-Now with this knowledge you can define constants, enums or anything that needs to use multiple in project written here. or something like configurations.
-
-
-Hope, This will help you write better codes. Happy Coding :)
diff --git a/client/src/guide/english/javascript/truth-table/index.md b/client/src/guide/english/javascript/truth-table/index.md
deleted file mode 100644
index 95e9984bac..0000000000
--- a/client/src/guide/english/javascript/truth-table/index.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: Truth Table
----
-
-
-This is why you should always use `===` and `!==`.
-
-Source: https://dorey.github.io/JavaScript-Equality-Table/
diff --git a/client/src/guide/english/javascript/truthy-values/index.md b/client/src/guide/english/javascript/truthy-values/index.md
deleted file mode 100644
index eb4dd14c91..0000000000
--- a/client/src/guide/english/javascript/truthy-values/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Truthy Value
----
-A **truthy** value is a value that translates to **true** when evaluated in a _Boolean_ context.
-
-All values are **truthy** unless they are defined as **falsy** (i.e. except for `false`, `0`, `""`, `null`, `undefined` and `NaN`).
-
-Some interesting **truthy** values are:
-
-'0' (a string containing a single zero)
-'false' (a string containing the text “false”)
-[] (an empty array)
-{} (an empty object)
-function(){} (an “empty” function)
-
-A single value can therefore be used within conditions, e.g.
-
-if (value) {
- // value is truthy
-}
-else {
- // value is falsy
- // it could be false, 0, '', null, undefined or NaN
-}
-
-See also: falsy | MDN
diff --git a/client/src/guide/english/jquery/jquery-hover-method/index.md b/client/src/guide/english/jquery/jquery-hover-method/index.md
deleted file mode 100644
index 83ae9877fd..0000000000
--- a/client/src/guide/english/jquery/jquery-hover-method/index.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: jQuery Hover Method
----
-
-# jQuery Hover Method
-The jquery hover method is a combination of the ```mouseenter``` and ```mouseleave``` events.
-The syntax is this:
-```
-$(selector).hover(inFunction, outFunction);
-```
-The first function, inFunction, will run when the ```mouseenter``` event occurs.
-The second function is optional, but will run when the ```mouseleave``` event occurs.
-If only one function is specified, the other function will run for both the ```mouseenter``` and ```mouseleave``` events.
-
-### More Information
-More information can be found [here].
-
-[here]: https://www.w3schools.com/jquery/event_hover.asp
diff --git a/client/src/guide/english/kotlin/hello-world/index.md b/client/src/guide/english/kotlin/hello-world/index.md
deleted file mode 100644
index 7c3c2d93e1..0000000000
--- a/client/src/guide/english/kotlin/hello-world/index.md
+++ /dev/null
@@ -1,66 +0,0 @@
----
-title: Hello World in Kotlin
----
-
-A Hello World program is a very simple program that outputs the string "Hello World!". It is often used to show the basic syntax of a programming language.
-
-In this tutorial we are going to analyse the syntax of a Hello World program written in Kotlin.
-
-If you still haven't installed Kotlin you should check this tutorial: https://guide.freecodecamp.org/kotlin
-
-## Hello World Program
-
-```kotlin
-// This is a simple Hello World program written in Kotlin
-
-fun main(args : Array) {
- println("Hello, World!")
-}
-```
-
-As you should expect, when you run this program the output should be "Hello, World!".
-
-## Syntax
-
-### Comments
-
-```
-// This is a simple Hello World program written in Kotlin
-```
-
-Comments are text written by a developer that are added with the purpose of making the code easier to understand by other developers.
-In Kotlin comments can be single-line comments (using //) or multi-line comments (using /**/).
-
-```
-// Single line comment
-
-/* This is a
-Multi-line comment
-*/
-```
-
-### Main function
-
-```kotlin
-fun main(args : Array) {...}
-```
-
-The main function is a mandatory function that tells the compiler where it should start executing our code. It takes an array of strings as parameter and returns the type Unit which corresponds to the type ```void``` in languages like Java.
-As we can see, functions are declared with the use of the keyword ```fun``` and its body should be written inside curly braces.
-
-Functions without a explicitly declared return type will return the type ```Unit```, therefore, the above code is equivalent to
-
-```kotlin
-fun main(args : Array): Unit {...}
-```
-
-
-### Print Statement
-
-The println function takes a string as an argument and prints it to the screen. In this case we are printing the string "Hello, World!". Note that string literals are declared using double quotes ```"String"```.
-
-
-If you'd like to know more about Kotlin Syntax and start writing awesome programs you should check the awesome Kotlin Official Documentation: https://kotlinlang.org/docs/reference/
-
-Hope you liked this tutorial,
-Cheers
diff --git a/client/src/guide/english/laravel/index.md b/client/src/guide/english/laravel/index.md
deleted file mode 100644
index e5e65eec9d..0000000000
--- a/client/src/guide/english/laravel/index.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: Laravel
----
-# Laravel
-
-Laravel is a free and open-source PHP web framework available on [GitHub](https://github.com/laravel/laravel) and licensed under the terms of MIT License. It was created by Taylor Otwell who designed it with the objetive of enabling the development of web applications following the model–view–controller (MVC) architectural pattern and it is now the most starred PHP framework on GitHub. Some of the main features found in Laravel are different ways for accessing relational databases, utilities that aid in application deployment and maintenance and at last but not least modular packaging system with a dedicated dependency manager.
-
-Because Laravel is open-source the community around it is very strong and so is the documentation where you can learn how to do almost everything, try taking a look at the [Laravel Documentation](https://laravel.com/docs/5.7/) to get a glimpse of the open source power!
diff --git a/client/src/guide/english/linux/10-simple-and-useful-linux-commands/index.md b/client/src/guide/english/linux/10-simple-and-useful-linux-commands/index.md
deleted file mode 100644
index 3d06b77be8..0000000000
--- a/client/src/guide/english/linux/10-simple-and-useful-linux-commands/index.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-title: 10 Simple and Useful Linux Commands
----
-# 10 Simple and Useful Linux Commands
-The commands listed here are basic, and will help you get started quickly. But they’re also powerful, and they’ll continue to be useful as your Linux expertise expands.
-1. `echo` This takes the text you give it and sends it somewhere—to back to the screen, to a file, or to another command. Example: `echo "hello!"`
-1. `cat` To display the contents of a text file, just type `cat myfile`.
-1. `find` It does what it says, and it’s good at it. Use it to locate files by path, size, date, owner and a bunch of other useful filters. Example: `find . -type f -mtime -1h # List files in this directory modified in the past hour`.
-1. `date` Just type date when you want to know what time it is. Example: `date "+It's %l:%m%p on %A"`. Use it in a script to name files according to the current date.
-1. `ls` What's in this directory? Combine `ls` with some useful flags to display and sort directory contents by date and size. It also gives you lots of options for formatting the output.
-1. `pwd` Where am I? Linux can be unforgiving, particularly when you delete something. Make sure you know are before you issue your commands.
-1. `mail` Linux's mail program isn’t good looking, but it can be really helpful. You can create a message and add text, recipients, and attachments all in one command. Example: `echo "We're having a great time." | mail -s "Wish you were here!" -A postcard.png -t mom@example.com`
-1. `cut` When you have a string with separators in it, use `cut` to filter out certain fields. Example: `echo "this, that, and the other" | cut -d, -f2 # "that"`
-1. `grep` To find lines of text that contain a certain string, use grep. Example: `grep 'root' /etc/passwd # root:x:0:0:root:/root:/bin/bash`
-1. `sed` Use sed to find and change a substring in a piece of text. Example: `echo "this, that, and the other" | sed 's/that/those/' # "this, those, and the other"`
-1. `shutdown` use shut down the system and turn off the power. Example: `shutdown -h now`shuts down system immediately. `shutdown -h +5` shuts down system after five minutes.
-
-Use these commands in scripts and at the command line. They're all very powerful commands, and Linux's man page has a lot more information about each one.
-
-***********
-
-Also, important commands used for System Administrators are following:
-
-1. `uptime` Command
-In Linux uptime command shows since how long your system is running and the number of users are currently logged in and also displays load average for 1,5 and 15 minutes intervals.
-
-2. `w` Command
-It will displays users currently logged in and their process along-with shows load averages. also shows the login name, tty name, remote host, login time, idle time, JCPU, PCPU, command and processes.
-
-3. `users` Command
-Users command displays currently logged in users. This command don’t have other parameters other than help and version.
-
-4. `who` Command
-who command simply return user name, date, time and host information. who command is similar to w command. Unlike w command who doesn’t print what users are doing. Lets illustrate and see the different between who and w commands.
-
-5. `whoami` Command
-whoami command print the name of current user. You can also use “who am i” command to display the current user. If you are logged in as a root using sudo command “whoami” command return root as current user. Use “who am i” command if you want to know the exact user logged in.
-
-6. `ls` Command
-ls command display list of files in human readable format.
-
-7. `crontab` Command
-List schedule jobs for current user with crontab command and -l option.
-
-8. `less` Command
-less command allows quickly view file. You can page up and down. Press ‘q‘ to quit from less window.
-
-9. `more` Command
-more command allows quickly view file and shows details in percentage. You can page up and down. Press ‘q‘ to quit out from more window.
-
-10. `cp` Command
-Copy file from source to destination preserving same mode.
-
-Here are the list of commands frequently used by adiminstrator.
-This is not a complete but it’s a compact list of commands to refer when needed.
diff --git a/client/src/guide/english/linux/basic-linux-commands/index.md b/client/src/guide/english/linux/basic-linux-commands/index.md
deleted file mode 100644
index 67bb8ea789..0000000000
--- a/client/src/guide/english/linux/basic-linux-commands/index.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: Basic Linux Commands
----
-## Basic Linux Commands
-
-When starting out with linux, there are some basic commands everyone should know.
-
- 1. **cd** - change directory
-- cd followed by a directory or file path will take you inside that directory(folder).
-
- 2. **ls** - list command
-- Type `ls` and the contents of the current directory will be displayed.
-
- 3. **man** - manual command
-- Shows you the manual for the following command. This is very helpful when trying to figure out how an unfamiliar command works. For example, type `man ls` for everything you need to know about the ls command. Type `q` to exit.
-
- 4. **pwd** - path
-- Type `pwd` to display the path to your current directory.
-
- 5. **mkdir** - make directory
-- This command, followed by the name you wish to name your directory, creates a new directory. `mkdir folder1` will make a new directory called folder1.
-
- 6. **rmdir** - remove directory
-- Removes the directory that follows the command. `rmdir folder1` will delete the directory named folder1 if it exists.
-
- 7. **rm** - remove
-- This command removes files, not directories. `rm file.txt` will remove the file named file.txt as long as it exists and is in the current directory.
-
- 8. **touch** - creates file
-- The touch command is used to create a file. It can be anything, from an empty txt file to an empty zip file. 'touch new.txt' will create a new file with name new.
-
- 9. **mv** - move
-- Use the mv command to move files through the command line. We can also use the mv command to rename a file. For example, if we want to rename the file “text” to “new”, we can use 'mv text new'.
-
- 10. **right-click** - copy and paste
-- This one is less of a command and more of a how-to, however, it is very useful for doing almost anything in a terminal on linux. To begin, highlight text like normal and then "right-click" on your mouse to copy a selection. You should see the highlighted portion become un-highlighted, this means you copied the selection. Now "right-click" on where you want to paste the selection and you're done.
-
- 11. **less** - view file content
-- Use `less filename.txt` to view contents of a file and navigate through them. By default, less will go through the file page by page.
diff --git a/client/src/guide/english/linux/index.md b/client/src/guide/english/linux/index.md
deleted file mode 100644
index e5be1e927a..0000000000
--- a/client/src/guide/english/linux/index.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: Linux
----
-
-Online linear regression simulator
-
-In Python:
-```py
-#Price of wheat/kg and the average price of bread
-wheat_and_bread = [[0.5,5],[0.6,5.5],[0.8,6],[1.1,6.8],[1.4,7]]
-
-def step_gradient(b_current, m_current, points, learningRate):
- b_gradient = 0
- m_gradient = 0
- N = float(len(points))
- for i in range(0, len(points)):
- x = points[i][0]
- y = points[i][1]
- b_gradient += -(2/N) * (y - ((m_current * x) + b_current))
- m_gradient += -(2/N) * x * (y - ((m_current * x) + b_current))
- new_b = b_current - (learningRate * b_gradient)
- new_m = m_current - (learningRate * m_gradient)
- return [new_b, new_m]
-
-def gradient_descent_runner(points, starting_b, starting_m, learning_rate, num_iterations):
- b = starting_b
- m = starting_m
- for i in range(num_iterations):
- b, m = step_gradient(b, m, points, learning_rate)
- return [b, m]
-
-gradient_descent_runner(wheat_and_bread, 1, 1, 0.01, 100)
-```
-
-Code example is from this article . It also explains gradient descent and other essential concepts for deep learning.
-
-It is important to note that not all linear regression is done with gradient descent. The normal equation can also be used for finding the linear regression coefficients, however, this uses matrix multiplication, and therefore can be very time consuming to use for more than 100,000 or 1,000,000 instances.
-
-In Python:
-Apply directly by using scikit library, thus making linear regression easy to use even on large datasets.
-```py
-import pandas as pd
-from sklearn.cross_validation import train_test_split
-from sklearn.linear_model import LinearRegression as lr
-train = pd.read_csv('../input/train.csv')
-test = pd.read_csv('../input/test.csv')
-X = train.iloc[:, 0:4].values
-y = train.iloc[:, 4].values
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)
-X_train
-model = lr()
-model.fit(X_train, y_train)
-print(model.score(X_train,y_train))
-y_pred_class = model.predict(X_test)
-model.score(X_train,y_train)
-print(model.coef_)
-print(model.intercept_)
-# calculate accuracy
-from sklearn import metrics
-print(metrics.accuracy_score(y_test, y_pred_class))
-```
diff --git a/client/src/guide/english/machine-learning/reinforcement-learning/index.md b/client/src/guide/english/machine-learning/reinforcement-learning/index.md
deleted file mode 100644
index acdb54e897..0000000000
--- a/client/src/guide/english/machine-learning/reinforcement-learning/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Reinforcement Learning
----
-#### Suggested Reading:
-
-
-- http://incompleteideas.net/sutton/book/the-book-2nd.html
-
-#### Reinforcement Learning
-
-
-Reinforcement Learning refers to a field of Machine Learning that applies to agents that you reinforce by giving them reward and punishment. It gives a nice gradual learning and can simplify the learning of agent in tasks where you cannot determine a proper error value.
-
-Example:
-A bot is given a task to play Space Invaders, it tries to learn to play it by interacting with game and in return getting a reward for the points that it scored at end of the game. Greater the reward, greater are its chances of doing the similar gameplay. In that way, it learns how to play the game and perform in the best possible way.
-
-In industries robot uses deep reinforcement learning to pick a device from one box and putting it in a container. Whether it succeeds or fails, it memorizes the object and gains knowledge and train’s itself to do this job with great speed and precision. Learning on its own is a kind of reinforcement learning provided the learning is in positive dimension.
-
-## List of Common Algorithms
-Q-Learning
-Temporal Difference (TD)
-Deep Adversarial Networks
-
-## Use cases:
-Some applications of the reinforcement learning algorithms are computer played board games (Chess, Go), robotic hands, and self-driving cars.
-
diff --git a/client/src/guide/english/mathematics/3-by-3-determinants/index.md b/client/src/guide/english/mathematics/3-by-3-determinants/index.md
deleted file mode 100644
index 4538cf38a6..0000000000
--- a/client/src/guide/english/mathematics/3-by-3-determinants/index.md
+++ /dev/null
@@ -1,63 +0,0 @@
----
-title: 3 by 3 Determinants
----
-## 3 by 3 Determinants
-
-Consider the following matrix, which we will call A:
-
-
-
- a
- b
- c
-
-
- d
- e
- f
-
-
- g
- h
- i
-
-
-
-Then the determinant of this matrix, denoted det(A) , is given by:
-
-det(A) = a * (e * i - h * f) - b * (d * i - f * g) + c * (d * h - e * g)
-
-Please keep in mind the order of operations in the expression above.
-
-For example, consider the following matrix, which we will call B:
-
-
-
- 1
- 2
- 3
-
-
- 0
- -3
- 5
-
-
- -10
- 4
- 7
-
-
-
-det(B) is given by the formula above. We apply the formula below:
-
-det(B) = 1 * ( (-3) * 7 - 5 * 4) - 2 * ( 0 * 7 - 5 * (-10)) + 3 * (0 * 4 - (-3) * (-10)) , which we simplify to:
-
-det(B) = 1 * ((-21) - 20) - 2 * (0 - (-50)) + 3 * (0 - (30)) , which we simplify to:
-
-det(B) = (-41) - 100 - 90 = -231
-
-#### More information:
- * [Determinant of a Matrix](https://www.mathsisfun.com/algebra/matrix-determinant.html) on MathIsFun
- * [3x3 Determinant calculator](http://www.wolframalpha.com/widgets/view.jsp?id=7fcb0a2c0f0f41d9f4454ac2d8ed7ad6)
- * [Determinant](https://en.wikipedia.org/wiki/Determinant) on Wikipedia
diff --git a/client/src/guide/english/mathematics/absolute-value/index.md b/client/src/guide/english/mathematics/absolute-value/index.md
deleted file mode 100644
index 856f4576f7..0000000000
--- a/client/src/guide/english/mathematics/absolute-value/index.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title: Absolute Value
----
-## Absolute Value
-
-Absolute value is the positive value of a number.
-You can think of a number's absolute value as its distance from zero.
-It can be defined as,
-
-
-
-Absolute Value
-
-
diff --git a/client/src/guide/english/mathematics/add-fractions-with-unlike-denominators/index.md b/client/src/guide/english/mathematics/add-fractions-with-unlike-denominators/index.md
deleted file mode 100644
index 3d4424613d..0000000000
--- a/client/src/guide/english/mathematics/add-fractions-with-unlike-denominators/index.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Add Fractions with Unlike Denominators
----
-## Add Fractions with Unlike Denominators
-
-In order to add fractions with unlike denominators, you need to rewrite the fractions so that they all have the same denominator. One way of doing this is to multiply all the unlike denominators together to create a common denominator.
-
-### Examples
-
-1 * 31 * 7*1
-
-
-2. Add one to each of the exponents:
-
-2's exponent: 1 + 1 = 2
-3's exponent: 1 + 1 = 2
-7's exponent: 1 + 1 = 2
-
-
-3. Multiple each of the numbers above:
-
-2 * 2 * 2 = 8
-
-
-4. Confirm that 42 has 8 factors:
-
-1 | 2 | 3 | 6 | ... | 7 | 14 | 21 | 42
- --- | --- | --- | --- | --- | --- | --- | --- | ---
-
diff --git a/client/src/guide/english/mathematics/area-of-a-circle/index.md b/client/src/guide/english/mathematics/area-of-a-circle/index.md
deleted file mode 100644
index 82eba0b706..0000000000
--- a/client/src/guide/english/mathematics/area-of-a-circle/index.md
+++ /dev/null
@@ -1,90 +0,0 @@
----
-title: Area of a Circle
----
-## Area of a Circle
-
-The area of a circle is all the space inside a circle's circumference.
-
-If 'r' is the radius of circle, its area is calculated with formula pi*r2 where pi is mathematical constant.
-
-pi = 22/7 = 3.141592....
-
-A = pi *r2 , r is the radius of circle
-
-A = pi * {d2 /4}, d is the diameter of circle, d=2* r
-
-
-
-Area of a circle is defined as the space enclosed by the circumference of the circle.
-
-#### Terminology
-
-Circumference (C) - The enclosing boundary of the circle is called circumference of the circle.
-
-Radius (r) - The length of a line from any point on the boundary/cirumference of the circle to the centre of the circle is known as the radius of the circle.
-
-Diameter (d) - The length of the line that passes across the circle through the centre of the circle, is called the diameter.
-
-Pi (π ) - A mathematical constant which is approximated as 3.14
-
-#### Formula
-Area = π × r2
-
-###### Given radius of the circle
-
-Area of circle = π * radius 2 π * (diameter/2) 2 C 2 / 4 * π
-
-#### Examples
-
-1. Given radius = 3cm, find area of the circle
-
- Area = 3.14 * 9 = 28.26 cm2
-
-2. Given diameter = 8cm, find area of the circle
-
- Radius = (Diameter/2) = 4cm
-
- Area = 3.14 * 16 = 50.24 cm2
-
-3. Given circumference of a circle = 25cm, find the area of the circle
-
- Area = 625 / (4 * 3.14) = 49.76 cm2
-
-A "Real World" Example:-
-
-Example: Max is building a house. The first step is to drill holes and fill them with concrete.
-The holes are 0.4 m wide and 1 m deep, how much concrete should Max order for each hole?
-
-The holes are circular (in cross section) because they are drilled out using an auger.
-The diameter is 0.4m, so the Area is:
-A = (π/4) × D2
-A = (3.14159.../4) × 0.42
-A = 0.7854... × 0.16
-A = 0.126 m2 (to 3 decimals)
-And the holes are 1 m deep, so:
-Volume = 0.126 m2 × 1 m = 0.126 m3
-So Max should order 0.126 cubic meters of concrete to fill each hole.
-
-Note: Max could have estimated the area by:
-1. Calculating a square hole: 0.4 × 0.4 = 0.16 m2
-2. Taking 80% of that (estimates a circle): 80% × 0.16 m2 = 0.128 m2
-3. And the volume of a 1 m deep hole is: 0.128 m3
-
-#### More Information
-
-More information with illustrations can be found [WikiHow](https://www.wikihow.com/Calculate-the-Area-of-a-Circle)
-
diff --git a/client/src/guide/english/mathematics/area-of-a-parallelogram/index.md b/client/src/guide/english/mathematics/area-of-a-parallelogram/index.md
deleted file mode 100644
index cf18ad53f2..0000000000
--- a/client/src/guide/english/mathematics/area-of-a-parallelogram/index.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: Area of a Parallelogram
----
-
-## Area of a Parallelogram
-
-A parallelogram is a four-sided figure in which the opposite sides and angles are equal. It can be considered as being made up of two same triangles sticked base to base.
-
-
-The area of a triangle is `1/2 * base * height` and the area of a parallelogram is the addition of areas of the two same triangles.
-Therefore,
-
-### Example
-Consider a paralleogram as shown in the figure.
-
-
-Therefore, Area = 6 * 2.5 = 15 (m)^2
-
-
-
-
-#### More Information:
-
-For more details visit [wiki](https://en.wikipedia.org/wiki/Parallelogram)
-
diff --git a/client/src/guide/english/mathematics/completing-the-square/index.md b/client/src/guide/english/mathematics/completing-the-square/index.md
deleted file mode 100644
index 6636a8407c..0000000000
--- a/client/src/guide/english/mathematics/completing-the-square/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Completing the Square
----
-## Completing the Square
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/guide/english/mathematics/finding-a-percent/index.md b/client/src/guide/english/mathematics/finding-a-percent/index.md
deleted file mode 100644
index 331daf9e52..0000000000
--- a/client/src/guide/english/mathematics/finding-a-percent/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Finding a Percent
----
-## Finding a Percent
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/guide/english/mathematics/intro-to-the-trigonometric-ratios/index.md b/client/src/guide/english/mathematics/intro-to-the-trigonometric-ratios/index.md
deleted file mode 100644
index a8b5ce47a0..0000000000
--- a/client/src/guide/english/mathematics/intro-to-the-trigonometric-ratios/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Intro to the Trigonometric Ratios
----
-## Intro to the Trigonometric Ratios
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/guide/english/mongodb/index.md b/client/src/guide/english/mongodb/index.md
deleted file mode 100644
index b709cff1b9..0000000000
--- a/client/src/guide/english/mongodb/index.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title: MongoDB
----
-## MongoDB
-
-MongoDB is an open-source non-relational Database that uses a JSON like structure to store data.
-It uses a document model to store and retrieve the data instead of the table model used by sequential databases such as SQL or Oracle.
-
-### NOSQL Vs RDBMS
-
-| MongoDB Terms And Concepts | SQL Terms and Concepts |
-| --- | --- |
-| Database | Database |
-| Collection | Table |
-| document | Row |
-| Field | Column |
-| Index | Index |
-| Embedded Documents | Table Joins |
-
-
-### MongoDB Characteristics
-1. Next Generation Database
-2. No Joins
-3. Clustering
-4. Opensource
-5. Schema less
-6. No Relationships
-
-### Features of MongoDB
-1. Document Database
-2. High Performance
-3. Rich Query Language
-4. High Availability
-5. Horizontal Scalability
-
-
-### More Information
-[What is Mongo DB?](https://www.mongodb.com/what-is-mongodb)
-
-[Wikipedia article on Document-oriented Databases](https://en.wikipedia.org/wiki/Document-oriented_database)
-
-[SQL vs NoSQL](https://insights.dice.com/2012/07/16/sql-vs-nosql-which-is-better/)
-
-[Learn MongoDB from MongoDB](https://university.mongodb.com/)
diff --git a/client/src/guide/english/natural-language-processing/index.md b/client/src/guide/english/natural-language-processing/index.md
deleted file mode 100644
index ea1a7d3646..0000000000
--- a/client/src/guide/english/natural-language-processing/index.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Introduction to NLP
----
-
-## Outline
-* Motivation
-* Use cases
-* Language Modelling
-* Further readings
-
-## Motivation
-It has always been our dream to make machines understand our language. Ever since Chomsky came up with Context free grammars, linguists have been wanting to come up with solutions to understand context dependent grammars. It is therefore only natural that an academic disciple had evolved around this topic.
-
-## Use cases
-People have used this concept in a lot of interesting applications. Few of the exciting ones include Google Translate, Siri, or Gmail auto reply suggestions. People are however working on ways to improve these predictions, and state of the art research is being done on how to make machines answer questions more reliably.
-
-## How Natural Language Processing works
-Earlier, NLP employed rule based approach, i.e. all the rules were hard coded(Eg writing grammar). However this wasn't very affective to the variations in the language models.
-Currently, NLP processes are carried on using Artificial Intelligence. They rely mainly on Deep Learning, an AI that determines patterns in the data and uses it to train the model. This method is better than the earlier methods used because when learning through the huge data present, the machine can focus on most common cases, which is not easy with hand-written rules because it is not ovious as to where the efforts are to be put. Also, these models become more reliable with the increase in data, but in earlier approaches it an only be made accurate by increasing the complexity of the rules, which is a more difficult task.
-The model learns the rules of the language through the analysis of large corpora of typical real-world examples. This method requires enormous amount of labelled data , which is a big hurdle for NLP.
-
-## Language Modelling
-For those looking to get into this field, I intend to start you off with 2 concepts.
-
-#### Tokenisation
-Here the task sounds simple. Given a corpus (a dataset of sentences), generate individual tokens (meaningful words). We need to tokenise words and sentences. The first approach that comes to mind is to split by period and space. This however doesn't work. Consider Mr. John. Are "Mr" and "John" 2 sentences? Of course not. Now consider hyphen separated words. Would you want to split them as 2 words or as 1 word? These difficult questions make the task of tokenisation not so straightforward. Go ahead and pick a corpus from nltk, and buid your own regex for your very own tokeniser!
-
-#### n-gram models
-Next task is to build a language model. Here we consider an assumption that the nth word depends only on the previous n-1 words. 2-gram and 3-gram models are most commonly used. To build a 3-gram model, just group 3 tokens together and count their frequency in the corpus. You are now ready to predict the probability of a group of 3 words!
-
-## Further readings
-The field of NLP is huge. If you have read this far and have implemented the above, you have certainly loved this. Go ahead and read Jurafsky's book to learn some more new concepts. Remember, it's important to implement them as well.
-
diff --git a/client/src/guide/english/network-engineering/osi-layers/index.md b/client/src/guide/english/network-engineering/osi-layers/index.md
deleted file mode 100644
index 23db0107ab..0000000000
--- a/client/src/guide/english/network-engineering/osi-layers/index.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title: OSI Layers
----
-## OSI Layers
-
-### Introduction
-
-Have you ever wondered how data is sent through the network from one machine to another? If yes, then the Open System Interconnected model is what you are looking for.
-
-The OSI model is used to help standardise and characterise how data should flow from sender to receiver without taking into consideration the underlying internal structure of the endpoint (sender, receiver).
-
-The organisation that came up with this model is the **International Standardisation Organisation** and hence this model is formally referred to as **ISO - OSI**.
-
-### Architecture
-
-As in the figure below the model divides the network into **7 layers**. Data communication in the OSI model starts with the top layer ( Application Layer ) of the stack at the sending side, travels down the stack to the sender's lowest layer ( Physical Layer ), then traverses the physical network connection to the bottom layer on the receiving side, and up its OSI model stack.
-
-We go for a layered approach because it is easy to design independent layers with dedicated functions which interact with each other as compared to a single complex model.
-
-
-
-### **Important Observations**
-
-* _**End-to-end layers:**_
-In the diagram above, you would notice that the upper layers of the protocol (Application - Transport), the sender's and receiver's layers are directly connected via arrows. This is because these layers are not aware of intermediate devices that are used to transport data (such as switches and routers). These layers appear to communicate directly with each other.
-
-* _**Unit of Data:**_
-In the diagram above, to the extreme left is the unit of data that is used in each of the layer. The transport layer (and the layers below it) have a unique name for the unit of data being transferred from sender to receiver.
-
-### **Functions of Layers**
-
-* _**Layer 1 - Physical Layer:**_ The physical layer is the lowest of the OSI Layers and the most complex. This is because of the undelying hardware technologies used. The function of this layer is to define how the bit stream will be transmitted rather than the logical data packet. It deals with defining which frequency will the bit be transmitted on, what kind of modulation will be used, how the bits will be grouped and other low lying physical parameters needed for transmission of bits.
-
-* _**Layer 2 - Data Link Layer:**_ The data link layer is responsible for transferring data to adjacent devices on the same Local Area Network (LAN). This layer also has provisions to make sure that error-free data is being passed on to the higher layers from the physical layer. Hence, it conteains error detection and correction mechanisms to ensure the integrity of data is maintained.
-
-* _**Layer 3 - Network Layer:**_ The network layer is responsible for forwarding packets to other networks. Usually a network is divided into multiple subnets and the network layer with the help of routers forwards packets between such networks to establish a Wide Area Network (WAN).
-
-* _**Layer 4 - Transport Layer:**_ The transport layer ensures that messages are delivered error-free, in sequence, and with no losses or duplications. It relieves the higher layer protocols from any concern with the transfer of data between them and their peers.
-
-* _**Layer 5 - Session Layer:**_ The session layer allows session establishment between processes running on different stations.
-
-* _**Layer 6 - Presentation Layer:**_ The presentation layer formats the data to be presented to the application layer.
-
-* _**Layer 7 - Application Layer:**_ The application layer serves as the window for users and application processes to access network services.
diff --git a/client/src/guide/english/nodejs/file-system/index.md b/client/src/guide/english/nodejs/file-system/index.md
deleted file mode 100644
index db649ace3f..0000000000
--- a/client/src/guide/english/nodejs/file-system/index.md
+++ /dev/null
@@ -1,80 +0,0 @@
-## File System
-
-The Node.js File System module allows you to work with the file system on your computer.
-
-Node.js has a set of built-in modules which you can use without any further installation. Similarly **File System module** contains a set of functions which are required to perform different operations on files such as read and write operation.
-
-In order to to include a module, use the ```require()``` function with the name of the module.
-
-```javascript
-const fs = require('fs');
-```
-
-Common use for the File System module:
-
-* Read files
-* Create files
-* Update files
-* Delete files
-* Rename files
-
-## Reading a file
-
-The ```fs.readFile()``` method is used to read file on your computer. It takes three arguments - filename, encoding and a call back function.
-
-Node.js code to read file from your computer and return the content to the console.
-
-```javascript
-const fs = require('fs');
-fs.readFile('input.txt', 'utf-8', (err, data) => {
- if(err){
- console.log(err);
- }
- else{
- console.log("Content present in input.txt file : " + data.toString());
- }
-});
-```
-The above code reads a file *input.txt* from your computer and returns the content to the console.
-
-### Steps for execution :
-
-* You should have Node.js installed in your computer.
-* Create a file *app.js* and paste the above code.
-* Create a file *input.txt* and write some content into it.
-* Now open your console in the working directory and execute the command ``` node app.js ```.
-
-*Note* : The input.txt file should be present in the same directory where your Node.js code file is present otherwise it will throw an error.
-
-## Writing in a file
-
-The ```fs.writeFile()``` method takes three arguments - filename, content and a call back function.
-
-Node.js code to write content into file.
-
-```javascript
-const fs = require('fs');
-fs.writeFile('output.txt', "New content added", (err, data) => {
- if(err){
- console.log(err);
- }
- else{
- console.log("The file is saved");
- }
-});
-```
-The above code creates a file *output.txt* and add content *New content added* to it.
-
-### Steps for execution :
-
-* You should have Node.js installed in your computer.
-* Create a file *app.js* and paste the above code.
-* Now open your console in the working directory and execute the command ``` node app.js ```.
-
-*Note* : If file does not exist then the ```fs.writeFile()``` method creates a file and writes the content into it. On the contrary if the file exists then it overwrites the content in the file.
-
-## Resources
-
-* [Node.js API](https://nodejs.org/api/fs.html#fs_file_system)
-* [W3 Schools](https://www.w3schools.com/nodejs/nodejs_filesystem.asp)
-
diff --git a/client/src/guide/english/nodejs/npm/index.md b/client/src/guide/english/nodejs/npm/index.md
deleted file mode 100644
index 4f8891da37..0000000000
--- a/client/src/guide/english/nodejs/npm/index.md
+++ /dev/null
@@ -1,338 +0,0 @@
----
-title: NPM
----
-## NPM
-
-
-Node.js makes it possible to write applications in JavaScript on the server. It’s built on the V8 JavaScript runtime and written in C++ — so it’s fast. Originally, it was intended as a server environment for applications, but developers started using it to create modules to aid them in local task automation. Since then, a whole new ecosystem of Node-based tools has evolved to transform the face of front-end development.
-
-To make use of these modules (or packages) in Node.js we need to be able to install and manage them in a useful way. This is where npm, the Node package manager, comes in. It installs the packages you want to use and provides a useful interface to work with them.
-
-## Installing NPM
-
-To install `npm` we have to download Nodejs binaries in your local envrionment. Node.js binaries include the latest version of npm. To verify that:
-
-```shell
-npm -v
-5.6.0
-```
-
-Node Package Manager (NPM) provides two main functionalities −
-
-* Online repositories for node.js packages/modules which are searchable on `npmjs.com`.
-
-* Command line utility to install Node.js packages, do version management and dependency management of Node.js packages.
-
-## Installing Modules using NPM
-
-`npm` can install packages in local or global mode. By default, NPM installs any dependency in the local mode. In local mode it installs the package in a node_modules folder in your parent working directory. This location is owned by the current user. Global packages are installed in {prefix}`/lib/node_modules/` which is owned by root, where {prefix} is usually `/usr/ or /usr/local`. This means you would have to use sudo to install packages globally, which could cause permission errors when resolving third-party dependencies, as well as being a security concern.
-
-### Installing Packages in Global Mode
-
-Any packages installed globally will become available from the command line. We use the --global flag or -g to install packages globally.
-
-```shell
-$ npm install uglify-js --global
-```
-
-We can list the global packages we have installed with the npm list command.
-
-```shell
-$ npm list --global
-/usr/local/lib
-├─┬ npm@5.6.0
-│ ├── abbrev@1.1.0
-│ ├── ansi-regex@2.1.1
-│ ├── ansicolors@0.3.2
-│ ├── ansistyles@0.1.3
-....................
-└─┬ uglify-js@3.0.15
- ├─┬ commander@2.9.0
- │ └── graceful-readlink@1.0.1
- └── source-map@0.5.6
-```
-
-The output however, is rather verbose. We can change that with the --depth=0 option.
-
-```js
-$ npm list -g --depth=0
-/usr/local/lib
-├── npm@5.6.0
-└── uglify-js@3.0.15
-```
-
-### Installing Packages in Local Mode
-
-When you install packages locally, you normally do so using a package.json file.
-
-```shell
-npm install --save express
-```
-
-Now you can use this module in your js file as following
-
-```js
-const express = require('express');
-```
-
-Local modules are further divided into two types of depenedencies: `devDepenednecies` and `dependencies`. The difference between these two, is that devDependencies are modules which are only required during development, while dependencies are modules which are also required at runtime. To save a dependency as a devDependency on installation we need to do an `npm install --save-dev`, instead of just an `npm install --save`.
-
-A nice shorthand for installing a devDependency that I like to use is `npm i -D`. The shorthand for saving a regular dependency is `-S` instead of `-D`.
-
-### Installing a Specific Version of a Package
-
-To do so, we mention the package version we want to install.
-
-```shell
-$ npm install underscore@1.8.2 -S
-```
-
-To remove a global dependency, use `-g` flag.
-
-### Uninstalling Local Packages
-
-npm is a package manager so it must be able to remove a package. We can remove the package:
-
-```shell
-$ npm uninstall underscore -S
-```
-
-To update a global dependency, use `-g` flag.
-
-### Updating a Package
-
-To update a package, you can do:
-
-```
-$ npm update underscore -S
-```
-
-To check if there is an update available for any package associated with our project:
-
-```shell
-$ npm outdated
-
-Package Current Wanted Latest Location
-underscore 1.8.2 1.8.3 1.8.3 project
-```
-
-The Current column shows us the version that is installed locally. The Latest column tells us the latest version of the package. And the Wanted column tells us the latest version of the package we can upgrade to without breaking our existing code.
-
-## Managing Dependencies with package.json
-
-If not using a specific flag and installing a module like `npm install express` will install the module in `node_modules` folder locally but the `package.json` that keep records of every dependency we are using in a project will not be updated with our addition. Thus, the package will be development specific, will not be installed in runtimme environment. Make sure, you always use a proper flag and keep `package.json` file updated.
-
-When you install packages locally, you need a package.json file. To generate one you can do that by using `npm init` command. It will prompt up with some questions that by pressing enter you can keep the default values.
-
-```shell
-$ npm init
-package name: (project)
-version: (1.0.0)
-description: Demo of package.json
-entry point: (index.js)
-test command:
-git repository:
-keywords:
-author:
-license: (ISC)
-```
-
-Think of `package.json` as the keeper of all dependencies or manifestation of a Node.js project. If you want a quicker way to generate a package.json file use `npm init --y`.
-
-List of Common Attributes in a `package.json` file:
-
-* name − name of the package
-
-* version − semantic version of the package
-
-* description − description of the package
-
-* homepage − homepage of the package
-
-* author − author of the package
-
-* contributors − name of the contributors to the package
-
-* dependencies − list of dependencies. NPM automatically installs all the dependencies mentioned here in the node_module folder of the package.
-
-* devDependencies - list of all development specific dependencies
-
-* repository − repository type and URL of the package
-
-* main − entry point of the package
-
-* keywords − keywords
-
-* license - a license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it.
-
-* scripts - The "scripts" property is a dictionary containing script commands that are run at various times in the lifecycle of your package.
-
-* config - object that can be used to set configuration parameters used in package scripts that persist across upgrades.
-
-An example:
-
-```json
-{
- "name": "express",
- "description": "Fast, unopinionated, minimalist web framework",
- "version": "4.11.2",
- "author": {
-
- "name": "TJ Holowaychuk",
- "email": "tj@vision-media.ca"
- },
-
- "contributors": [{
- "name": "Aaron Heckmann",
- "email": "aaron.heckmann+github@gmail.com"
- },
-
- ],
- "license": "MIT", "repository": {
- "type": "git",
- "url": "https://github.com/strongloop/express"
- },
- "homepage": "https://expressjs.com/", "keywords": [
- "express",
- "framework",
- "sinatra",
- "web",
- "rest",
- "restful",
- "router",
- "app",
- "api"
- ],
- "dependencies": {
- "serve-static": "~1.8.1",
-
- },
- "devDependencies": {
- "jade": "~1.9.1",
- },
- "engines": {
- "node": ">= 0.10.0"
- },
- "files": [
- "LICENSE",
- "History.md",
- "Readme.md",
- "index.js",
- "lib/"
- ],
- "scripts": {
- "test": "mocha --require test/support/env
- --reporter spec --bail --check-leaks test/ test/acceptance/",
- "test-cov": "istanbul cover node_modules/mocha/bin/_mocha
- -- --require test/support/env --reporter dot --check-leaks test/ test/acceptance/",
- "test-tap": "mocha --require test/support/env
- --reporter tap --check-leaks test/ test/acceptance/",
- "test-travis": "istanbul cover node_modules/mocha/bin/_mocha
- --report lcovonly -- --require test/support/env
- --reporter spec --check-leaks test/ test/acceptance/"
- },
-
-}
-```
-
-## npm Scripts
-
-`npm` scripts are used to automate repetitive tasks. For example, building your project, minifying Cascading Style Sheets (CSS) and JavaScript (JS) files. Scripts are also used in deleting temporary files and folders, etc. They can be customized and are accessible via `scripts` object in `package.json`.
-
-```json
-{
- "name": "super-cool-package",
- "version": "1.0.0",
- "scripts": {}
-}
-```
-
-An example of the most popular NPM script:
-
-```json
-"scripts": {
- "start": "node index.js",
- ...
-}
-```
-
-## npm Cache
-
-When npm installs a package it keeps a copy, so the next time you want to install that package, it doesn’t need to hit the network. The copies are cached in the .npm directory in your home path.
-
-```shell
-$ ls ~/.npm
-lodash.zipobject
-log-driver
-log-symbols
-logalot
-logfmt
-loglevel
-long-timeout
-longest
-longest-strea
-```
-
-This directory will get cluttered with old packages over time, so it’s useful to clean it up occasionally.
-
-```shell
-$ npm cache clean
-```
-
-## Yarn - an alternative to npm
-
-Yarn is also a JavaScript package manager developed and maintained by Facebook. Both share high level similarities when it come to using them. It is supposedly to be faster in installing dependencies than npm. To install it:
-
-```shell
-npm install -g yarn
-```
-
-Yarn doesn't intend to replace npm, more like improving on it. It uses the same package.json file, and saves dependencies to the `node_modules/`folder. To initialise a projcet, you will use:
-
-```shell
-yarn init
-```
-
-### Adding, Upgrading, and Removing Dependencies
-
-Adding a new dependency is easy and similar to npm:
-
-```shell
-yarn add [package-name]
-```
-
-If you want a specific package version or tag, you can do this.
-
-```shell
-yarn add express@4.14.1
-```
-
-For dev dependencies, peer dependencies and optional dependencies you pass the --dev --peer --optional respectively.
-
-```shell
-yarn add gulp --dev
-```
-
-Will save gulp under devDependencies. To upgrade or remove a package, you just replace the add command with either upgrade or remove followed by the package name.
-
-```shell
-# upgrade a gulp from 3.9.1 to version 4
-yarn upgrade gulp@4.0
-
-# remove a gulp
-yarn remove gulp
-```
-
-After every install, upgrade or removal, yarn updates a yarn.lock file which keeps track of the exact package version installed in node_modules directory. Similar feature has been updated in npm. Now there is a `package-lock.json` which behave exactly in the same manner as `yarn.lock` in newer versions of npm.
-
-### Package Version Numbers, and What they Mean
-
-A first release of a npm package is always 1.0.0
-
-Bug fixes, or minor changes increment the third digit, hense 1.0.0 would become 1.0.1
-
-New features that dont break previous versions of a package increment the second digit, hense 1.0.0 would become 1.1.0
-
-All changes that break the previous releases of a package increment the first digit, hense 1.0.0 would become 2.0.0
-
-It is important to remember this when updateing packages to keep your project stable!
diff --git a/client/src/guide/english/nodejs/socket.io/index.md b/client/src/guide/english/nodejs/socket.io/index.md
deleted file mode 100644
index 558a64b02d..0000000000
--- a/client/src/guide/english/nodejs/socket.io/index.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Socket.io
----
-
-## Socket.io
-
-[Socket.io](https://socket.io/) is a Node.js library made to help make real-time communication between computers possible. To ensure this Socket.io uses WebSockets to establish a connection between the client's browser and the server. This library uses [Engine.IO](https://github.com/socketio/engine.io) for building the connection.
-
-### Demos
-
-To get a taste of what is possible, Socket.io provides two demos to show it's possible use-cases. You can find the demos at [https://socket.io/demos/chat/](https://socket.io/demos/chat/) and find the link to the whiteboard demo on the left.
-
-### Get Started
-
-Since Socket.io is a Node.js library you have to make sure that Node.js is installed.
-If it's not set up yet get the latest version at [Nodejs.org](https://nodejs.org/)
-
-#### macOS
-
-Node.js can also be installed via [Homebrew](https://brew.sh/) a package manager for macOS.
-
-Just type `brew install node` to install Node.js.
-
-A [get started](https://socket.io/get-started/chat/) guide can also be found on Socket.io's page. It shows how to easily build a real-time chat in just a couple of lines.
-
-#### More information
-
-More information about Socket.io and it's documentation can be found at:
-- [Socket.io](https://socket.io/)
-- [Socket.io Documentation](https://socket.io/docs/)
\ No newline at end of file
diff --git a/client/src/guide/english/php/PHP Operators/index.md b/client/src/guide/english/php/PHP Operators/index.md
deleted file mode 100644
index a73dfe9f36..0000000000
--- a/client/src/guide/english/php/PHP Operators/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: PHP Operators
----
-## PHP Operators
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/guide/english/php/PHP Variables/index.md b/client/src/guide/english/php/PHP Variables/index.md
deleted file mode 100644
index 812177b6e7..0000000000
--- a/client/src/guide/english/php/PHP Variables/index.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: PHP Variables
----
-
-### PHP- Vaiables Types
-
-Varibles are the main way to store information in the middle way of a PHP program.
-All variables in PHP are donated with a leading dollar sign like `$variable_name`.
-Variables are assigned with the `= operator` , with the variable on the left-hand side and the expression to be evaluated on the right.
-
-### Variable Naming
-
-Rules for naming a variable is listed below:-
- 1. Variables names must begin with a letter or underscores character.
- 2.A variable name can consist of numbers, letters, underscores but you cannot use characters like `+ , - , % , ( , ) . &` in its name.
- 3.Variable names are case-sensitive i.e. `($age and $AGE are two different variables)`.
-
-### Creating (Declaring) PHP Variables
-
-In PHP, a variable starts with the $ sign, followed by the name of the variable. The code snippet given below shows it.
-
-``` shell
-
- ```
-
-
-
diff --git a/client/src/guide/english/php/array/index.md b/client/src/guide/english/php/array/index.md
deleted file mode 100644
index edc9a1e2b8..0000000000
--- a/client/src/guide/english/php/array/index.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: array
----
-
-## Introduction of PHP array
-
-An array in PHP is actually an ordered map. A map is a type that associates values to keys.
-This type is optimized for several different uses; it can be treated as an array, list (vector), hash table (an implementation of a map), dictionary, collection, stack, queue, and probably more.
-As array values can be other arrays, trees and multidimensional arrays are also possible.
-
-
-Here is an example:
-```
-
-```
-
-PHP array has so many functions to work with. Here is all list sorted: Functions
-
-## Associative arrays
-
-PHP arrays can be used as key and value like map. It can be accessed by key too.
-
-Here is an simple example:
-```
- "bar",
- "bar" => "foo",
-);
-
-echo $array['bar'];
-
-```
-
-Have a good day, happy coding !!!
diff --git a/client/src/guide/english/php/forms/handling-form-input/index.md b/client/src/guide/english/php/forms/handling-form-input/index.md
deleted file mode 100644
index 7a052e094f..0000000000
--- a/client/src/guide/english/php/forms/handling-form-input/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Handling Form Input
----
-## Handling Form Input
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/php/if-else-statement/index.md b/client/src/guide/english/php/if-else-statement/index.md
deleted file mode 100644
index f5386070f7..0000000000
--- a/client/src/guide/english/php/if-else-statement/index.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: If-else Statement
----
-## Introduction
-If/Else is a conditional statement where depending on the truthiness of a condition, diffierent actions will be performed.
-
-> **Note:** The `{}` brackets are only needed if the condition has more than one action statement.
-
-## If Statement
-~~~~
- if (condition){
- statement1;
- statement2;
- }
-~~~~
-> **Note:** The `else` statement is optional.
-## If/Else Statement
-~~~~
- if (condition){
- statement1;
- statement2;
- }
- else{
- statement3;
- statement4;
- }
-~~~~
-## If/Elseif/Else Statement
-~~~~
- if (condition){
- statement1;
- statement2;
- }
- elseif{
- statement3;
- statement4;
- }
- else
- statement5;
-~~~~
-
-For more information check out the following link:
-PHP Else
diff --git a/client/src/guide/english/php/php-array/index.md b/client/src/guide/english/php/php-array/index.md
deleted file mode 100644
index cc956765d3..0000000000
--- a/client/src/guide/english/php/php-array/index.md
+++ /dev/null
@@ -1,167 +0,0 @@
----
-title: Php Arrays
----
-
-An array is a data structure that stores one or more similar type of values in a single value. For example if you want to store 100 numbers then instead of defining 100 variables its easy to define an array of 100 length.
-
-There are three different kind of arrays and each array value is accessed using an ID c which is called array index.
-
-Numeric array − An array with a numeric index. Values are stored and accessed in linear fashion.
-
-Associative array − An array with strings as index. This stores element values in association with key values rather than in a strict linear index order.
-
-Multidimensional array − An array containing one or more arrays and values are accessed using multiple indices
-
-NOTE − Built-in array functions is given in function reference PHP Array Functions
-
-### Numeric Array
-These arrays can store numbers, strings and any object but their index will be represented by numbers. By default array index starts from zero.
-
-#### Example
-Following is the example showing how to create and access numeric arrays.
-
-Here we have used array() function to create array. This function is explained in function reference.
-
-```
-
-
-
- ";
- }
-
- /* Second method to create array. */
- $numbers[0] = "one";
- $numbers[1] = "two";
- $numbers[2] = "three";
- $numbers[3] = "four";
- $numbers[4] = "five";
-
- foreach( $numbers as $value ) {
- echo "Value is $value Javascript Switch Guide to compare and contrast). It allows rapid case testing with a lot of different possible conditions, the code is also more readable.
-
-### Syntax
-```php
-php.net docs Switch
diff --git a/client/src/guide/english/php/working-with-databases/mysqli/index.md b/client/src/guide/english/php/working-with-databases/mysqli/index.md
deleted file mode 100644
index b95cb55f75..0000000000
--- a/client/src/guide/english/php/working-with-databases/mysqli/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: MySQLi
----
-## MySQLi
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/product-design/index.md b/client/src/guide/english/product-design/index.md
deleted file mode 100644
index c1c09c08ec..0000000000
--- a/client/src/guide/english/product-design/index.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Product Design
----
-## Product Design
-
-In this section, we'll have guides to a wide variety of tools and methods used by product designers.
\ No newline at end of file
diff --git a/client/src/guide/english/progressive-web-apps/add-to-homescreen/index.md b/client/src/guide/english/progressive-web-apps/add-to-homescreen/index.md
deleted file mode 100644
index ece13a3e07..0000000000
--- a/client/src/guide/english/progressive-web-apps/add-to-homescreen/index.md
+++ /dev/null
@@ -1,138 +0,0 @@
----
-title: Add To Homescreen
----
-
-## Add To Homescreen
-
-Here the web app install banner is focused on web app, with the feature of add to homescreen.
-
-### Browser Support for Add To Homescreen
-
-Add to Homescreen functionality is currently supported by:
-* Chrome
-* iOS Safari
-
-You can see the latest status of browser support of this feature [here](https://caniuse.com/#feat=web-app-manifest).
-
-### On Android
-
-On Android, the "add to homescreen" banner comes up automatically if you meet certain requirements. This is what it should look like on Android:
-
-| Add to homescreen prompt | When app launched |
-| :----------------------: | :---------------: |
-| ![prompt][add1] | ![launch][add2] |
-
-[add1]: https://user-images.githubusercontent.com/15358452/31663686-860779f0-b375-11e7-85c9-1387d9b3bfcf.png "Add to homescreen prompt on android"
-[add2]: https://user-images.githubusercontent.com/15358452/31663690-89b0d998-b375-11e7-8a84-f3e33be9a2c2.png "Launch from Homescreen"
-
-#### Requirements
-
-* include a `manifest.json` file with the following properties:
- * `short name`
- * `name`
- * `192x192` size of `png` icon
- * `start_url`
-* include a service worker that is both registered and activated
-* the website served over HTTPS (you can still try this with localhost without HTTPS)
-* the website meets engagement heuristics defined by Chrome
-
-#### manifest.json
-
-```json
-{
- "name": "FreeCodeCamp",
- "short_name": "FreeCodeCamp",
- "theme_color": "#00FF00",
- "background_color": "#00FF00",
- "display": "standalone",
- "Scope": "/",
- "start_url": "/",
- "icons": [
- {
- "src": "assets/images/icons/icon-72x72.png",
- "sizes": "72x72",
- "type": "image/png"
- },
- {
- "src": "assets/images/icons/icon-96x96.png",
- "sizes": "96x96",
- "type": "image/png"
- },
- {
- "src": "assets/images/icons/icon-128x128.png",
- "sizes": "128x128",
- "type": "image/png"
- },
- {
- "src": "assets/images/icons/icon-144x144.png",
- "sizes": "144x144",
- "type": "image/png"
- },
- {
- "src": "assets/images/icons/icon-152x152.png",
- "sizes": "152x152",
- "type": "image/png"
- },
- {
- "src": "assets/images/icons/icon-192x192.png",
- "sizes": "192x192",
- "type": "image/png"
- },
- {
- "src": "assets/images/icons/icon-384x384.png",
- "sizes": "384x384",
- "type": "image/png"
- },
- {
- "src": "assets/images/icons/icon-512x512.png",
- "sizes": "512x512",
- "type": "image/png"
- }
- ],
- "splash_pages": null
-}
-```
-
-* `name` is the name of the web app. (It will be shown in the launch screen)
-* `short name` is the short name of the web app. (It will be shown below the icon of phone menu)
-* `theme_color` is the color of the top of the browser.
-* `background_color` is the background color of the launch screen.
-* `display` is the way the web app should display once launched on the phone.
-* `start_url` define the starting url of the website.
-* `icons` is an array that store all the images location, sizes and type.
-
-### On other devices
-
-Although this method does not work on iOS and Windows, there is a fallback method.
-
-**iOS**
-
-On iOS, the "add to homescreen" button must be added manually. Add the following meta tags to the head section of your HTML to support iOS web app icon.
-
-```html
-1
-
-### Progressive Enhancement
-
-Progressive enhancement means that everyone can access the basic content and functionality of a page in any browser, and those without certain browser features may receive a reduced but still functional experience. [- Lighthouse](https://medium.com/@addyosmani/progressive-web-apps-with-react-js-part-4-site-is-progressively-enhanced-b5ad7cf7a447)2
-
-A great analogy from [Aaron Gustafson](http://alistapart.com/article/understandingprogressiveenhancement) is that progressive enhancement (PE) is like a peanut M&M.
-
-> "The Peanut is your content, the chocolate coating is your presentation layer and your JavaScript is the hard candy shell."
-
-This implies that depending on the browser, the experience can change.
-
-### Demo
-
-VIDEO
-
-### References
-
-1. [Russell, Alex. "Progressive Web Apps: Escaping Tabs Without Losing Our Soul" "Infrequently Noted" Posted: June 15, 2015.](https://infrequently.org/2015/06/progressive-apps-escaping-tabs-without-losing-our-soul/)
-2. [Progressive Web Apps - Google Developers](https://developers.google.com/web/progressive-web-apps/)
diff --git a/client/src/guide/english/puppet/index.md b/client/src/guide/english/puppet/index.md
deleted file mode 100644
index 9da4b89258..0000000000
--- a/client/src/guide/english/puppet/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Puppet
----
-## Puppet
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/python/abs-function/index.md b/client/src/guide/english/python/abs-function/index.md
deleted file mode 100644
index d72db5b0dc..0000000000
--- a/client/src/guide/english/python/abs-function/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Python Abs Function
----
-`abs()` is a built-in function in Python 3, to compute the absolute value of any number. The absolute value of a number "means only how far a number is from 0" 1 It takes one argument `x`. The argument can even be a complex number , and in that case its modulus is returned.
-
-## Argument
-
-It takes one argument `x` - an integer, or decimal, or a complex number.
-
-## Return Value
-
-The return value would be a positive number. Even if complex number is passed, it would return its magnitude, computed as per complex number algebra.
-
-## Code Sample
-```python
-print(abs(3.4)) # prints 3.4
-print(abs(-6)) # prints 6
-print(abs(3 + 4j)) # prints 5, because |3 + 4j| = 5
-```
-
-🚀 Run Code
-
-Official Docs
-
-### Sources
-1. Math Is Fun. Accessed: October 25, 2017
diff --git a/client/src/guide/english/python/basic-operators/index.md b/client/src/guide/english/python/basic-operators/index.md
deleted file mode 100644
index cfc68f7544..0000000000
--- a/client/src/guide/english/python/basic-operators/index.md
+++ /dev/null
@@ -1,323 +0,0 @@
----
-title: Basic Operators
----
-## Basic Operators
-
-Operators are symbols which tells the interpreter to do a specific operation (viz arithmetic, comparison, logical, etc.)
-
-The different types of operators in Python are listed below:
-
-1. Arithmetic Operators
-2. Relational Operators
-3. Bitwise Operators
-4. Assignment Operators
-5. Logical Operators
-6. Membership Operators
-7. Identity Operators
-
-#### Arithmetic Operators
-
-An arithmetic operator takes two operands as input, performs a calculation and returns the result.
-
-Consider the expression, “a = 2 + 3” . Here, `2` and `3` are the operands and `+` is the arithmetic operator . The result of the operation is stored in the variable a.
-
-
-
- Operator
- Description
- Usage
-
-
- +
- Performs Addition on the operands
- 12 + 3 = 15
-
-
- -
- Performs Subtraction on the operands.
- 12 - 3 = 9
-
-
- *
- Performs Multiplication on the operands
- 12 * 3 = 36
-
-
- /
- Performs Division on the operands.
- 12 / 3 = 4
-
-
- Note: When two integers are used, the result differs between Python 2 and Python 3.
- 5 / 2 = 2 in Python 2
- 5 / 2 = 2.5 in Python 3
-
-
- %
- Performs a Modulus on the operands.
- 16 % 3 = 1
-
-
- **
- Performs an Exponentiation operation.
- 12 ** 3 = 1728
-
-
- //
- Performs a Floor Division operation.
- 18 // 5 = 3
-
-
-
-Note: To get the result in floating type, one of the operands must also be of float type.
-
-#### Relational Operators
-
-A relational operator is used to compare two operands to decide a relation between them. It returns a boolean value based on the condition.
-
-
-
- Operator
- Description
- Usage
-
-
- >
- Returns True if the left operand is greater than the right operand
- 12 > 3 returns True
-
-
- <
- Returns True if the right operand is greater than the left operand
- 12 < 3 returns False
-
-
- ==
- Returns True if both the operands are equal
- 12 == 3 returns False
-
-
- >=
- Returns True if the left operand is greater than or equal to the right operand
- 12 >= 3 returns True
-
-
- <=
- Returns True if the right operand is greater than or equal to the left operand
- 12 <= 3 returns False
-
-
- !=
- Returns True if both the operands are not equal
- 12 != 3 returns True
-
-
-
-#### Bitwise Operators
-
-A bitwise operator performs operations on the operands bit by bit
-
-Consider a = 2 (in binary notation, 10) and b = 3 (in binary notation, 11) for the below usages
-
-
-
- Operator
- Description
- Usage
-
-
- &
- Performs bitwise AND operation on the operands
- a & b = 2
-
-
- |
- Performs bitwise OR operation on the operands
- a | b = 3
-
-
- ^
- Performs bitwise XOR operation on the operands
- a ^ b = 1
-
-
- ~
- Performs bitwise NOT operation on the operand
- ~a = -3
-
-
- >>
- Performs a bitwise right shift. Shifts the bits of left operand, right by the number of bits specified as the right operand
- a >> b = 0
-
-
- <<
- Performs a bitwise left shift. Shifts the bits of left operand, left by the number of bits specified as the right operand
- a << b = 16
-
-
-
-
-#### Assignment Operators
-An assignment operator is used to assign values to a variable. This is usually combined with other operators (like arithmetic, bitwise) where the operation is performed on the operands and the result is assigned to the left operand.
-
-Consider the following examples,
-a = 18 . Here `=` is an assignment operator, and the result is stored in variable a.
-a += 10 . Here `+=` is an assignment operator, and the result is stored in variable a. This is same as a = a + 10.
-
-
-
- Operator
- Usage
-
-
- =
- a = 5. The value 5 is assigned to the variable a
-
-
- +=
- a += 5 is equivalent to a = a + 5
-
-
- -=
- a -= 5 is equivalent to a = a - 5
-
-
- *=
- a *= 3 is equivalent to a = a * 3
-
-
- /=
- a /= 3 is equivalent to a = a / 3
-
-
- %=
- a %= 3 is equivalent to a = a % 3
-
-
- **=
- a **= 3 is equivalent to a = a ** 3
-
-
- //=
- a //= 3 is equivalent to a = a // 3
-
-
- &=
- a &= 3 is equivalent to a = a & 3
-
-
- |=
- a |= 3 is equivalent to a = a | 3
-
-
- ^=
- a ^= 3 is equivalent to a = a ^ 3
-
-
- >>=
- a >>= 3 is equivalent to a = a >> 3
-
-
- <<=
- a <<= 3 is equivalent to a = a << 3
-
-
-
-#### Logical Operators
-
-A logical operator is used to make a decision based on multiple conditions. The logical operators used in Python are
-`and`, `or` and `not`
-
-
-
- Operator
- Description
- Usage
-
-
- and
- Returns True if both the operands are True
- a and b
-
-
- or
- Returns True if any one of the operands are True
- a or b
-
-
- not
- Returns True if the operand is False
- not a
-
-
-
-
-#### Membership Operators
-
-A membership operator is used to identify membership in any sequence (lists, strings, tuples).
-
- ...
- ...
- ...
-
- ```
-
-#### Class Objects:
-
-Class objects support two kinds of operations: attribute references and instantiation.
-
-Attribute references use the standard syntax used for all attribute references in Python: `obj.name`.
-Valid attribute names are all the names that were in the class’s namespace when the class object was created.
-So, if the class definition looked like this:
-```python
-class MyClass:
- """ A simple example class """
- i = 12345
-
- def f(self):
- return 'hello world'
-```
-Then `MyClass.i` and `MyClass.f` are valid attribute references, returning an integer and a function object, respectively.
-Class attributes can also be assigned to, so you can change the value of `MyClass.i` by assignment. `__doc__` is also a valid attribute, returning the docstring belonging to the class: `"A simple example class"`.
-
-Class instantiation uses function notation. Just pretend that the class object is a parameterless function that returns a new instance of the class. For example (assuming the above class):
-```python
-x = MyClass()
-```
-Creates a new instance of the class and assigns this object to the local variable x.
-
-The instantiation operation (“calling” a class object) creates an empty object.
-Many classes like to create objects with instances customized to a specific initial state.
-Therefore a class may define a special method named __init__(), like this:
-
-```python
-def __init__(self):
- self.data = []
-```
-When a class defines an `__init__()` method, class instantiation automatically invokes `__init__()` for the newly-created class instance.
-So in this example, a new, initialized instance can be obtained by:
-```python
-x = MyClass()
-```
-Of course, the `__init__()` method may have arguments for greater flexibility.
-In that case, arguments given to the class instantiation operator are passed on to `__init__()`. For example,
-```python
-class Complex:
- def __init__(self, realpart, imagpart):
- self.r = realpart
- self.i = imagpart
- ...
-
-x = Complex(3.0, -4.5)
->>> x.r, x.i
-(3.0, -4.5)
-```
\ No newline at end of file
diff --git a/client/src/guide/english/python/creating-guis-in-python3/index.md b/client/src/guide/english/python/creating-guis-in-python3/index.md
deleted file mode 100644
index a8ba820880..0000000000
--- a/client/src/guide/english/python/creating-guis-in-python3/index.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Creating GUI's in Python3
----
-
-# Creating GUI's in Python 3
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
diff --git a/client/src/guide/english/python/data-structures/dictionaries/index.md b/client/src/guide/english/python/data-structures/dictionaries/index.md
deleted file mode 100644
index 26378f1a9c..0000000000
--- a/client/src/guide/english/python/data-structures/dictionaries/index.md
+++ /dev/null
@@ -1,108 +0,0 @@
----
-title: The Python Dict
----
-
-A Dictionary (a.k.a "dict") in python is a built-in datatype that can be used to store **`key-value`** pairs. This allows you to treat a **`dict`** like it's a *database* to store and organize data.
-
-The special thing about dictionaries is the way they are implemented. Hash-table-like structure makes it easy to check for
-existence - which means that we can easily determine if a specific key is present in the dictionary without needing to examine
-every element. The Python interpreter can just go to the location key and check if the key is there.
-
-Dictionaries can use almost any arbitrary datatypes, like strings, integers etc, for keys. However, values that are not hashable,
-that is, values containing lists, dictionaries or other mutable types (that are compared by value rather than by object identity) may not be used as keys. Numeric types used for keys obey the normal rules for numeric comparison: if two numbers compare equal (such as `1` and `1.0`) then they can be used interchangeably to index the same dictionary entry. (Note however, that since computers store floating-point numbers as approximations it is usually unwise to use them as dictionary keys.)
-
-One most important requirement of a dictionary is that the keys **must** be unique.
-To create an empty dictionary just use a pair of braces:
-```python
- >>> teams = {}
- >>> type(teams)
- >>>
-```
-To create a non-empty dictionary with some initial values, place a comma-seperated list of key-value pairs:
-```python
- >>> teams = {'barcelona': 1875, 'chelsea': 1910}
- >>> teams
- {'barcelona': 1875, 'chelsea': 1910}
-```
-It's easy to add key-value pairs to an existing dictionary:
-```python
- >>> teams['santos'] = 1787
- >>> teams
- {'chelsea': 1910, 'barcelona': 1875, 'santos': 1787} # Notice the order - Dictionaries are unordered !
- >>> # extracting value - Just provide the key
- ...
- >>> teams['barcelona']
- 1875
-```
-**`del`** operator is used to delete a key-value pair from the dict. In scenarios where a key that's already in use is again used to store values, the old value associated with that key is completely lost. Also, keep in mind that it's an error to extract the value using an non-existent key.
-```python
- >>> del teams['santos']
- >>> teams
- {'chelsea': 1910, 'barcelona': 1875}
- >>> teams['chelsea'] = 2017 # overwriting
- >>> teams
- {'chelsea': 2017, 'barcelona': 1875}
-```
-**`in`** keyword can be used to check whether a key exist in the dict or not:
-
-```python
- >>> 'sanots' in teams
- False
- >>> 'barcelona' in teams
- True
- >>> 'chelsea' not in teams
- False
-```
-**`keys`** is a built-in *method* that can be used to get the keys of a given dictionary. To extract the keys present in a dict as lists:
-```python
- >>> club_names = list(teams.keys())
- >>> club_names
- ['chelsea', 'barcelona']
-```
-Yet another way of creating dictionary is using the **`dict()`** method:
-```python
- >>> players = dict( [('messi','argentina'), ('ronaldo','portugal'), ('kaka','brazil')] ) # sequence of key-value pair is passed
- >>> players
- {'ronaldo': 'portugal', 'kaka': 'brazil', 'messi': 'argentina'}
- >>>
- >>> # If keys are simple strings, it's quite easier to specify pairs using keyword arguments
- ...
- >>> dict( totti = 38, zidane = 43 )
- {'zidane': 43, 'totti': 38}
-```
-Dict comprehensions can be used as well to create dictionaries from arbitrary key and value expressions:
-```python
- >>> {x: x**2 for x in (2, 4, 6)}
- {2: 4, 4: 16, 6: 36}
-```
-
-**Looping in Dictionary**
-To simply loop over the keys in the dictionary, rather than the keys and values:
-```python
- >>> d = {'x': 1, 'y': 2, 'z': 3}
- >>> for key in d:
- ... print(key) # do something
- ...
- x
- y
- z
-```
-To loop over both key and value you can use the following:
-For Python 2.x:
-```python
- >>> for key, item in d.iteritems():
- ... print items
- ...
- 1
- 2
- 3
-```
-Use **`items()`** for Python 3.x:
-```python
- >>> for key, item in d.items():
- ... print(key, items)
- ...
- x 1
- y 2
- z 3
-```
diff --git a/client/src/guide/english/python/data-structures/tuples/index.md b/client/src/guide/english/python/data-structures/tuples/index.md
deleted file mode 100644
index e3babb718e..0000000000
--- a/client/src/guide/english/python/data-structures/tuples/index.md
+++ /dev/null
@@ -1,170 +0,0 @@
----
-title: The Tuples
----
-## The Tuples
-
-A tuple is a sequence of Python objects. Tuples are immutable which means they cannot be modified after creation, unlike lists.
-
-**Creation:**
-
-An empty `tuple` is created using a pair of round brackets, `()`:
-```shell
- >>> empty_tuple = ()
- >>> print(empty_tuple)
- ()
- >>> type(empty_tuple)
-
- >>> len(empty_tuple)
- 0
-```
-A `tuple` with elements is created by separating the elements with commas (surrounding round brackets, `()`, are optional with exceptions):
-```shell
- >>> tuple_1 = 1, 2, 3 # Create tuple without round brackets.
- >>> print(tuple_1)
- (1, 2, 3)
- >>> type(tuple_1)
-
- >>> len(tuple_1)
- 3
- >>> tuple_2 = (1, 2, 3) # Create tuple with round brackets.
- >>> print(tuple_2)
- (1, 2, 3)
- >>> tuple_3 = 1, 2, 3, # Trailing comma is optional.
- >>> print(tuple_3)
- (1, 2, 3)
- >>> tuple_4 = (1, 2, 3,) # Trailing comma in round brackets is also optional.
- >>> print(tuple_4)
- (1, 2, 3)
-```
-A `tuple` with a single element must have the trailing comma (with or without round brackets):
-```shell
- >>> not_tuple = (2) # No trailing comma makes this not a tuple.
- >>> print(not_tuple)
- 2
- >>> type(not_tuple)
-
- >>> a_tuple = (2,) # Single element tuple. Requires trailing comma.
- >>> print(a_tuple)
- (2,)
- >>> type(a_tuple)
-
- >>> len(a_tuple)
- 1
- >>> also_tuple = 2, # Round brackets omitted. Requires trailing comma.
- >>> print(also_tuple)
- (2,)
- >>> type(also_tuple)
-
-```
-Round brackets are required in cases of ambiguity (if the tuple is part of a larger expression):
-
-> Note that it is actually the comma which makes a tuple, not the parentheses. The parentheses are optional, except in the empty tuple case, or when they are needed to avoid syntactic ambiguity. For example, `f(a, b, c)` is a function call with three arguments, while `f((a, b, c))` is a function call with a 3-tuple as the sole argument.
-```shell
- >>> print(1,2,3,4,) # Calls print with 4 arguments: 1, 2, 3, and 4
- 1 2 3 4
- >>> print((1,2,3,4,)) # Calls print with 1 argument: (1, 2, 3, 4,)
- (1, 2, 3, 4)
- >>> 1, 2, 3 == (1, 2, 3) # Equivalent to 1, 2, (3 == (1, 2, 3))
- (1, 2, False)
- >>> (1, 2, 3) == (1, 2, 3) # Use surrounding round brackets when ambiguous.
- True
-```
-A `tuple` can also be created with the `tuple` constructor:
-```shell
- >>> empty_tuple = tuple()
- >>> print(empty_tuple)
- ()
- >>> tuple_from_list = tuple([1,2,3,4])
- >>> print(tuple_from_list)
- (1, 2, 3, 4)
- >>> tuple_from_string = tuple("Hello campers!")
- >>> print(tuple_from_string)
- ('H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!')
- >>> a_tuple = 1, 2, 3
- >>> b_tuple = tuple(a_tuple) # If the constructor is called with a tuple for
- the iterable,
- >>> a_tuple is b_tuple # the tuple argument is returned.
- True
-```
-**Accessing elements of a `tuple`:**
-
-Elements of `tuples` are accessed and index the same way that `lists` are.
-```shell
- >>> my_tuple = 1, 2, 9, 16, 25
- >>> print(my_tuple)
- (1, 2, 9, 16, 25)
-```
-_Zero indexed_
-```shell
- >>> my_tuple[0]
- 1
- >>> my_tuple[1]
- 2
- >>> my_tuple[2]
- 9
-```
-_Wrap around indexing_
-```shell
- >>> my_tuple[-1]
- 25
- >>> my_tuple[-2]
- 16
-```
-**Packing and Unpacking:**
-
-The statement `t = 12345, 54321, 'hello!'` is an example of tuple packing: the values `12345`, `54321` and `'hello!'` are packed together in a tuple. The reverse operation is also possible:
-```shell
- >>> x, y, z = t
-```
-This is called, appropriately enough, sequence unpacking and works for any sequence on the right-hand side. Sequence unpacking requires that there are as many variables on the left side of the equals sign as there are elements in the sequence. Note that multiple assignment is really just a combination of tuple packing and sequence unpacking.
-```shell
- >>> t = 1, 2, 3 # Tuple packing.
- >>> print(t)
- (1, 2, 3)
- >>> a, b, c = t # Sequence unpacking.
- >>> print(a)
- 1
- >>> print(b)
- 2
- >>> print(c)
- 3
- >>> d, e, f = 4, 5, 6 # Multiple assignment combines packing and unpacking.
- >>> print(d)
- 4
- >>> print(e)
- 5
- >>> print(f)
- 6
- >>> a, b = 1, 2, 3 # Multiple assignment requires each variable (right)
- have a matching element (left).
- Traceback (most recent call last):
- File "", line 1, in
- ValueError: too many values to unpack (expected 2)
-```
-**Immutable:**
-
-`tuples` are immutable containers, guaranteeing **which** objects they contain will not change. It does **not** guarantee that the objects they contains will not change:
-```shell
- >>> a_list = []
- >>> a_tuple = (a_list,) # A tuple (immutable) with a list (mutable) element.
- >>> print(a_tuple)
- ([],)
-
- >>> a_list.append("Hello campers!")
- >>> print(a_tuple) # Element of the immutable is mutated.
- (['Hello campers!'],)
-```
-**Uses:**
-
-Functions can only return a single value, however, a heterogenuous `tuple` can be used to return multiple values from a function. One example is the built-in `enumerate` function that returns an iterable of heterogenuous `tuples`:
-```shell
- >>> greeting = ["Hello", "campers!"]
- >>> enumerator = enumerate(greeting)
- >>> enumerator.next()
- >>> enumerator.__next__()
- (0, 'Hello')
- >>> enumerator.__next__()
- (1, 'campers!')
-```
-### More Inforamtion:
-Python Docs - Tuples
diff --git a/client/src/guide/english/python/decorators/index.md b/client/src/guide/english/python/decorators/index.md
deleted file mode 100644
index ff1454ac65..0000000000
--- a/client/src/guide/english/python/decorators/index.md
+++ /dev/null
@@ -1,246 +0,0 @@
----
-title: Python Decorators
----
-Decorators essentially work as wrappers. They modify the behaviour of the code before and after a target function execution, without the need to modify the function itself, augmenting the original functionality, thus decorating it.
-
-Before going in detail about decorators, there are some concepts that should be clear. In Python, functions are objects and we can do a lot of useful stuff with them.
-
-> ### Assigning funtions to a variables:
-
- def greet(name):
- return "Hello "+name
- greet_someone = greet
- print greet_someone("John")
-
-> Output: Hello John
-
- Run code
-
-> ### Defining functions inside other functions:
-
- def greet(name):
- def get_message():
- return "Hello "
- result = get_message()+name
- return result
- print(greet("John"))
-
-> Output: Hello John
-
- Run code
-
-> ### Functions can also be passed as parameters to other functions:
-
- def greet(name):
- return "Hello " + name
- def call_func(func):
- other_name = "John"
- return func(other_name)
- print call_func(greet)
-
-> Output: Hello John
-
- Run code
-
-> ### Functions can return other functions:
->
-> In other words, functions generating other functions.
-
- def compose_greet_func():
- def get_message():
- return "Hello there!"
- return get_message
- greet = compose_greet_func()
- print(greet())
-
-Output: Hello there!
-
- Run code
-
-> ### Inner functions have access to the enclosing scope
->
-> More commonly known as a closure . A very powerful pattern that we will come across while building decorators. Another thing to note, Python only allows read access to the outer scope and not assignment. Notice how we modified the example above to read a "name" argument from the enclosing scope of the inner function and return the new function.
-
- def compose_greet_func(name):
- def get_message():
- return "Hello there "+name+"!"
- return get_message
- greet = compose_greet_func("John")
- print(greet())
-
-> Output: Hello there John!
-
- Run code
-
-## Composition of Decorators
-
-Function decorators are simply wrappers to existing functions. Putting the ideas mentioned above together, we can build a decorator. In this example let's consider a function that wraps the string output of another function by p tags.
-
- def get_text(name):
- return "lorem ipsum, {0} dolor sit amet".format(name)
-
- def p_decorate(func):
- def func_wrapper(name):
- return "``{0}`
`".format(func(name))
- return func_wrapper
-
- my_get_text = p_decorate(get_text)
- print (my_get_text("John"))
-
-> Output: ``lorem ipsum, John dolor sit amet`
`
-
- Run code
-
-That was our first decorator. A function that takes another function as an argument, generates a new function, augmenting the work of the original function, and returning the generated function so we can use it anywhere. To have `get_text` itself be decorated by `p_decorate`, we just have to assign get_text to the result of p_decorate.
-
- get_text = p_decorate(get_text)
- print (get_text("John"))
-
-> Output: lorem ipsum, John dolor sit amet
-
-Another thing to notice is that our decorated function takes a name argument. All what we had to do in the decorator is to let the wrapper of get_text pass that argument.
-
-> ### Python's Decorator Syntax
-
-Python makes creating and using decorators a bit cleaner and nicer for the programmer through some syntactic sugar To decorate get_text we don't have to get_text = p_decorator(get_text) There is a neat shortcut for that, which is to mention the name of the decorating function before the function to be decorated. The name of the decorator should be perpended with an @ symbol.
-
- def p_decorate(func):
- def func_wrapper(name):
- return "``{0}`
`".format(func(name))
- return func_wrapper
-
- @p_decorate
- def get_text(name):
- return "lorem ipsum, {0} dolor sit amet".format(name)
-
- print get_text("John")
-
-> Output: ``lorem ipsum, John dolor sit amet`
`
-
- Run code
-
-Now let's consider we wanted to decorate our get_text function by 2 other functions to wrap a div and strong tag around the string output.
-
- def p_decorate(func):
- def func_wrapper(name):
- return "``{0}`
`".format(func(name))
- return func_wrapper
-
- def strong_decorate(func):
- def func_wrapper(name):
- return "``{0}` `".format(func(name))
- return func_wrapper
-
- def div_decorate(func):
- def func_wrapper(name):
- return "``{0}`
`".format(func(name))
- return func_wrapper
-
-With the basic approach, decorating get_text would be along the lines of
-
- get_text = div_decorate(p_decorate(strong_decorate(get_text)))
-
-With Python's decorator syntax, same thing can be achieved with much more expressive power.
-
- @div_decorate
- @p_decorate
- @strong_decorate
- def get_text(name):
- return "lorem ipsum, {0} dolor sit amet".format(name)
-
- print (get_text("John"))
-
-> Output: ``lorem ipsum, John dolor sit amet`
Run code
-
-One important thing to notice here is that the order of setting our decorators matters. If the order was different in the example above, the output would have been different. ## Decorating Methods In Python, methods are functions that expect their first parameter to be a reference to the current object. We can build decorators for methods the same way, while taking self into consideration in the wrapper function.
-
- def p_decorate(func):
- def func_wrapper(self):
- return "``{0}`
`".format(func(self))
- return func_wrapper
-
- class Person(object):
- def __init__(self):
- self.name = "John"
- self.family = "Doe"
- @p_decorate
- def get_fullname(self):
- return self.name+" "+self.family
-
- my_person = Person()
- print (my_person.get_fullname())
-
-> Output: ``John Doe`
`
-
- Run code
-
-A much better approach would be to make our decorator useful for functions and methods alike. This can be done by putting *args and **kwargs as parameters for the wrapper, then it can accept any arbitrary number of arguments and keyword arguments.
-
- def p_decorate(func):
- def func_wrapper(*args, **kwargs):
- return "``{0}`
`".format(func(*args, **kwargs))
- return func_wrapper
-
- class Person(object):
- def __init__(self):
- self.name = "John"
- self.family = "Doe"
- @p_decorate
- def get_fullname(self):
- return self.name+" "+self.family
-
- my_person = Person()
- print (my_person.get_fullname())
-
-> Output : ``John Doe`
`
-
- Run code
-
-### Passing arguments to decorators Looking back at the example before the one above, you can notice how redundant the decorators in the example are. 3 decorators(div_decorate, p_decorate, strong_decorate) each with the same functionality but wrapping the string with different tags. We can definitely do much better than that. Why not have a more general implementation for one that takes the tag to wrap with as a string? Yes please!
-
- def tags(tag_name):
- def tags_decorator(func):
- def func_wrapper(name):
- return "<{0}>{1}".format(tag_name, func(name))
- return func_wrapper
- return tags_decorator
-
- @tags("p")
- def get_text(name):
- return "Hello "+name
-
- print (get_text("John"))
-
-> Output: ``Hello John`
`
-
- Run code
-
-It took a bit more work in this case. Decorators expect to receive a function as an argument, that is why we will have to build a function that takes those extra arguments and generate our decorator on the fly. In the example above tags, is our decorator generator. Debugging decorated functions At the end of the day decorators are just wrapping our functions, in case of debugging that can be problematic since the wrapper function does not carry the name, module and docstring of the original function. Based on the example above if we do:
-
- print (get_text.__name__)
-
-> Output: func_wrapper The output was expected to be get_text yet, the attributes __name__, __doc__, and __module__ of get_text got overridden by those of the wrapper(func_wrapper. Obviously we can re-set them within func_wrapper but Python provides a much nicer way. ### Functools to the rescue
-
- from functools import wraps
- def tags(tag_name):
- def tags_decorator(func):
- @wraps(func)
- def func_wrapper(name):
- return "`<{0}>`{1}``".format(tag_name, func(name))
- return func_wrapper
- return tags_decorator
-
- @tags("p")
- def get_text(name):
- """returns some text"""
- return "Hello "+name
-
- print (get_text.__name__) # get_text
- print (get_text.__doc__) # returns some text
- print (get_text.__module__) # __main__
-
- Run code
-
-You can notice from the output that the attributes of get_text are the correct ones now.
diff --git a/client/src/guide/english/python/defining-functions/index.md b/client/src/guide/english/python/defining-functions/index.md
deleted file mode 100644
index 533d6d8619..0000000000
--- a/client/src/guide/english/python/defining-functions/index.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: Python Defining Functions
----
-Python Docs
-
-We can create a function that writes the Fibonacci series to an arbitrary boundary:
-
- >>> def fib(n): # write Fibonacci series up to n
- ... """Print a Fibonacci series up to n."""
- ... a, b = 0, 1
- ... while a < n:
- ... print(a, end=' ')
- ... a, b = b, a+b
- ... print()
- ...
- >>> # Now call the function we just defined:
- ... fib(2000)
- 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
-
-The [`def`](https://docs.python.org/3/reference/compound_stmts.html#def) keyword introduces a function definition. It must be followed by the function name and the parenthesized list of formal parameters. The statements that form the body of the function start at the next line and must be indented.
-
-The first statement of the function body can optionally be a string literal; this string literal is the function's documentation string, or [docstring](https://www.python.org/dev/peps/pep-0257/) (More about docstrings can be found in the section Documentation Strings). Some tools use docstrings to automatically produce online or printed documentation or to let the user interactively browse through code. It's good practice to include docstrings in code that you write, so try to make a habit of it.
diff --git a/client/src/guide/english/python/functions/index.md b/client/src/guide/english/python/functions/index.md
deleted file mode 100644
index 2e9106abeb..0000000000
--- a/client/src/guide/english/python/functions/index.md
+++ /dev/null
@@ -1,131 +0,0 @@
----
-title: Functions
----
-## Functions
-
-A function allows you to define a reusable block of code that can be executed many times within your program.
-
-Functions allow you to create more modular and [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself) solutions to complex problems.
-
-While Python already provides many built-in functions such as `print()` and `len()`, you can also define your own functions to use within your projects.
-
-One of the great advantages of using functions in your code is that it reduces the overall number of lines of code in your project.
-
-### Syntax
-
-In Python, a function definition has the following features:
-
-1. The keyword `def`
-2. a function name
-3. paranthesis'()', and within paranthesis input parameters,although the input parameters are optional.
-4. a colon ':'
-5. some block of code to execute
-6. a return statement (optional)
-
-```python
-# a function with no parameters or returned values
-def sayHello():
- print("Hello!")
-
-sayHello() # calls the function, 'Hello!' is printed to the console
-
-# a function with a parameter
-def helloWithName(name):
- print("Hello " + name + "!")
-
-helloWithName("Ada") # calls the function, 'Hello Ada!' is printed to the console
-
-# a function with multiple parameters with a return statement
-def multiply(val1, val2):
- return val1 * val2
-
-multiply(3, 5) # prints 15 to the console
-```
-
-Functions are blocks of code that can be reused simply by calling the function. This enables simple, elegant code reuse without explicitly re-writing sections of code. This makes code both more readable, makes for easier debugging, and limits typing errors.
-
-Functions in Python are created using the `def` keyword, followed by a function name and function parameters inside parentheses.
-
-A function always returns a value,The `return` keyword is used by the function to return a value, if you don't want to return any value, the default value `None` will returned.
-
-The function name is used to call the function, passing the needed parameters inside parentheses.
-
-```python
-# this is a basic sum function
-def sum(a, b):
- return a + b
-
-result = sum(1, 2)
-# result = 3
-```
-
-You can define default values for the parameters, that way Python will interpretate that the value of that parameter is the default one if none is given.
-
-```python
-def sum(a, b=3):
- return a + b
-
-result = sum(1)
-# result = 4
-```
-
-You can pass the parameters in the order you want, using the name of the parameter.
-
-```python
-result = sum(b=2, a=2)
-# result = 4
-```
-
-However, it is not possible to pass a keyword argument before a non-keyword one
-
-```Python
-result = sum(3, b=2)
-#result = 5
-result2 = sum(b=2, 3)
-#Will raise SyntaxError
-```
-
-Functions are also Objects, so you can assign them to a variable, and use that variable like a function.
-
-```python
-s = sum
-result = s(1, 2)
-# result = 3
-```
-
-### Notes
-
-- If a function definition includes parameters, you must provide the same number of parameters when you call the function.
-
- ```python
- print(multiply(3)) # TypeError: multiply() takes exactly 2 arguments (0 given)
-
- print(multiply('a', 5)) # 'aaaaa' printed to the console
-
- print(multiply('a', 'b')) # TypeError: Python can't multiply two strings
- ```
-
-- The block of code that the function will run includes all statements indented within the function.
-
- ```python
- def myFunc():
- print('this will print')
- print('so will this')
-
- x = 7
- # the assignment of x is not a part of the function since it is not indented
- ```
-
-- Variables defined within a function only exist within the scope of that function.
-
- ```python
- def double(num):
- x = num * 2
- return x
-
- print(x) # error - x is not defined
- print(double(4)) # prints 8
- ```
--Python interprets the function block only when the function is called and not when the function is defined.So even if the function definition block contains some sort of error,the python interpretar will point that out only when the function is called.
-### More Information:
-- Python 3 Docs: Defining Functions
diff --git a/client/src/guide/english/python/if-elif-else-statements/index.md b/client/src/guide/english/python/if-elif-else-statements/index.md
deleted file mode 100644
index 7a954c856e..0000000000
--- a/client/src/guide/english/python/if-elif-else-statements/index.md
+++ /dev/null
@@ -1,96 +0,0 @@
----
-title: If Elif Else Statements
----
-
-## If Elif Else Statements
-
-The `if`/`elif`/`else` structure is a common way to control the flow of a program, allowing you to execute specific blocks of code depending on the value of some data. If the condition following the keyword `if` evaluates as `true`, the block of code will execute:
-Note that parenthesis is not used before and after the condition check as in other languages .
-```python
-if True:
- print('If block will execute!')
-```
-
-```python
-x = 5
-
-if x > 4:
- print("The condition was true!") #this statement executes
-```
-
-You can optionally add an `else` response that will execute if the condition is `false`:
-```python
-if not True:
- print('If statement will execute!')
-else:
- print('Else statement will execute!')
-```
-Or you can also see this example
-```python
-y = 3
-
-if y > 4:
- print("I won't print!") #this statement does not execute
-else:
- print("The condition wasn't true!") #this statement executes
-```
-
-*Note that there is no condition following the `else` keyword - it catches all situations where the condition was `false`*
-
-Multiple conditions can be checked by including one or more `elif` checks after your initial `if` statement but only one condition will execute:
-
-```python
-z = 7
-
-if z > 8:
- print("I won't print!") #this statement does not execute
-elif z > 5:
- print("I will!") #this statement will execute
-elif z > 6:
- print("I also won't print!") #this statement does not execute
-else:
- print("Neither will I!") #this statement does not execute
-```
-
-*Note only the first condition that evaluates as `true` will execute. Even though `z > 6` is `true`, the `if/elif/else` block terminates after the first true condition. This means that an `else` will only execute if none of the conditions were `true`.*
-
-We can also create nested if's for decision making. Before preceding please refer to the href='https://guide.freecodecamp.org/python/code-blocks-and-indentation' target='_blank' rel='nofollow'>indentation guide once before preceding.
-
-Let's take an example of finding a number which is even and also greater than '10`
-```
-python
-x = 34
-if x % 2 == 0: # this is how you create a comment and now, checking for even.
- if x > 10:
- print("This number is even and is greater than 10")
- else:
- print("This number is even, but not greater 10")
-else:
- print ("The number is not even. So point checking further.")
-```
-This was just a simple example for nested if's. Please feel free to explore more online.
-
-While the examples above are simple, you can create complex conditions using boolean comparisons and boolean operators .
-
-
-***Inline python if-else statement***
-
-We can also use if-else statements inline python functions
-The following example should check if the number is greater or equal than 50, if yes return True:
-
-```
-python
-x = 89
-is_greater = True if x >= 50 else False
-
-print(is_greater)
-```
-
-Output
-```
->
-True
->
-```
-
-
diff --git a/client/src/guide/english/python/import-statements/index.md b/client/src/guide/english/python/import-statements/index.md
deleted file mode 100644
index ee1b4c41ad..0000000000
--- a/client/src/guide/english/python/import-statements/index.md
+++ /dev/null
@@ -1,90 +0,0 @@
----
-title: Python Import Statements
----
-While learning programming and reading some resources you'd have come across this word 'abstraction' which simply means to reduce and reuse the code as much as possible.
-
-Functions and Modules facilitate abstraction. You create functions when you want to do something repeatedly within a file.
-
-Modules come into picture when you want to reuse a group of functions in different source files. Modules are also useful in structuring the program well.
-
-* Using Standard Libraries and other third party modules:
-* Structuring the program
-
-## Using Standard Libraries
-
-Example: You can read about the methods/functions of all the standard libraries in the official Python Docs in detail.
-
- import time
- for i in range(100):
- time.sleep(1) # Waits for 1 second and then executes the next command
- print(str(i) + ' seconds have passed') # prints the number of seconds passed after the program was started
-
- Run Code
-
- # To calculate the execution time of a part of program
- import time
- start = time.time()
- # code here
- end = time.time()
- print('Execution time:' , end-start)
-
- Run Code
-
- # Using math Module
- import math
- print(math.sqrt(100)) # prints 10
-
- Run Code
-
-## Using third party Modules
-
-Third party modules don't come bundled with python , but we have to install it externally using package managers like `pip` and `easy install`
-
- # To make http requests
- import requests
- rq = requests.get(target_url)
- print(rq.status_code)
-
-Find out more about python-requests module here
-
-## To structure programs
-
-We want to make a program that has various functions regarding prime numbers. So lets start. We will define all the functions in `prime_functions.py`
-
- # prime_functions.py
- from math import ceil, sqrt
- def isPrime(a):
- if a == 2:
- return True
- elif a % 2 == 0:
- return False
- else:
- for i in range(3,ceil(sqrt(a)) + 1,2):
- if a % i == 0:
- return False
- return True
-
- def print_n_primes(a):
- i = 0
- m = 2
- while True:
- if isPrime(m) ==True:
- print(m)
- i += 1
- m += 1
- if i == a:
- break
-
-Now we want to use the functions that we just created in `prime_functions.py` so we create a new file `playground.py` to use those functions.
-
-> _Please note that this program is far too simple to make two separate files, it is just to demonstrate. But when there are large complex programs, making different files is really useful._
-
- # playground.py
- import prime_functions
- print(prime_functions.isPrime(29)) # returns True
-
-## Sorting Imports
-
-Good practice is to sort `import` modules in three groups - standard library imports, related third-party imports, and local imports. Within each group it is sensible to sort alphabetically by module name. You can find [more information in PEP8](https://www.python.org/dev/peps/pep-0008/?#imports).
-
-One of the most important thing for Python language is legibility, and alphabetically sorting modules are quicker to read and search. Also it is easier to verify that something is imported, and avoid duplicated imports.
diff --git a/client/src/guide/english/python/index.md b/client/src/guide/english/python/index.md
deleted file mode 100644
index 1d103a0c6e..0000000000
--- a/client/src/guide/english/python/index.md
+++ /dev/null
@@ -1,168 +0,0 @@
----
-title: Python
----
-
-## What is Python?
-
-Python is a general purpose programming language which is dynamically typed, interpreted, and known for its easy readability with great design principles.
-
-To learn more about Python, check out these pages on python.org:
-
-What is Python?
-
-Python FAQ .
-
-## Python 2 or Python 3
-
-* The two versions are similar, with knowledge of one switching to writing code for the other is easy.
-* Python 2 or Python 3
- * Python 2.x will not be maintained past 2020.
- * 3.x is under active development. This means that all recent standard library improvements, for example, are only available by default in Python 3.x.
- * Python ecosystem has amassed a significant amount of quality software over the years. The downside of breaking backwards compatibility in 3.x is that some of that software (especially in-house software in companies) still doesn't work on 3.x yet.
-
-## Installation
-
-Most *nix based operating systems come with Python installed (usually Python 2, Python 3 in most recent ones). Replacing the system Python is not recommended and may cause problems. However, different versions of Python can be safely installed alongside the system Python. See Python Setup and Usage .
-
-Windows doesn't come with Python, the installer and instructions can be found here
-
-## Python Interpreter
-
-The Python interpreter is what is used to run Python scripts.
-
-If it is available and in Unix shell’s search path makes it possible to start it by typing the command `python` followed by the script name will invoke the interpreter and run the script.
-
-`hello_campers.py`
-
-```python
-print('Hello campers!')
-```
-
-From terminal:
-
- $ python hello_campers.py
- Hello campers!
-
-"When multiple versions of Python are installed, calling them by version is possible depending on the install configuration. In the Cloud9 ide custom environment, they can be invoked like:
-
- $ python --version
- Python 2.7.6
- $ python3 --version
- Python 3.4.3
- $ python3.5 --version
- Python 3.5.1
- $ python3.6 --version
- Python 3.6.2
- $ python3.7 --version
- Python 3.7.1
-
-## Python Interpreter Interactive Mode
-
-Interactive mode can be started by invoking the Python interpreter with the `-i` flag or without any arguments.
-
-Interactive mode has a prompt where Python commands can be entered and run:
-
- $ python3.5
- Python 3.5.1 (default, Dec 18 2015, 00:00:00)
- GCC 4.8.4 on linux
- Type "help", "copyright", "credits" or "license" for more information.
- >>> print("Hello campers!")
- Hello campers!
- >>> 1 + 2
- 3
- >>> exit()
- $
-
-## The Zen of Python
-
-Some of the principles that influenced the design of Python are included as an Easter egg and can be read by using the command inside Python interpreter interactive mode:
-
- >>> import this
- The Zen of Python, by Tim Peters
-
- Beautiful is better than ugly.
- Explicit is better than implicit.
- Simple is better than complex.
- Complex is better than complicated.
- Flat is better than nested.
- Sparse is better than dense.
- Readability counts.
- Special cases aren't special enough to break the rules.
- Although practicality beats purity.
- Errors should never pass silently.
- Unless explicitly silenced.
- In the face of ambiguity, refuse the temptation to guess.
- There should be one-- and preferably only one --obvious way to do it.
- Although that way may not be obvious at first unless you're Dutch.
- Now is better than never.
- Although never is often better than *right* now.
- If the implementation is hard to explain, it's a bad idea.
- If the implementation is easy to explain, it may be a good idea.
- Namespaces are one honking great idea -- let's do more of those!
-
-
-## Pros and Cons of Python
-### Pros
-1. Interactive language with a module support for almost all functionality.
-2. Open Source: So, you can contribute to the community, the functions you have developed for future use and to help others
-3. A lot of good interpreters and notebooks available for better experience like jupyter notebook.
-
-#### Cons
-1. Being open source, many different ways have developed over the year for same function. This sometimes, creates chaos for others to read someone else code.
-2. It is a slow language. So, a very bad language to use for developing general algorithms.
-
-## Documentation
-
-Python is well documented . These docs include tutorials, guides, references and meta information for language.
-
-Another important reference is the Python Enhancement Proposals (PEPs ). Included in the PEPs is a style guide for writing Python code, `PEP 8` .
-
-## Debugging
-
-Inline `print` statements can be used for simple debugging:
-
-> **... often the quickest way to debug a program is to add a few print statements to the source: the fast edit-test-debug cycle makes this simple approach very effective.**
->
-> --Executive Summary
-
-Python also includes more powerful tools for debugging, such as:
-
-* logging module, _logging_
-* debugging module, _pdb_
-
-Just note that these exist for now.
-
-## Hello World!
-
-Going back to the docs, we can read about the `print` function, a _built-in function_ of the Python Standard Library .
-
- print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
-
-The built-in functions are listed in alphabetical order. The name is followed by a parenthesized list of formal parameters with optional default values. Under that is a short description of the function and its parameters are given and occasionally an example.
-
-The `print` function in Python 3 replaces the `print` statement in Python 2.
-
- >>> print("Hello world!")
- Hello world!
-
-A function is called when the name of the function is followed by `()`. For the Hello world! example, the print function is called with a string as an argument for the first parameter. For the rest of the parameters the defaults are used.
-
-The argument that we called the `print` function with is a `str` object or _string_, one of Python's _built-in types_ .
-Also the most important thing about python is that you don't have to specify the data type while declaring a variable, python's compiler
-will do that itself based on the type of value assigned.
-
-The `objects` parameter is prefixed with a `*` which indicates that the function will take an arbitrary number of arguments for that parameter.
-
-## Want to learn more?
-
-Free Code Camp has some great resources. The web is a big place, there's plenty more to explore:
-* Python Practice Book: http://anandology.com/python-practice-book/index.html
-* Think Python: http://greenteapress.com/thinkpython/html/index.html
-* Practical Business Python: http://pbpython.com/
-* Another course: https://realpython.com/?utm_source=fsp&utm_medium=promo&utm_campaign=bestresources
-* General: https://www.fullstackpython.com/
-* Learn the Basics: https://www.codecademy.com/learn/learn-python
-* Computer science using Python: https://www.edx.org/course/introduction-computer-science-mitx-6-00-1x-11?ref=hackernoon#!
-* List of more resources for learning python: https://github.com/vinta/awesome-python
-* Interactive Python: http://interactivepython.org/runestone/static/thinkcspy/index.html
-* Developer's Guide to Python: https://devguide.python.org/
diff --git a/client/src/guide/english/python/input-functions/index.md b/client/src/guide/english/python/input-functions/index.md
deleted file mode 100644
index c6869456a1..0000000000
--- a/client/src/guide/english/python/input-functions/index.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: Python Input Function
----
-Many a time, in a program we need some input from the user. Taking inputs from the user makes the program feel interactive. In Python 3, to take input from the user we have a function `input()`. If the input function is called, the program flow will be stopped until the user has given an input and has ended the input with the return key. Let's see some examples:
-
-1. When we just want to take the input:
-
- # This will just give a prompt without any message
- inp = input()
-
- Run Code
-
-1. To give a prompt with a message:
-
- prompt_with_message = input('')
- # _
- # The '_' in the output is the prompt
-
- Run Code
-
-3\. When we want to take an integer input:
-
- number = int(input('Please enter a number: '))
-
- Run Code
-
-If you enter a non integer value then Python will throw an error `ValueError`. **So whenever you use this, please make sure that you catch it too.** Otherwise, your program will stop unexpectedly after the prompt.
-
- number = int(input('Please enter a number: '))
- # Please enter a number: as
- # Enter a string and it will throw this error
- # ValueError: invalid literal for int() with base 10 'as'
-
-4\. When we want a string input:
-
- string = str(input('Please enter a string: '))
-
- Run Code
-
-Though, inputs are stored by default as a string. Using the `str()` function makes it clear to the code-reader that the input is going to be a 'string'. It is a good practice to mention what type of input will be taken beforehand.
-
-Official Docs
diff --git a/client/src/guide/english/python/lists/index.md b/client/src/guide/english/python/lists/index.md
deleted file mode 100644
index 875e1f6071..0000000000
--- a/client/src/guide/english/python/lists/index.md
+++ /dev/null
@@ -1,112 +0,0 @@
----
-title: Lists
----
-**TODO: `list` basic info**
-
-[Python Docs - Lists](https://docs.python.org/3/library/stdtypes.html#lists)
-
-**Creation:**
-
-An empty `list` is created using a pair of square brackets:
-```shell
->>> empty_list = []
->>> type(empty_list)
-
->>> len(empty_list)
-0
-```
-
-A `list` can be created with elements by enclosing a comma separated list of elements with square brackets. Lists allow for the elements to be of different types (heterogeneous) but are most commonly of a single type (homogeneous):
-```shell
->>> homogeneous_list = [1, 1, 2, 3, 5, 8]
->>> type(homogeneous_list)
-
->>> print(homogeneous_list)
-[1, 1, 2, 3, 5, 8]
->>> len(homogeneous_list)
-6
->>> heterogeneous_list = [1, "Hello Campers!"]
->>> print(heterogeneous_list)
-[1, "Hello Campers!"]
->>> len(heterogeneous_list)
-2
-```
-The `list` constructor can also be used to create a `list`:
-```shell
->>> empty_list = list() # Creates an empty list
->>> print(empty_list)
-[]
->>> list_from_iterable = list("Hello campers!") # Creates a list from an iterable.
->>> print(list_from_iterable)
-['H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!']
-```
-
-**Accessing elements of a `list`:**
-```shell
->>> my_list = [1, 2, 9, 16, 25]
->>> print(my_list)
-[1, 2, 9, 16, 25]
-```
-
-_Zero indexed_
-```shell
->>> my_list[0]
-1
->>> my_list[1]
-2
->>> my_list[2]
-9
-```
-_Wrap around indexing_
-```shell
->>> my_list[-1]
-25
->>> my_list[-2]
-16
-```
-_Unpacking lists for python-3_
-```shell
->>> print(*my_list)
-1 2 9 16 25
-```
-
-**Mutable:**
-
-`lists` are mutable containers. Mutable containers are containers that allow changes to which objects are contained by the container. **TODO: ADD MORE?**
-
-_Re-arranging elements in a list_
-
-Elements from a `list` may be extracted and re-arranged using another `list` as index.
-```shell
->>> my_list = [1, 2, 9, 16, 25, 34, 53, 21]
->>> my_index = [5, 2, 0]
->>> my_new_list = [my_list[i] for i in my_index]
->>> print(my_new_list)
-[34, 9, 1]
-```
-
-**TODO: Which of these should be discussed here:**
-
-[Python Docs - More on Lists](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)
-
-* `list.append(x)` Add an item to the end of the list. Equivalent to a[len(a):] = [x].
-
-* `list.extend(L)` Extend the list by appending all the items in the given list. Equivalent to a[len(a):] = L.
-
-* `list.insert(i, x)` Insert an item at a given position. The first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x).
-
-* `list.remove(x)` Remove the first item from the list whose value is x. It is an error if there is no such item.
-
-* `list.pop([i])` Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list. (The square brackets around the i in the method signature denote that the parameter is optional, not that you should type square brackets at that position. You will see this notation frequently in the Python Library Reference.)
-
-* `list.clear()` Remove all items from the list. Equivalent to del a[:].
-
-* `list.index(x)` Return the index in the list of the first item whose value is x. It is an error if there is no such item.
-
-* `list.count(x)` Return the number of times x appears in the list.
-
-* `list.sort(key=None, reverse=False)` Sort the items of the list in place (the arguments can be used for sort customization, see sorted() for their explanation).
-
-* `list.reverse()` Reverse the elements of the list in place.
-
-* `list.copy()` Return a shallow copy of the list. Equivalent to a[:].
diff --git a/client/src/guide/english/python/lists/list-sort-method/index.md b/client/src/guide/english/python/lists/list-sort-method/index.md
deleted file mode 100644
index 6cdb4ae055..0000000000
--- a/client/src/guide/english/python/lists/list-sort-method/index.md
+++ /dev/null
@@ -1,116 +0,0 @@
----
-title: List Sort Method
----
-## List Sort Method
-
-Python lists have a built-in ```sort()``` method that modifies the list in-place and a ```sorted()``` built-in function that builds a new sorted list from an iterable.
-
-list.sort(key=…, reverse=[True/False])
-
-### Parameters
-
-There are two optional parameters to this method
-key - The input value for the key parameter should be a function that takes a single argument and returns a value used for comparisons to sort the items in the list
-reverse=[value]
-value=True : Sorts the items in the list in descending order
-value=False : Sorts the items in the list in ascending order. This is considered the default value.
-reverse parameter
-
-```py
-a = [4, 2, 5, 3, 1]
-
-#Sorts the list in descending order
-a.sort(reverse=True)
-
-print a # prints [5, 4, 3, 2, 1]
-```
-
-If you want to sort the list based on your own function, then use the key parameter.
-here . In brief, sort function uses TimSort algorithm, which according to Python Developers, is :-
->an adaptive, stable, natural mergesort, modestly called
-timsort (hey, I earned it ). It has supernatural performance on many
-kinds of partially ordered arrays (less than lg(N!) comparisons needed, and
-as few as N-1), yet as fast as Python's previous highly tuned samplesort
-hybrid on random arrays.
-
-#### sort() Parameters
-By default, sort() doesn't require any extra parameters. However, it has two optional parameters:
- * reverse - If true, the sorted list is reversed (or sorted in Descending order)
- * key - function that serves as a key for the sort comparison
-
-#### More Information:
-More information about ```sort()``` can be found here
-
-More information about sort() and sorted() can be found here
-
-More information about sort() and sorted() can be found here .
\ No newline at end of file
diff --git a/client/src/guide/english/python/python-f-strings/index.md b/client/src/guide/english/python/python-f-strings/index.md
deleted file mode 100644
index fced5b6a7f..0000000000
--- a/client/src/guide/english/python/python-f-strings/index.md
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title: Python f-strings
----
-# f-strings in Python
-In Python version 3.6, a new method of formatting strings was implemented. The new method is called Literal string interpolation (though commonly referred to as an f-string).
-
-The use of f-string allows the programmer to dynamically insert a variable into a string in a clean and concise manner. In addition to inserting variables into a string this feature also also provides the ability for a programmer to evaluate expressions, join the contents of collection, and even invoke functions within the f-string.
-
-To perform these dynamic behaviours within an f-string we wrap them inside curly brackets within the string, and prepend a lower case f to the beginning of the string (before the opening quote.
-
-### Examples
-1. Dynamically inserting a variable into a string at runtime:
- ```python
- name = 'Jon Snow'
- greeting = f'Hello! {name}'
- print(greeting)
- ```
-
-2. Evaluate an expression in a string:
- ```python
- val1 = 2
- val2 = 3
- expr = f'The sum of {val1} + {val2} is {val1 + val2}'
- print(expr)
- ```
-3. Calling a function and inserting output within a string:
- ```python
- def sum(*args):
- result = 0
- for arg in args:
- result += arg
- return result
-
- func = f'The sum of 3 + 5 is {sum(3, 5)}'
- print(func)
- ```
- 4. Joining the contents of a collection within a string:
-
- ```python
- fruits = ['Apple', 'Banana', 'Pear']
-
- list_str = f'List of fruits: {", ".join(fruits)}'
- print(list_str)
- ```
-### Sources
-https://www.python.org/dev/peps/pep-0498/
diff --git a/client/src/guide/english/python/range-function/index.md b/client/src/guide/english/python/range-function/index.md
deleted file mode 100644
index 174078d168..0000000000
--- a/client/src/guide/english/python/range-function/index.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: Range Method
----
-# Range Function
-If you do need to iterate over a sequence of numbers, the built-in function range() comes in handy. It generates arithmetic progressions:
-
-#### Example Usage
- ```py
-for i in range(5):
- print(i)
- ```
-
- #### Output
- ```
-0
-1
-2
-3
-4
- ```
-
diff --git a/client/src/guide/english/python/setting-up-python-web-framework-django-and-flask/index.md b/client/src/guide/english/python/setting-up-python-web-framework-django-and-flask/index.md
deleted file mode 100644
index 0251ddcce9..0000000000
--- a/client/src/guide/english/python/setting-up-python-web-framework-django-and-flask/index.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: Setting Up Python Web Framework Django and Flask
----
-In this article, we shall be discussing how to install Django and Flask - two popular web frameworks written in Python.
-
-Perhaps you are already familiar with the widespread usage and community support for Python; in web-development. You might as well be aware as to what a web framework is; and the options available for Python.
-
-In case these assumptions are untrue, you might want to take a look at this wiki article . If you are all caught up, let's go ahread with setting up Python web frameworks in your local development machine.
-
-But it would be unfair if we completely ignore the Python 2 vs Python 3 debate.
-
-## Virtual environment
-
-Before we install Django we will get you to install an extremely useful tool to help keep your coding environment tidy on your computer. It's possible to skip this step, but it's highly recommended. Starting with the best possible setup will save you a lot of trouble in the future!
-
-So, let's create a virtual environment (also called a virtualenv). Virtualenv will isolate your Python/Django setup on a per-project basis. This means that any changes you make to one website won't affect any others you're also developing. Neat, right?
-
-For more information on virtual environments see the relevent section here .
-
-## Wrapping Up
-
-If you have already installed `pip` then simply:
-```
-$ pip install django
-```
-After installation it's complete we can create a new project:
-```
-$ django-admin startproject myproject
-$ cd myproject
-$ python manage.py runserver
-```
-Go to `http://localhost:8000`! :rocket:
-
-We have successfully installed the web-framework of our need. However, it's not yet complete. Most web applications are content and data driven - so we need a data storage. Or, a Database, if you will.
-
-In next article, we would be discussing how to install PostgreSQL and use it with our Python web application.
-
-A point to ponder - we have been using `pip` heavily, but we have barely said anything about it. Well, for now, it's just a package manager like `npm`. It has some differences with `npm`; but, you don't need to worry about that now. If you are interested, do check out the official `pip` documentation .
-
-_If you have suggestions or questions, come join us on gitter _.
diff --git a/client/src/guide/english/python/using-python-for-web-development/index.md b/client/src/guide/english/python/using-python-for-web-development/index.md
deleted file mode 100644
index 6f1cd7a8e8..0000000000
--- a/client/src/guide/english/python/using-python-for-web-development/index.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Using Python for Web Development
----
-Python is known for its beautiful syntax and ease of readability. This scripting language can be used for some quick-and-dirty prototyping of your idea of a web-app. It can also be used to build scalable and maintainable large web applications.
-
-#### Most Popular Python Web Frameworks:
-
-* Django
-* Flask
-* Bottle
-* Pyramid
-* Web2py
-
-So let's get started with some web frameworks and learn how they help build web app on-hands. But before that, we would need to set-up the development environment by completing [installation of web frameworks in Python](https://guide.freecodecamp.org/python/setting-up-python-web-framework-django-and-flask).
diff --git a/client/src/guide/english/python/web-frameworks-and-what-they-do-for-you/bottle/index.md b/client/src/guide/english/python/web-frameworks-and-what-they-do-for-you/bottle/index.md
deleted file mode 100644
index 84af42d1f6..0000000000
--- a/client/src/guide/english/python/web-frameworks-and-what-they-do-for-you/bottle/index.md
+++ /dev/null
@@ -1,83 +0,0 @@
----
-title: Bottle
----
-
-
-The bottle framework allows us to very quickly and easily get up and running with a basic web application.
-
-The following details how to write and run a simple greeting web app where we can enter our name in a form, press submit and get back a greeting.
-
-
-1. Use `pip` to install the bottle package.
- ```
- pip install bottle
- ```
-
-2. Create a `html` file to be served when loading the site. For example `index.html`.
-
- Let's add a heading and a basic form to this page.
-
- ```html
- Say Hello
-
-
- ```
-
-3. Create a new python file, example `main.py`.
-
-4. In the first line of the file we need to import get, request, and run functions from the bottle module.
- ```python
- from bottle import get, request, run
- ```
-
-5. Now we define our function to serve our html file when the root page is accessed.
-
- Here we use the `@get` decorator, which specifies this function should respond to `HTTP GET` requests and pass in `'/'` as the path that the function will be invoked by.
-
- Next we define then `index()` function using the `def` keyword.
-
- To read and return the html file we created in step 2, we use what is called a context manager. This handles opening and closing the file for us, allowing us to read the files and contents and return them with the `return` statement.
-
- ```python
- @get('/')
- def index():
- with open('./index.html') as f:
- return f.read()
- ```
-
-6. To get the site to run and listen for requests we need to add a call to the bottle frameworks `run` function as follows.
-
- Here we pass in the host that the web application will run on, in this case `localhost`, and the port that it should listen for HTTP requests.
-
-
-7. Run the application and load it up in your browser http://localhost:8080/, you should see the html file we created eariler rendered in the browser.
-
- If we enter our name and press submit now we will get a `HTTP 404` error though as we have not yet defined the function to respond to this request.
-
-
- ```python
- run(host='localhost', port=8080)
- ```
-
-
-8. Back in our `main.py` file we now need to define the function to respond when sumbitting our form.
-
- Again we use the `@get` decorator here, however this time we pass in `'/.hello'` as the path. You may notice that this is the same path that we defined in the action attribute of our form in `index.html`.
-
- Next we retrieve the `name` value from the url, when submitting the form the form data is url encoded like this http://localhost:8080/hello?name=Jon+Snow
-
- Finally we return our greeting, appending the name entered in our form.
-
- ```python
- @get('/hello')
- def hello():
- name = request.query['name']
- return f'Hello {name}'
- ```
-
-### Sources
-https://bottlepy.org/docs/dev/
diff --git a/client/src/guide/english/python/web-frameworks-and-what-they-do-for-you/index.md b/client/src/guide/english/python/web-frameworks-and-what-they-do-for-you/index.md
deleted file mode 100644
index 11f0cf2d4f..0000000000
--- a/client/src/guide/english/python/web-frameworks-and-what-they-do-for-you/index.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: Python Web Frameworks and What They Do
----
-We have used the word `framework` quite liberally in the earlier articles. You may or may not be familiar with what that is. Nonetheless, we will discuss what Python Web Frameworks do for you, out-of-the-box.
-
-Web Frameworks, to put it informally, do for you what would be doing _repeatedly_ if you were to build a lot of websites with different functionalities.
-
-Let's take an extremely crude example and attempt to make a simple analogy. Say, you go to dinner, and it's a fancy restaurant. It could be any type of restaurant - Italian, Mexican, Indian, Korean, Pan-Asian.
-
-Try to think of the common things that happen in a restaurant when a customer walks in. A valet might take your car and validate parking. You might be asked at the reception if you had booking; and how many of your friends are with you. You would probably be shown to your table, or asked to wait - depending on the crowd inside.
-
-Once seated, you would be asked if you wanted regular or bottled water. Then someone would ask if you prefer drinks. You might order some starters, followed by main-course; and finally, some dessert. You have to pay the bill.
-
-I understand if you would like to take a moment to take a trip down memory lane, enjoying a delicious toothsome. Once you are done, you need to put yourself in the position of the person who is running the business.
-
-If you notice, there are some activities that you are doing repeatedly for every customer. And based on the type of restaurant and time of day, there are some things that would be different. For instance, the menu and food prices.
-
-Say, you are running the business; you would also need to handle other aspects of this business that a customer would be oblivious to. For instance; the salary of the staff, managing books, paying rent and tax on the property, printing new menu cards etc.
-
-You are wondering where this conversation is headed. Calm down! We are getting back to Python Web Development ASAP.
-
-A Web Framework does these repeating activities for you - that you would do when you build a web application using only a programming language and some networking libraries. Like Request Handling, URL Routing, Template Compilation, Context Setting, CSRF Protection, Logging, Database Interaction via ORM, Authentication, Response Rendering etc.
-
-You are probably wondering what, then, is left for the developer to do? Based on the application, you have to use the framework APIs and write your application-specific logic.
-
-Your code will fill the gaps _intentionally_ left in the framework code - and combining your code with the framework; your web application would have life breathed into it!
-
-Two of the most popular web frameworks in Python are Django and Flask. Django is probably the most-used Python framework out there. Django helps you to build websites where you're interacting with both your client (user) and your database, often simultaneously. Flask is a micro-framework, which can also do much of the tasks that Django does, but by using extensions made by the community. Other frameworks worth mentioning are Pylons and Tornado.
-
-### Django
-
-Django (/ˈdʒæŋɡoʊ/ JANG-goh) is a free and open-source web framework, written in Python, which follows the model-view-template (MVT) architectural pattern. It is maintained by the Django Software Foundation (DSF), an independent organization established as a 501(c)(3) non-profit.
-
-Django's primary goal is to ease the creation of complex, database-driven websites. Django emphasizes reusability and "pluggability" of components, rapid development, and the principle of don't repeat yourself. Python is used throughout, even for settings files and data models. Django also provides an optional administrative create, read, update and delete interface that is generated dynamically through introspection and configured via admin models.
-
-Some well-known sites that use Django include the Public Broadcasting Service, Instagram, Mozilla, The Washington Times, Disqus, Bitbucket, and Nextdoor. It was used on Pinterest, but later the site moved to a framework built over Flask.
-
-
-### Flask
-
-Flask is a lightweight WSGI web application and a micro framework which it's classified as a microframework because it does not require particular tools or libraries. It is designed to make getting started quick and easy, with the ability to scale up to complex applications. However, Flask supports extensions that can add application features as if they were implemented in Flask itself. Extensions exist for object-relational mappers, form validation, upload handling, various open authentication technologies and several common framework related tools. Extensions are updated far more regularly than the core Flask program. Flask is commonly used with MongoDB (NOSQL DataBase) which allows it more control over databases and history.
-
-It began as a simple wrapper around Werkzeug and Jinja and has become one of the most popular Python web application frameworks.
-
-Flask offers suggestions, but doesn't enforce any dependencies or project layout. It is up to the developer to choose the tools and libraries they want to use. There are many extensions provided by the community that make adding new functionality easy.
-
-Flask was made in 2004 by an international group of Pythonists called 'Pocoo', as an April Fools joke which was later made into a 'real' thing. According to Wikpedia, it was the most used Python web framework on Github. It is a free and open-source micro-framework written in Python ([view on GitHub](https://github.com/freeCodeCamp/guide/tree/master/src/pages/javascript)). As the Wikipedia states,
-
-Flask is classified as a microframework because it does not require particular tools or libraries. It has no database abstraction layer, form validation, or any other components where pre-existing third-party libraries provide common functions.
-
-Flask is very much a 'batteries not included' framework, compared to something like Django. This means you need to install modules such as user authentication, forms, and other things yourself. It's not to say that Flask isn't made for those things, simply that they aren't included and those modules are made by the community. Flask also has extensive, detailed documentation available at http://flask.pocoo.org/docs/. It provides simplicity and more control over smaller things. You won't have functionality that isn't being used, as you can choose what is added and what isn't.
-
-Sites that use Flask include Pinterest! (which moved from Django), Twilio's private API's (they even made an extension called Flask-RESTful for API's), and Netflix (which uses ScriptFlask, a tool based on Flask)
-
-### Bottle
-
-Bottle is a Python micro framework that allows users to quickly get up and running with a Python web application. It is a lot more lightweight than something more fully featured such as Django, and has no third-party dependencies relying only on the Python standard library.
-
-This makes it perfect for small web applications where some of the more advanced features of Django such as authentication, or database access would not be required.
\ No newline at end of file
diff --git a/client/src/guide/english/python/what-is-python-used-for/index.md b/client/src/guide/english/python/what-is-python-used-for/index.md
deleted file mode 100644
index f5d3e685bb..0000000000
--- a/client/src/guide/english/python/what-is-python-used-for/index.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-title: What Is Python Used for
----
-
-## What Is Python Used for
-
-Python can easily be used for small, large, online and offline projects. The best options for utilizing Python are web development, simple scripting and data analysis.
-Below are a few examples of what Python will let you do:
-
-##### Web Development:
-You can use Python to create web applications on many levels of complexity. There are many excellent Python web frameworks, including Pyramid, Django and Flask, to name
-a few.
-
-##### Data Analysis:
-
-Python is the leading language of choice for many data scientists. Python has grown in popularity within the field due to the availability of many excellent libraries
-focused on data science (of which NumPy and Pandas are two of the most well-known) and data visualisation (like Matplotlib and Seaborn). Pyton really made Data crunching
-fun with all its numerous available libraries. Ipython with JupyterLab is another form of Python that improves the usage of Python in the field of data science.
-
-##### Automation:
-Python is a very flexible language that can be used to automate boring or repetitive tasks. System administrators often use it by writing scripts which can be easily
-executed from the terminal. Python can also be used to create bots which automate some of our daily tasks.
-
-##### Artificial Intelligence:
-Python is also used extensively in the growing field of Artificial Intelligence (AI). Google selected Python to be one of the first well-supported programming languages
-for training and interacting with models using Tensorflow.
-
-#### Mobile app development
-Mobile apps and games can be created with python using Kivy, Pygame and PyQt.
-
-#### Security And Networking:
-Python is used to build Networking tools and security-tools that are widely used.Python's remote automation is the most secured, fast and efficient for cloud-testing
-of frameworks, that's why professional developers use python for making most secured frameworks and for socket-programmings.
-
-##### Machine Learning, Deep Learning
-Python is one of the best languages suited for machine learning, deep learning and data analytics with a stronghold in all of them.
-
-There are specialized languages best suited for various role such as R and MATLAB but when it comes to overlapping fields of applications python wins hands down due to
-its flexibility and rapid prototyping and availability of libraries.
-
-#### Telegram Bots Development
-You can use Python and some Python-libraries for developing your own Telegram Bots
-
-#### Data Gathering by crawling and scraping
-Python could also be used by parse pages source codes and retrieve its data. Using some python modules, such as: Scrapy and also (for some reasons and pages which uses javascript) Selenium, should do the trick!
-
-#### More Information:
-Here's a link to a section of the official Python website describing its various applications.
-
-#### Python is generally used for
-
-* Web & Internet Development
-* Educational Advancment
-* Scientific Studies/Computing
-* Desktop development
-* Numeric Computing
-* Software development
-* Business Application development
-* Machine Learning
-* IOT
-* Game Development
-* Rapid Prototyping
-* Browser Automation
-* Data analysis
-* Scraping data from websites
-* Image Processing
-## Why python has got such a wide range of usage?
-* Python has got many packages to work with, some ranging for aerospace research to mathematics.
-*Secondly for choosing to be a part of the open source community.
- Yes! Python is Open-source.
- * For it's simple and elegant syntax.
- *There are many built-in functions because of which python codes are small in size than compared with other codes which are same in context but written in different language.
- * Python also supports Object-Oriented programming fashion.
- Thus these things add on for the popularity of Python in various communities.
-
-#### Some articles covering the usability of python
-
-* 10 Major Uses of Python
-* Applications for Python
-* Where is the Python Language Used?
-* What is Python used for?
-
-
-The official package index for python is here .
-
-[training and interacting with models]: https://stackoverflow.com/questions/35677724/tensorflow-why-was-python-the-chosen-language
diff --git a/client/src/guide/english/react-native/basic-commands/index.md b/client/src/guide/english/react-native/basic-commands/index.md
deleted file mode 100644
index a049ae4c40..0000000000
--- a/client/src/guide/english/react-native/basic-commands/index.md
+++ /dev/null
@@ -1,74 +0,0 @@
----
-title: Basic Commands
----
-## Basic Commands
-
-Here you will find a list of basic commands to start developing iOS and Android apps using React Native. If you don't have it installed yet, is highly recommended that you follow the [official guide](https://facebook.github.io/react-native/docs/getting-started.html).
-
-
-### Starting a new project
-
-There are different ways you can bootstrap a react native application. You can use **Expo** or `create-react-native-app`(which in turns uses Expo-Cli) to start your new project, but with this method you are in more control of what happend in your projecto and can communicate, tweak and write your own modules with native libraries for iOS and Android mobile platform.
-```
-react-native init [PROJECT-NAME]
-cd [PROJECT-NAME]
-```
-
-
-
-**Run app in Android emulator**
-
-This command is self explanatory and as it says it will start the Android emulator and install the app you just created. You need to be in the root of the project to run this command.
-```
-react-native run-android
-```
-
-
-**Run app in iOS emulator**
-
-This command do exactly the same as `react-native run-android` but instead of the Android emulator, it opens the iPhone simulator.
-```
-react-native run-ios
-```
-
-
-**Link dependencies to native projects**
-
-Some libraries have dependencies that need to be linked in the native code generated for React Native. If something doesn't work after you installed a new library, maybe is because you skip this step.
-```
-react-native link [LIBRARY-NAME]
-```
-
-
-**Clear bundle**
-
-If something don't run as expected, maybe you need to clear and create a new bundle with this command.
-```
-watchman watch-del-all
-```
-
-
-**Support decorators**
-
-JSX doesn't support decorators by default so you need to install the **Babel** plugin to make it work.
-```
-npm install babel-plugin-transform-decorators-legacy --save
-npm install babel-plugin-transform-class-properties --save
-```
-
-
-### Export APK to run in device
-With the following commands you will have and unsigned apk so you can install and share with your colleagues for testing purposes. Just remember that this apk is not ready to upload to the App Store or production.
-You will find your fresh apk in *android/app/build/outputs/apk/app-debug.apk*
-
-**1. Bundle debug build**
-```
-react-native bundle --dev false --platform android --entry-file index.android.js --bundle-output ./android/app/build/intermediates/assets/debug/index.android.bundle --assets-dest ./android/app/build/intermediates/res/merged/debug
-```
-
-
-**2. Create debug build**
-```
-cd android
-./gradlew assembleDebug
-```
diff --git a/client/src/guide/english/react-native/functional-vs-class-components/index.md b/client/src/guide/english/react-native/functional-vs-class-components/index.md
deleted file mode 100644
index 9a783ce22c..0000000000
--- a/client/src/guide/english/react-native/functional-vs-class-components/index.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: Functional vs Class Components
----
-## React Native - Functional vs Class Components
-
-In React Native, there are two main types of components that make up an application - *functional components* and *class components*. These are structured the same as they would be in a regular React app for the web.
-
-### Class Components
-
-Class components are JavaScript ES2015 classes that extend a base class from React called `Component`.
-
-```js
-class App extends Component {
- render () {
- return (
- Hello World!
- )
- }
-}
-```
-
-This gives the class `App` access to the React lifecycle methods like `render` as well state/props functionality from the parent.
-
-### Functional Components
-
-Functional components are simpler. They don't manage their own state or have access to the lifecycle methods provided by React Native. They are literally plain old JavaScript functions. They are also known as stateless components.
-
-```js
-const PageOne = () => {
- return (
- Page One
- );
-}
-```
-
-### Summary
-
-Class components are used as container components to handle state management and wrap child components. Functional components generally are just used for display purposes - these components call functions from parent components to handle user interactions or state updates.
diff --git a/client/src/guide/english/react-native/index.md b/client/src/guide/english/react-native/index.md
deleted file mode 100644
index 4aaa65f743..0000000000
--- a/client/src/guide/english/react-native/index.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: React Native
----
-## React Native
-
-React Native is a cross-platform framework for building mobile applications that can run outside of the browser — most commonly iOS and Android applications
-
-It can be used to build applications on Windows devices, desktop OS’s, and Apple TV apps as well but this guide will only be covering it’s most common purpose — Android and iOS applications.
-
-**Table of Contents**
-- [What is React Native?](#what-is-react-native)
-- [Reasons to choose React Native](#reasons-to-choose-react-native)
-- [How to Get Started with React Native](#how-to-get-started-with-react-native)
-
-### What is React Native
-
-React Native falls in-between native and hybrid applications on the mobile app spectrum. The user interface you create is entirely native and the overall application performance is nearly as good as writing a native app. It also gives you the flexibility to embed web views (webpages) or native code (Java/Kotlin for Android, Objective C/Swift for iOS) inside your applications wherever you want.
-
-It follows the same pattern as React where the views (what you see on the screen) are rendered from the JavaScript files. The difference is that it supplies its own API for handling native mobile views vs the DOM on the web. If you are confused about how this works, follow this guide on freeCodeCamp and it will take you step by step through these concepts.
-
-### Reasons to choose React Native
-1. **Code reusability** — It uses one code based that is shared between both platforms.
-1. **Reuse web tools and skills** — Reuse JavaScript knowledge, tools and utilities like `axios`, Redux, and other libraries that don’t require the DOM from the web.
-1. **Optimized for developer productivity** — Comes with features like hot/live module reloading and chrome developer tools for debugging out of the box!
-1. **Performance** — Performs better than hybrid application frameworks like Ionic and Cordova since it is not using web views.
-1. **Corporate backing** — Lot’s of companies support and contribute to React Native including Walmart, Airbnb, Wix, and, of course, Facebook.
-1. **Community** — React Native has a large (and growing) community with over 1500 contributors to the core project and thousands more who contribute to various libraries.
-1. **Better user experience** — React Native uses the JavaScript code to render native components from your phone's OS. In other words, the application's user interface (UI) is entirely native!
-1. **Cross-Platform** - Great way to prototype and save time while building either a universal user interfeace or platform specific mobile application that can run on both iOS and Android devices.
-
-### How to Get Started with React Native
-
-There are two quick easy ways to get started with React Native. Depending on your situation, one can be a better option for you.
-
-1. [Create React Native App](https://www.npmjs.com/package/create-react-native-app)- Similar to Create React App it get up in running using the terminal.
-1. [Expo](https://expo.io) - Best for prototyping an app or if it is earlier stage. Using Expo you can even create an quick app using drag and drop features from snack.expo.io in the broswer.
diff --git a/client/src/guide/english/react-native/screen-dimensions/index.md b/client/src/guide/english/react-native/screen-dimensions/index.md
deleted file mode 100644
index e2a0d47f0c..0000000000
--- a/client/src/guide/english/react-native/screen-dimensions/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Screen Dimensions
----
-## React Native - Screen Dimensions
-
-React Native uses Dots Per Inch (DPI) to measure the sizing of the User Interface (UI) and anything displayed on the UI. This type of measurement allows an application to look uniform accross various screen sizes and pixel densities.
-
-For standard use cases, applications can be developed without having to know the specifics of the user's device (eg pixel density) since the UI elements will scale automatically. When it is required, there are APIs availabel such as `PixelRatio` for finding out about the pixel density of the users device.
-
-To get the window or screen height/width of a users device, React Native has an API called `Dimensions`.
-
-```js
-import { Dimensions } from 'react-native';
-```
-
-Here are the methods that the `Dimensions` API provides:
-
-```js
-Dimensions.get('window').height;
-Dimensions.get('window').width;
-Dimensions.get('screen').height;
-Dimensions.get('screen').width;
-```
-
-**Note: There have been some known issues in the past with the Dimensions API such as not returning the correct information when a user rotates their device. It's best to make sure you test this on actual devices before deploying an application.**
-
diff --git a/client/src/guide/english/react-native/styling/index.md b/client/src/guide/english/react-native/styling/index.md
deleted file mode 100644
index f3b8015f5a..0000000000
--- a/client/src/guide/english/react-native/styling/index.md
+++ /dev/null
@@ -1,122 +0,0 @@
----
-title: Styling
----
-## React Native - Styling
-
-React Native provides an API for creating stylesheets and styling your components: [StyleSheet](https://facebook.github.io/react-native/docs/stylesheet).
-
-```jsx
-import React, { Component } from 'react';
-import { StyleSheet, View, Text } from 'react-native';
-
-export default class App extends Component {
- render () {
- return (
-
- I am a header!
- I am some blue text.
-
- );
- }
-}
-
-const styles = StyleSheet.create({
- header: {
- fontSize: 20
- },
- text: {
- color: 'blue'
- }
-});
-```
-
-While regular CSS stylesheets aren't valid, React Native's superset of CSS is very similar to traditional CSS. Many CSS properties (e.g. `color`, `height`, `top`, `right`, `bottom`, `left`) are the same in StyleSheet. Any CSS properties that have hyphens (e.g. `font-size`, `background-color`) must be changed to camelCase (e.g. `fontSize`, `backgroundColor`).
-
-Not all CSS properties exist in StyleSheet. Since there is no true concept of hovering on mobile devices, CSS hover properties don't exist in React Native. Instead, React Native provides [Touchable components](https://facebook.github.io/react-native/docs/handling-touches#touchables) that respond to touch events.
-
-Styles are also not inherited as they are in traditional CSS. In most cases, you must declare the style of each component.
-
-### Flexbox Layouts
-
-React Native uses an implementation of [flexbox](https://facebook.github.io/react-native/docs/flexbox) similar to the web standard. By default, items in the view will be set to `display: flex`.
-
- > If you do not want to use flexbox, you can also arrange React Native components via `relative` or `absolute` positioning.
-
-Flexbox in React Native defaults to `flexDirection: column`, instead of `flex-direction: row` (web standard). The `column` value displays flexible items vertically, which accommodates mobile devices in portrait orientation.
-
-To learn more about flexbox, visit [this detailed guide on CSS-Tricks](https://css-tricks.com/snippets/css/a-guide-to-flexbox/) and a gamified learning approach with [Flexbox Froggy](http://flexboxfroggy.com/).
-
-### Styled Components
-
-Including lots of styles in a file with a component isn't always easy to maintain. Styled components can solve this issue.
-
-For example, a Button component may be used in multiple places across an application. Copying and pasting the style object with each Button instance would be inefficient. Instead, create a reusable, styled Button component:
-
-```jsx
-import React from 'react';
-import { Text, TouchableOpacity } from 'react-native';
-
-const Button = ({ onPress, children }) => {
- const { buttonStyle, textStyle } = styles;
- return (
-
-
- {children}
-
-
- );
-};
-
-export default Button;
-
-const styles = {
- textStyle: {
- alignSelf: 'center',
- color: '#336633',
- fontSize: 16,
- fontWeight: '600',
- paddingTop: 10,
- paddingBottom: 10
- },
- buttonStyle: {
- backgroundColor: '#fff',
- borderWidth: 1,
- borderColor: '#336633',
- paddingTop: 4,
- paddingBottom: 4,
- paddingRight: 25,
- paddingLeft: 25,
- marginTop: 10,
- width: 300
- }
-};
-```
-
-The styled Button component can be easily imported and used across the application without repeatedly declaring the style object:
-
-```jsx
-import React, { Component } from 'react';
-import { TextInput, View } from 'react-native';
-import Button from './styling/Button';
-
-export default class Login extends Component {
- render() {
- return (
-
- Log In
-
- );
- }
-}
-```
-
-### Libraries for Styling
-
-There are a few popular libraries for styling React Native. Some of them provide features similar to [Bootstrap](../../bootstrap/index.md), including default forms, button styles, and page layout options. Some of the most popular options are
-
- 1. [NativeBase](https://github.com/GeekyAnts/NativeBase) UI cross-platform components library created by [Geekyants.com](https://geekyants.com/).
- 2. [React Native Elements](https://github.com/react-native-training/react-native-elements) another UI toolkit created by [react-native-training](https://github.com/react-native-training)
- 3. Customize your own style using [styled-components](https://github.com/styled-components/styled-components).
-
diff --git a/client/src/guide/english/react/component/index.md b/client/src/guide/english/react/component/index.md
deleted file mode 100644
index a40b967eb4..0000000000
--- a/client/src/guide/english/react/component/index.md
+++ /dev/null
@@ -1,83 +0,0 @@
----
-title: React - Components
----
-## React - Components
-
-Components are reusable in react.js. You can inject value into props as given below :
-
-```jsx
-
-function Welcome(props) {
- return Hello, {props.name} ;
-}
-
-const element =
-
{this.props.name}
-
- {this.props.color}
-
-
-
{props.name}
-
{props.color}
-
-
{props.name}
-
{props.color}
-
1
-
-React is a JavaScript library and React applications built on it run in the browser, NOT on the server. Applications of this kind only communicate with the server when necessary, which makes them very fast compared to traditional websites that force the user to wait for the server to re-render entire pages and send them to the browser.
-
-React is used for building user interfaces - what the user sees on their screen and interacts with to use your web app. This interface is split up into components, instead of having one huge page you break it up into smaller pieces known as components. In more general terms, this approach is called Modularity.
-
-- It's declarative: React uses a declarative paradigm that makes it easier to reason about your application.
-- It's efficient: React computes the minimal set of changes necessary to keep your DOM up-to-date.
-- And it's flexible: React works with the libraries and frameworks that you already know.
-
-## Why learn React?
-
-1. React involves Composition that is lots of components wrapping up the functionalities into an encapsulated container.
-Many popular websites use React implementing the MVC architectural pattern. Facebook (Partially), Instagram (Completely), Khan Academy (Partially), Codecademy (Partially), New York Times (Partially), Yahoo Mail (Completely), Dropbox's new photo and video gallery app Carousel (Completely) are the popular websites known to be using React.
-How these large applications are build using React? The simple answer is by building small applications or components.
-Example:
-
-```jsx
-const Component2 = () => {
- return (
-
- );
-};
-const Component3 = () => {
- return (
-
- );
-};
-const Component1 = () => {
- return (
-
-
- );
-};
-
-ReactDOM.render(
- Document
-
-
-
-
-
-```
-
-We can fill in the title of “Time to React!”.
-
-This content will not appear in your webpage. Anything in the head section of the HTML file will be meta data that our browser will user to interpret our code in the body section. This title is going to be what appears on the tab for our page, not actually on the page.
-
-### 2 - Get Script Tags to Harness the Power of React and Babel Libraries
-
-Ok, item one is checked off of our list. Let’s look at item two. We are going to set up our developer environment by using script tags to bring in React and Babel. This is not a real life developer environment. That would be quite an elaborate setup. It would also leave us with a lot of boiler plate code and libraries that would take us off subject of learning React basics. The goal of this series is to go over the basic syntax of React and get right into coding.
-We are going to use `
-
-
-
-
- ...
- Time to React!
-
-```
-
-You are free to use more updated versions of these libraries as they come out. They should not create any breaking changes for the content we are covering.
-
-What are we doing here?
-The: HTML `
-
-```
-
-The “type” of script that we are using we’ll wrap in quotes and set it to `"text/babel"`.
-We’ll need this ability to use babel right away as we work with JSX. First, we are going to render React to the DOM. We will use the `ReactDOM.render()` method to do this. This will be a method, and remember a method is just a function attached to an object. This method will take two arguments.
-
-```javascript
-
- React has not rendered yet
-
-
-```
-
-The first argument is the “what” of react. The second argument is the “where” of the location you want it to be placed in the DOM.
-Let’s start by calling our ReactDOM.render() method.
-Our first argument is going to be our JSX.
-
-```javascript
-
- React has not rendered yet
-
-
-```
-
-The [official react docs state](https://reactjs.org/docs/introducing-jsx.html): “This funny tag syntax is neither a string nor HTML. It is called JSX, and it is a syntax extension to JavaScript. We recommend using it with React to describe what the UI should look like. JSX may remind you of a template language, but it comes with the full power of JavaScript. JSX produces React “elements”.”
-
-Often times, JSX freaks people out who have been developers for a while because it looks like HTML. At a very early age developers are taught separation of concerns. HTML has its place, CSS has its place and JavaScript has it’s place. JSX seems to blur the lines. You are using what looks like HTML but as Facebook says comes with the full power of JavaScript.
-
-This can freak out veterans so many react tutorials start without JSX which can be quite complex. We won’t do that. Because this course is directed towards those who are very young in their careers you may not bring those red flags when you see this syntax.
-
-And JSX is just really intuitive. You can probably quite easily read this code and see that this is going to be the largest header tag displaying the text “Hello World”. No mystery and pretty straightforward.
-Now, let’s look at what our second argument would be.
-
-```javascript
-
- React has not rendered yet
-
-
-```
-
-This is where we want our react content rendered to the dom. You’ve probably done this quite a few times in the past. We’ll just type in `document.getElementById()`. And we’ll pass into the argument of the id of app. And that is it. We will now target the div with the id of app to insert our react content.
-
-We want to make sure our content is saved. Go ahead and open this up in the browser and you should see “Hello World”. As you can probably guess, using React is not the quickest or best way to create a Hello World app. We aren’t quite seeing the benefits of it yet. But now, we know that everything is working.
-
-Go ahead and open up the console and look at the “elements”. You can do that on a mac with command + shift + j or on a On Windows and Linux: Ctrl + Shift + J
-
-If you click on the head tag we can see our script libraries we included. Then we can go down to body of our document. Let’s click on our div with the id of “app”. And when we do we see our `` tag with the content “Hello World”.
-
-[View Entire Code Here](https://github.com/robgmerrill/hello-react/blob/master/section-one/index.html)
-
-or
-
-Stack Overflow. Accessed: October 28, 2017.
diff --git a/client/src/guide/english/react/jsx/index.md b/client/src/guide/english/react/jsx/index.md
deleted file mode 100644
index 4bb07a964d..0000000000
--- a/client/src/guide/english/react/jsx/index.md
+++ /dev/null
@@ -1,76 +0,0 @@
----
-title: JSX
----
-
-# JSX
-
-> JSX is short for JavaScript XML.
-
-JSX is an expression which uses valid HTML statements within JavaScript. You can assign this expression to a variable and use it elsewhere. You can combine other valid JavaScript expressions and JSX within these HTML statements by placing them within braces (`{}`). Babel further compiles JSX into an object of type `React.createElement()`.
-
-### Single-line & Multi-line expressions
-Single-line expression are simple to use.
-
-```jsx
-const one = Hello World! ;
-```
-
-When you need to use multiple lines in a single JSX expression, write the code within a single parenthesis.
-
-```jsx
-const two = (
-
-);
-```
-
-### Using only HTML tags
-
-```jsx
-const greet = Hello World! ;
-```
-
-### Combining JavaScript expression with HTML tags
-We can use JavaScript variables within braces.
-
-```jsx
-const who = "Quincy Larson";
-const greet = Hello {who}! ;
-```
-
-We can also call other JavaScript functions within braces.
-
-```jsx
-function who() {
- return "World";
-}
-const greet = Hello {who()}! ;
-```
-### Only a single parent tag is allowed
-A JSX expression must have only one parent tag. We can add multiple tags nested within the parent element only.
-
-```jsx
-// This is valid.
-const tags = (
-
-);
-
-// This is not valid.
-const tags = (
- Hello World!
- This is my special list:
-
-);
-```
-
-### More Information
-
-- [Introducing JSX](https://reactjs.org/docs/introducing-jsx.html)
diff --git a/client/src/guide/english/react/state/index.md b/client/src/guide/english/react/state/index.md
deleted file mode 100644
index f99ce4b71d..0000000000
--- a/client/src/guide/english/react/state/index.md
+++ /dev/null
@@ -1,125 +0,0 @@
----
-title: State
----
-
-# State
-
-State is the place where the data comes from.
-
-We should always try to make our state as simple as possible and minimize the number of stateful components. If we have, for example, ten components that need data from the state, we should create one container component that will keep the state for all of them.
-
-State is basically like a global object that is available everywhere in a component.
-
-Example of a Stateful Class Component:
-
-```javascript
-import React from 'react';
-
-class App extends React.Component {
- constructor(props) {
- super(props);
-
- // We declare the state as shown below
-
- this.state = {
- x: "This is x from state",
- y: "This is y from state"
- }
- }
- render() {
- return (
-
-
{this.state.x}
- {this.state.y}
-
- );
- }
-}
-export default App;
-```
-
-Another Example:
-
-```javascript
-import React from 'react';
-
-class App extends React.Component {
- constructor(props) {
- super(props);
-
- // We declare the state as shown below
- this.state = {
- x: "This is x from state",
- y: "This is y from state"
- }
- }
-
- render() {
- let x1 = this.state.x;
- let y1 = this.state.y;
-
- return (
-
-
{x1}
- {y1}
-
- );
- }
-}
-export default App;
-```
-
-## Updating State
-You can change the data stored in the state of your application using the `setState` method on your component.
-
-```js
-this.setState({ value: 1 });
-```
-
-Keep in mind that `setState` is asynchronous so you should be careful when using the current state to set a new state. A good example of this would be if you want to increment a value in your state.
-
-#### The Wrong Way
-```js
-this.setState({ value: this.state.value + 1 });
-```
-
-This can lead to unexpected behavior in your app if the code above is called multiple times in the same update cycle. To avoid this you can pass an updater callback function to `setState` instead of an object.
-
-#### The Right Way
-```js
-this.setState(prevState => ({ value: prevState.value + 1 }));
-```
-
-## Updating State
-You can change the data stored in the state of your application using the `setState` method on your component.
-
-```js
-this.setState({value: 1});
-```
-
-Keep in mind that `setState` may be asynchronous so you should be careful when using the current state to set a new state. A good example of this would be if you want to increment a value in your state.
-
-##### The Wrong Way
-```js
-this.setState({value: this.state.value + 1});
-```
-
-This can lead to unexpected behavior in your app if the code above is called multiple times in the same update cycle. To avoid this you can pass an updater callback function to `setState` instead of an object.
-
-##### The Right Way
-```js
-this.setState(prevState => ({value: prevState.value + 1}));
-```
-
-##### The Cleaner Way
-```
-this.setState(({ value }) => ({ value: value + 1 }));
-```
-
-When only a limited number of fields in the state object is required, object destructing can be used for cleaner code.
-
-### More Information
-
-- [React - State and Lifecycle](https://reactjs.org/docs/state-and-lifecycle.html)
-- [React - Lifting State Up](https://reactjs.org/docs/lifting-state-up.html)
-- [React Native - State Up](https://facebook.github.io/react-native/docs/state.html)
diff --git a/client/src/guide/english/react/why-react/index.md b/client/src/guide/english/react/why-react/index.md
deleted file mode 100644
index 98f205ef22..0000000000
--- a/client/src/guide/english/react/why-react/index.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: Why React
----
-## Why React.js?
-
-### Simplicity
-React.js is not a full fledged Javascript framework like Angular.js or other popular frontend frameworks. Instead, React.js acts as the 'V' in MVC (Model View Controller). It is simply a view engine that can be dropped in and used with a plethora of other tools for the data and model part of MVC (most popularly Redux and Node.js).
-
-### Performance
-
-Since React makes use of a _Virtual DOM_, it can selectively update portions of the page as needed rather than always having to complete an entire page reload. In many cases, not updating the entire DOM will save considerably on performance. Moreover, many of the built-in functions (such as Lifecycle functions) also have performance benefits as they often help to check if a re-render is even needed to begin with.
-
-### Low learning curve
-Of the major frontend "frameworks" available, React has a relatively low barrier to entry and has a quick ramp up time. In addition, React's official documentation is extremely clear and provide many examples for most of the common use cases.
-
-### Tooling
-The tools and software commonly utilized with React are incredibly well maintained and supported and provide several different avenues of best practices to follow when developing web applications. Some of these tools include Redux, React-router, Thunk, and many others. There are also a number of development tools, such as a React and Redux Chrome extension, which helps with debugging your React applications.
-
-### Support
-React is created and maintained by the folks at Facebook and is used by individuals and companies all over the world in large volume. This means React is constantly improving and any problems you may have have probably already been asked on Stack Overflow.
-
-Other than the above, we can take our react knowledge to develop mobile native applications using react-native and also take our knowledge and expand it to VR using react-vr. Basically learning react opens us up to various other oppurtunities like using it for Web, VR, PWA(Progressive Web App) and many others
-
-#### More Information
-To learn more about why React is so great check out the [official website](https://reactjs.org/)
diff --git a/client/src/guide/english/redux/redux-middleware/index.md b/client/src/guide/english/redux/redux-middleware/index.md
deleted file mode 100644
index 5a217372c4..0000000000
--- a/client/src/guide/english/redux/redux-middleware/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Redux Middleware
----
-## Redux Middleware
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/guide/english/redux/redux-selectors/index.md b/client/src/guide/english/redux/redux-selectors/index.md
deleted file mode 100644
index 4056015c06..0000000000
--- a/client/src/guide/english/redux/redux-selectors/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Redux Selectors
----
-## Redux Selectors
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/guide/english/redux/reselect/index.md b/client/src/guide/english/redux/reselect/index.md
deleted file mode 100644
index 453a9947f7..0000000000
--- a/client/src/guide/english/redux/reselect/index.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: Reselect
----
-## Reselect
-Reselect is simple selector library for Redux.
-Why we need selectors? Official docs describe it this way:
-
-* Selectors can compute derived data, allowing Redux to store the minimal possible state.
-* Selectors are efficient. A selector is not recomputed unless one of its arguments changes.
-* Selectors are composable. They can be used as input to other selectors.
-
-It might sound complicated but slectors allow app to work faster by reducing unnecessarily rerendering(s). Normally `mapStateToProps` is called every single time any change in `store` is made. `mapStateToProps` binds store values to react. Until you use `PureComponents` it might cause component being rerendered although it's not required.
-
-#### More Information:
-
-* [reselect](https://github.com/reduxjs/reselect)
-* [React, Reselect and Redux](https://medium.com/@parkerdan/react-reselect-and-redux-b34017f8194c)
-
diff --git a/client/src/guide/english/rest-api/index.md b/client/src/guide/english/rest-api/index.md
deleted file mode 100644
index 94ee3974b5..0000000000
--- a/client/src/guide/english/rest-api/index.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-title: Rest API Design
----
-
-
-### History
-REST stands for **Re**presentational **S**tate **T**ransfer protocol. Roy Fielding defined REST in his Phd dissertation in year 2000.
-
-### What is it?
-REST was developed to provide a uniform interface for
-
- - Identifying resources
- - Manipulation of resources
- - Self descriptive messages
- - Using Hypermedia as the Engine of Application State (HATEOS)
-
-### Best Practices
-
- - #### Basics
-
-| Method | http://api.co/v2/cars | http://api.co/v2/cars/1234 |
-|--- |--- |--- |
-| GET | List all the cars | Retrieve an individual car |
-| POST | Create a new car | Error |
-| PUT | Replace cars collections with new one | Replace the car with id 1234 |
-| DELETE | Delete all cars | Delete car with id 1234 |
-
-*Note while PUT operations either client or server can generate id's*
-
-- #### Nouns are good Verbs are bad
-
- - Use nouns to refer resources like `cars`, `fruits` etc.
- - Use verbs for action declarations `convertMilesToKms`, `getNutritionalValues`
-
-- #### Singular or Plural?
- Use correct grammer for declaration
-
- **Avoid** `/person/145`
-
- **Prefer** `/people/154` Assume to return 154th person from list of people
-
-- #### Use casing
- Use anyone of the below patterns and be **consistent!**
-
-
- | Case Styles | Example |
- | ------------- |-------------|
- | **UpperCamelCase** | `http://api.fintech.cp/DailyTransactions/Today` |
- | **lowerCamelCase** | `http://api.fintech.cp/dailyTransactions/today` |
- | **snake_case** | `http://api.fintech.cp/daily_transactions/today` |
-
-- #### **Relationships and Resources**
-
- - Resources can have `one-to-many`, `many-to-many`, `many-to-one` relationships etc. Mapping them correctly is crucial.
- - **One-to-Many** Mapping
-
- For example, `Tickets/145/messages/4` suggests one-to-many relationship between `tickets` and `messages`. Meaning `1` ticket has `N` messages. Message isn't standalone resource. You can't have `/messages/4`.
-
- - **Many to Many** Mapping
-
- For example, `/usergroups/345/users/56` suggests select 345th user group and get user with id 56. However, one user might be in multiple `usergroups` i.e. `/usergroups/209/users/56` is also valid. In such case so for seperating the depedant resource `users` into a seperate endpoint like `/users/56` and provide resource linking in `/usergroups/209/users/56`
-
-- #### **API Parameters**
-
- - **PATH** : *required* to access the resource E.g. `/cars`, `/fruits`
-
- - **Query Parameters** : *optional* filter the list E.g. `/cars?type=SUV&year=2010`
-
- - **Body** : Resource specific logic. Advance search query. Sometimes it might have both Query and body.
-
- - **Header** : Should contain global or platform wide data. E.g. API key parameters, encrypted keys for auth, device type information e.g. mobile or desktop or endpoint, device data type e.g. xml or json. Use header to communicate these parameters
-
- - #### HTTP Status Codes
-
- Use correct status codes
-
- | Codes | Meaning |
- | ------------- |:-------------:|
- | 1xx | Request received and understood. |
- | 2xx | Action requested by client was received, understood and requested. |
- | 3xx | Client must take additional action to complete the request. Most of these status codes are used in URL Redirection. |
- | 4xx | Intended for situations where it seems the error was caused by the client. |
- | 5xx | The server failed to fulfil a request. |
-
-
-
- Little more on **2xx**!
-
- - **201 Resource Created.**
- POST `/cars` should return HTTP 201 created with `location` header stating how to access the resource
- E.g. `location` : `api.com/cars/124` in header
-
- - **202 - Accepted**
-
- Use this if the task is huge to run. Tell the client, it has accepted the request and will/is process/processing
- No payload is returned
-
- - **204 - No content**
-
- Used when deleted `DELETE cars/124`
- Returns no content. But can also return `200 OK` if API intends to send the deleted resource for further processing.
-
- The dangerous **5xx** resources!
-
- - **500** Internal Server Error
- - **504** Gateway Timeout. Server didn't receive timely response
-
- Less known **4xx** suggests that you are passing wrong parameter. Can also pass information that is wrong. E.g.
-
- `DELETE /cars/MH09234`
-
- returns `4xx` or message
- `Expecting int car id /car/id got string car/MH09234 `
-
-
-### **Further reading**
-[How to Design Great APIs - Parse Developer Day 2013](https://www.youtube.com/watch?v=qCdpTji8nxo)
-
-[The never-ending REST API design debate by Guillaume Laforge](https://www.youtube.com/watch?v=48azd2VqtP0)
-
-[HTTP status codes](https://httpstatuses.com/)
diff --git a/client/src/guide/english/robotics/index.md b/client/src/guide/english/robotics/index.md
deleted file mode 100644
index d8c785ce82..0000000000
--- a/client/src/guide/english/robotics/index.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: Robotics
----
-## Robotics
-
-Robotics is about the systems that make up robots. There is no universally applicable deifinition of a robot. One generally accepted definition is: _A robot is a programmable physical machine that follows the sense, think, act paradigm_. More specifically, a robot needs to sense its environment, use that information as an input to make decisions and then act accordingly. Each system in this paradigm is often a study in itself. There are a multitude of varieties of robot types and component systems. Each robot usually is dedicated to a set of processes with clear objectives.
-
-### Sense
-
-A robot has to sense its environment. For this, it uses different types of sensors. A _sensor_ can be defined as an input device which converts physical parameters into (usually) electrical signals. Cameras in your smartphone are a type of sensors, they convert light into electrical bits of information. A digital thermometer is a sensor that converts heat (temperature) into a electrical signal that can be displayed as a celsius value on its screen. There are always limitations to the accuracy of the output of a sensor, so the output from the sensor is usually further processed to compensate for the errors.
-
-### Think
-
-A robot has to make decisions based on the input it receives from the environment and the way it is programmed. Autonomous functions are those which can be performed by a robot without any human input. Robots usually have a mixture of autonomous and controlled functions (fully autonomous robots are getting common these days). They have an onboard computer that facilitates the computation needed for the decision making process of a robot. For example, commercial consumer [quadcopters](https://en.wikipedia.org/wiki/Quadcopter) are offering a feature where the copter can be asked to follow a moving object. It uses the input from the camera, performs [image processing](https://en.wikipedia.org/wiki/Digital_image_processing) to distinguish the object from the environment and uses [controlled systems](https://en.wikipedia.org/wiki/Control_system) to follow the object. And all of this is done without any human input (ie after the copter is programmed).
-
-### Act
-
-Once the robot makes its decision, it needs to act accordingly. For this purpose, it uses actuators. An _actuator_ is a device that converts energy into motion. Actuators can be classified according to the type of input energy they require. The two most commmon types of actuators are electrical (which use electrical energy to generate motion) and pneumatic (which use air pressure to generate motion). For example, a motor is an actuator that converts electrical energy into rotatory motion. There are always limitations to the accuracy and degree of control of an actuator, hence [control systems](https://en.wikipedia.org/wiki/Control_system) are used in order to compensate those limitations.
-
-## Essential things for Robotics.
-
-First, you need to have good amount of patience to ace in Robotics.
-
-1) Be good at any one programming language to have a good grip over code.
-2) Learn RaspberryPi or Arduino for the proper understanding of electronics and logic.
- Now the difference between RaspberryPi and Arduino is:
- RaspberryPi is a SBC(Single-Board-Computer) whereas Arduino is only a Microcontroller.
- So the difference between the above stuff is quite important.
-3) Inverse Kinematics is very important for the designing part.
- Here is a good resource to learn [Inverse kinematics](https://www.intechopen.com/books/industrial_robotics_theory_modelling_and_control/robot_kinematics__forward_and_inverse_kinematics).
-
-Putting together, these resources are good enough to kick start your journey with Robotics!
-
-### More Information:
-
-[Robots (Wikipedia.org)](https://en.wikipedia.org/wiki/Robot)
-
-[Robotics (Wikipedia.org)](https://en.wikipedia.org/wiki/Robotics)
-
-[Sensors (electronicshub.org)](https://www.electronicshub.org/different-types-sensors/)
-
-[Actuator (Wikipedia.org)](https://en.wikipedia.org/wiki/Actuator)
-
diff --git a/client/src/guide/english/ruby/common-array-methods/index.md b/client/src/guide/english/ruby/common-array-methods/index.md
deleted file mode 100644
index 0cf9f88ed6..0000000000
--- a/client/src/guide/english/ruby/common-array-methods/index.md
+++ /dev/null
@@ -1,209 +0,0 @@
----
-title: Common Array Methods
----
-## Common Array Methods
-
-Ruby Arrays form a core foundation in programming in Ruby, and most languages in fact. It is used so much that it would be beneficial to know and even memorize some of the most commonly used methods for arrays. If you want to know more about Ruby Arrays, we have [an article about them](https://guide.freecodecamp.org/ruby/ruby-arrays).
-
-For the purpose of this guide, our array will be as follows:
-
-``` ruby
-array = [0, 1, 2, 3, 4]
-```
-
-#### .length
-The .length method tallies the number of elements in your array and returns the count:
-
-``` ruby
-array.length
-=> 5
-```
-
-#### .first
-The .first method accesses the first element of the array, the element at index 0:
-
-``` ruby
-array.first
-=> 0
-```
-
-#### .last
-The .last method accesses the last element of the array:
-
-``` ruby
-array.last
-=> 4
-```
-
-#### .take
-The .take method returns the first n elements of the array:
-
-``` ruby
-array.take(3)
-=> [0, 1, 2]
-```
-
-#### .drop
-The .drop method returns the elements after n elements of the array:
-
-``` ruby
-array.drop(3)
-=> [3, 4]
-```
-
-#### array index
-You can access a specific element in an array by accessing its index. If the index does not exist in the array, nil will be returned:
-
-```ruby
-array[2]
-=> 2
-
-array[5]
-=> nil
-```
-
-#### .pop
-The .pop method will permantently remove the last element of an array:
-
-``` ruby
-array.pop
-=> [0, 1, 2, 3]
-```
-
-#### .shift
-The .shift method will permantently remove the first element of an array and return this element:
-
-``` ruby
-array.shift
-=> 0
-array
-=> [1, 2, 3, 4]
-```
-
-#### .push
-The .push method will allow you to add an element to the end of an array:
-
-``` ruby
-array.push(99)
-=> [0, 1, 2, 3, 4, 99]
-```
-#### .unshift
-The .unshift method will allow you to add an element to the beginning of an array:
-
-```
-array = [2, 3]
-array.unshift(1)
-=> [1, 2, 3]
-```
-
-#### .delete
-The .delete method removes a specified element from an array permanently:
-
-``` ruby
-array.delete(1)
-=> [0, 2, 3, 4]
-```
-
-#### .delete_at
-The .delete_at method allows you to permanently remove an element of an array at a specified index:
-
-``` ruby
-array.delete_at(0)
-=> [1, 2, 3, 4]
-```
-
-#### .reverse
-The .reverse method reverses the array but does not mutate it (the original array stays as is):
-
-``` ruby
-array.reverse
-=> [4, 3, 2, 1, 0]
-```
-#### .select
-The .select method iterates over an array and returns a new array that includes any items that return true to the expression provided.
-
-``` ruby
-array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-array.select { |number| number > 4 }
-=> [5, 6, 7, 8, 9, 10]
-array
-=> [5, 6, 7, 8, 9, 10]
-```
-
-#### .include?
-The include? method checks to see if the argument given is included in the array:
-
-``` ruby
-array = [1, 2, 3, 4, 5]
-=> [1, 2, 3, 4, 5]
-array.include?(3)
-=> true
-
-#### .flatten
-The flatten method can be used to take an array that contains nested arrays and create a one-dimensional array:
-
-``` ruby
-array = [1, 2, [3, 4, 5], [6, 7]]
-array.flatten
-=> [1, 2, 3, 4, 5, 6, 7]
-```
-
-#### .join
-The .join method returns a string of all the elements of the array separated by a separator parameter. If the separator parameter is nil, the method uses an empty string as a separator between strings.
-
-``` ruby
-array.join
-=> "1234"
-array.join("*")
-=> "1*2*3*4"
-```
-
-#### .each
-The .each method iterates over each element of the array, allowing you to perform actions on them.
-
-``` ruby
-array.each do |element|
- puts element
-end
-=>
-0
-1
-2
-3
-4
-```
-
-#### .map
-The .map method is the same as the .collect method. The .map and .collect methods iterate over each element of the array, allowing you to perform actions on them. The .map and .collect methods differ from the .each method in that they return an array containing the transformed elements.
-
-``` ruby
-array.map { |element| element * 2 }
- puts element
-end
-=>
-0
-2
-4
-6
-8
-```
-
-#### .uniq
-The .uniq method takes in an array containing duplicate elements, and returns a copy of the array containing only unique elements--any duplicate elements are removed from the array.
-
-``` ruby
-array = [1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 6, 7, 8]
-array.uniq
-=> [1, 2, 3, 4, 5, 6, 7, 8]
-```
-
-#### .concat
-The .concat method appends the elements from an array to the original array. The .concat method can take in multiple arrays as an argument, which will in turn append multiple arrays to the original array.
-``` ruby
-array = [0, 1, 2, 3, 4]
-array.concat([5, 6, 7], [8, 9, 10])
-=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-```
-
-## More Information
-* [Ruby Array docs](http://ruby-doc.org/core-2.5.1/Array.html)
diff --git a/client/src/guide/english/ruby/ruby-arrays/index.md b/client/src/guide/english/ruby/ruby-arrays/index.md
deleted file mode 100644
index 8784a41f04..0000000000
--- a/client/src/guide/english/ruby/ruby-arrays/index.md
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: Ruby Arrays
----
-## Ruby Arrays
-
-An array represents a list of values. The individual values are often called "elements" of the array. To make an array in Ruby, use square brackets and separate values with commas:
-
-```ruby
-my_array = [1, 2, 3, 4, 5]
-```
-
-That first example is an array of numbers, but a Ruby array can contain values of different types, even other arrays:
-
-```ruby
-mixed_array = [5, "Hello World", true, [1,2,3]]
-```
-
-
-You can access the elements of an array with square brackets and numerical indexes. Notice that the first element is at index 0, not 1:
-
-```ruby
-mixed_array[0] # 5
-mixed_array[1] # "Hello World"
-mixed_array[2] # true
-```
-
-You can check how many elements an array has with the `length` method:
-
-```ruby
-mixed_array.length # 3
-[].length # 0
-```
-
-You can check the first element of an array with the `first` method:
-```ruby
-mixed_array.first # 5
-```
-
-You can check the last element of an array with the `last` method:
-```ruby
-mixed_array.last # true
-```
-
-#### Ruby Lambda
-A lambda is also commonly referred to as an anonymous function. To create a lambda in Ruby, you can use the following syntax:
-```ruby
-lambda = lambda {}
-```
-
-#### More Information:
-Ruby array documentation
diff --git a/client/src/guide/english/ruby/ruby-string-methods/index.md b/client/src/guide/english/ruby/ruby-string-methods/index.md
deleted file mode 100644
index 6818450993..0000000000
--- a/client/src/guide/english/ruby/ruby-string-methods/index.md
+++ /dev/null
@@ -1,189 +0,0 @@
----
-title: Ruby String Methods
----
-## Ruby String Methods
-Ruby has many built in methods to work with strings. Strings in Ruby by default are mutable and can be changed in place or a new string can be returned from a method.
-
-### Length:
-
-* The `.length` property returns the number of characters in a string including white-space.
- ```ruby
- "Hello".length #=> 5
- "Hello World!".length #=> 12
- ```
-
-### Empty:
-
-* The `.empty?` method returns `true` if a string has a length of zero.
- ```ruby
- "Hello".empty? #=> false
- "!".empty? #=> false
- " ".empty? #=> false
- "".empty? #=> true
- ```
-
-### Count:
-
-* The `.count` method counts how many times a specific character(s) is found in a string.
-* This method is case-sensitive.
- ```ruby
- "HELLO".count('L') #=> 2
- "HELLO WORLD!".count('LO') #=> 1
- ```
-
-### Insert:
-
-* The `.insert` method inserts a string into another string before a given index.
- ```ruby
- "Hello".insert(3, "hi5") #=> Helhi5lo # "hi5" is inserted into the string right before the second 'l' which is at index 3
- ```
-
-### Upcase:
-
-* The `.upcase` method transforms all letters in a string to uppercase.
- ```ruby
- "Hello".upcase #=> HELLO
- ```
-
-### Downcase:
-
-* The `.downcase` method transforms all letters in a string to lowercase.
- ```ruby
- "Hello".downcase #=> hello
- ```
-### Swapcase
-
-* The `.swapcase` method transforms the uppercase latters in a string to lowercase and the lowercase letters to uppercase.
- ```ruby
- "hELLO wORLD".swapcase #=> Hello World
- ```
-
-### Capitalize:
-
-* The `.capitalize` method make the first letter in a string uppercase and the rest of the string lowercase.
- ```ruby
- "HELLO".capitalize #=> Hello
- "HELLO, HOW ARE YOU?".capitalize #=> Hello, how are you?
- ```
-
-_Note that the first letter is only capitalized if it is at the beginning of the string._
- ```ruby
- "-HELLO".capitalize #=> -hello
- "1HELLO".capitalize #=> 1hello
- ```
-
-### Reverse:
-
-* The `.reverse` method reverses the order of the characters in a string.
- ```ruby
- "Hello World!".reverse #=> "!dlroW olleH"
- ```
-
-### Split:
-
-* The `.split` takes a strings and _splits_ it into an array, then returns the array.
- ```ruby
- "Hello, how are you?".split #=> ["Hello,", "how", "are", "you?"]
- ```
-
-* The default method splits the string based on whitespace, unless a different separator is provided (see second example).
- ```ruby
- "H-e-l-l-o".split('-') #=> ["H", "e", "l", "l", "o"]
- ```
-
-### Chop:
-
-* The `.chop` method removes the last character of the string.
-* A new string is returned, unless you use the `.chop!` method which mutates the original string.
- ```ruby
- "Name".chop #=> Nam
- ```
-
- ```ruby
- name = "Batman"
- name.chop
- name == "Batma" #=> false
- ```
-
- ```ruby
- name = "Batman"
- name.chop!
- name == "Batma" #=> true
- ```
-
-### Strip:
-
-* The `.strip` method removes the leading and trailing whitespace on strings, including tabs, newlines, and carriage returns (`\t`, `\n`, `\r`).
- ```ruby
- " Hello ".strip #=> Hello
- ```
-
-### Chomp:
-
-* The `.chomp` method removes the last character in a string, only if it’s a carriage return or newline (`\r`, `\n`).
-* This method is commonly used with the `gets` command to remove returns from user input.
- ```ruby
- "hello\r".chomp #=> hello
- "hello\t".chomp #=> hello\t # because tabs and other whitespace remain intact when using `chomp`
- ```
-
-### To Integer:
-
-* The `.to_i` method converts a string to an integer.
- ```ruby
- "15".to_i #=> 15 # integer
- ```
-
-### Gsub:
-
-* `gsub` replaces every reference of the first parameter for the second parameter on a string.
-```ruby
-"ruby is cool".gsub("cool", "very cool") #=> "ruby is very cool"
-```
-* `gsub` also accepts patterns (like *regexp*) as first parameter, allowing things like:
-```ruby
-"ruby is cool".gsub(/[aeiou]/, "*") #=> "r*by *s c**l"
-```
-
-### Concatenation:
-
-* Ruby implements some methods to concatenate two strings together:
-
- * The `+` method:
- ```ruby
- "15" + "15" #=> "1515" # string
- ```
-
- * The `<<` method:
- ```ruby
- "15" << "15" #=> "1515" # string
- ```
-
- * The `concat` method:
- ```ruby
- "15".concat "15" #=> "1515" # string
- ```
-
-### Index:
-
-* The `index` method returns the index position of the first occurrance of the substring or regular expression pattern match in a string.
-* If there is no match found, `nil` is returned.
-* A second optional parameter indicates which index position in the string to begin searching for a match.
-
- ```ruby
- "information".index('o') #=> 3
- "information".index('mat') #=> 5
- "information".index(/[abc]/) #=> 6
- "information".index('o', 5) #=> 9
- "information".index('z') #=> nil
- ```
-
-### Clear:
-
-* Removes string content.
- ```ruby
- a = "abcde"
- a.clear #=> ""
- ```
-
-
diff --git a/client/src/guide/english/security/bug-bounties/index.md b/client/src/guide/english/security/bug-bounties/index.md
deleted file mode 100644
index 41139dd993..0000000000
--- a/client/src/guide/english/security/bug-bounties/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Bug Bounties
----
-
-## Bug Bounties
-
-Bug bounties are programs that are set up by companies to encourage people to check their products for vulnerabilities. In return these companies offer cash prizes for the discovered vulnerabilities.
-
-### Benefits to bounty hunters
-
-The benefits to the bounty hunters are fairly straightforward. They get paid for what they find and get to improve their skills
-
-### Benefits to companies
-
-The companies that sponsor these programs gain several benefits:
-
-- Many eyes on their product are more likely to find more bugs than the typical QA team
-- Only have to pay for results, not for the time spent trying to find bugs
-- Encourages people who find vulnerabilties to turn them over to the company and not to the black market.
-
-### Links
-
-The following is a list of popular platforms which provide access to bug bounties from a wide variety of companies:
-
-- [BugCrowd](https://www.bugcrowd.com/bug-bounty-list/)
-- [HackerOne](https://hackerone.com/bug-bounty-programs)
diff --git a/client/src/guide/english/security/cryptography/index.md b/client/src/guide/english/security/cryptography/index.md
deleted file mode 100644
index a2467a8e4a..0000000000
--- a/client/src/guide/english/security/cryptography/index.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: Cryptography
----
-
-## Cryptography
-
-The basic objective of cryptography is to enable two people to communicate through the unsecure channel in such a way that a third person cannot understand what is being said. This channel could be a telephone line or a computer network.
-
-Cryptography started being used by the Romans in order to make messages in battle unreadable by the enemy if decyphered.
-
-Cryptography prior to the modern age was effectively synonymous with encryption, the conversion of information from a readable state to apparent nonsense.
-
-Modern cryptography is used in data so that only one party or only authorised partys have the ability to access the information.
-
-Encryption over the years has become more advanced.
-
-### Example
-
-The information that Person1 wants to send to Person2, which we call "plaintext", can be text, numerical data, or any type of data at all. Person1 encrypts the plaintext, using a predetermined key, and sends the resulting "ciphertext" over the channel. Person3, upon seeing the ciphertext in the channel, cannot determine what the plaintext was, but Person2, who knows the encryption key, can decrypt the ciphertext and reconstruct the plaintext.
-
-### Caesar Cypher (Shift Cypher)
-
-The first known cypher was the Ceasar cypher. The Ceasar cypher works by shifting the letters of a "plaintext" by a specific amount up or down in the alphabet.
-
-From an outside person's perspective, the message appears to be random letters with spaces in between.
-
-### Modern Cryptography
-
-Modern encryption uses almost random numbers and mathematically sound functions in order to allow secure communication. These newly developed functyions cannot be easily cracked due to their structure, requiring even supercomputers hundreds of years to crack.
-
-There are 2 main types of modern encryption:
-
-### 1) Symmetric or Single Key Encryption:
-
-Symmetric Key Encryption is an encryption method where both parties use only one key for encryption and decryption. These algorithms, due to their design, are generally much faster than Asymmetric or Public Key Encryption.
-
-Some Symmetric encryption techniques include: Data Encryption Standard (DES), Advance Encryption Standard (AES), Blow Fish, Two Fish, RC4.
-
-### 2) Asymmetric or Public Key Encryption:
-
-Asymmetric Encryption algorithms provide each user with a pair of keys: one public and one private. Any message encrypted with one key from the pair can only be decrypted with the other.
-
-Some Asymmetric techniques include: RSA, Diffie-Hellman, DSS(Digital Signature Standard), ElGamal.
-
-### Cryptographic Hashing
-
-Most cryptographic hash functions are designed to take a string of any length as input and produce a fixed-length hash value.
-
-A cryptographic hash function must be able to withstand all known types of cryptanalytic attack.
-
-### Cryptography Hashing
-A cryptographic hash function is a type of hash function that is designed to also be a one-way function (a function that takes too much time and resources to brute force). The main purpose of hashes deal with message intregrity, so the same message always results in the same hash.
-
-#### More Information:
-
-- [Cryptography: Theory and Practice by Douglas Stinson](https://www.crcpress.com/Cryptography-Theory-and-Practice-Third-Edition/Stinson/p/book/9781584885085)
-- [TechTarget on Encryption](http://searchsecurity.techtarget.com/definition/encryption)
-- [Cryptography Guide](https://www.tutorialspoint.com/cryptography/index.htm)
diff --git a/client/src/guide/english/security/scanning/index.md b/client/src/guide/english/security/scanning/index.md
deleted file mode 100644
index e84b1bc010..0000000000
--- a/client/src/guide/english/security/scanning/index.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-title: Scanning
----
-# Scanning
-
-## Introduction
-Network Scanning refers to a set of procedures for indentifying hosts, posts and services on a network.
-
-Scanning activities can involve checking for open ports on a network, banner grabbing, and creating network diagrams.
-
-## Scanning Techniques
-One of the most common ways to scan a network is a technique called a Ping Sweep. This can determine the live hosts on a range of IP address. A really simple example of this is just going to your command line and typing `ping 8.8.8.8`. This will send an [ICMP](https://en.wikipedia.org/wiki/Internet_Control_Message_Protocol) ECHO request to a host, in this case it will be Google's Public DNS.
-
-Different Internet protocols require different methods of scanning; for example scanning a [TCP](https://en.wikipedia.org/wiki/Transmission_Control_Protocol) network would be different to scanning a [UDP](https://en.wikipedia.org/wiki/User_Datagram_Protocol) network.
-
-TCP scans generally take advantage of the way in which TCP operates and how TCP goes through a "handshake" to initiate communication on a network:
-
-1. A device (Host A) will send a `SYN` message in an attempt to communicate across a network to another device (Server B)
-2. B needs to reply to A with an `SYN` and an `ACK` to acknowledge A's request to start communication
-3. A needs to send back an `ACK` message to acknowledge B's response
-4. Communication can then start
-
-Throughout this communication, there are bits of information that each participant sends in an attempt to initiate the conversation.
-
-Note that you can also scan IPv6 networks (IPv6 increases the IP address size to make a lot more addresses available).
-
-There are a lot more types of [scans](https://nmap.org/bennieston-tutorial/) that further abuse the TCP Handshake process. These include IDLE scans, Xmas tree scans, Inverse TCP scans, and Full Scans.
-
-## Scanning in Penetration Testing
-Scanning is the second phase out of the typical five phases of penetration testing. The phase of scanning requires the application of technical tools to gather further intelligence on your target, but in this case, the intel being sought is more commonly about the systems that they have in place.1
-
-There are three main goals:
-1. Determining if a system is alive
-2. Port scanning the system
-3. Scanning the system for vulnerabilities2
-
-### Determining if the system is alive
-
-One way to determine if the target system is alive is by using the ping command, as mentioned in the Ping Sweep technique above.
-
-For example:
-```
-ping -c
-ping 10.10.0.1 -c 4
-```
-
-If the target system is alive, you should get a response back that looks similar to below.
-
-```
-Pinging 10.10.0.1 with 32 bytes of data:
-
-Reply from 10.0.0.1: bytes=32 time=26ms TTL=240
-Reply from 10.0.0.1: bytes=32 time=26ms TTL=240
-Reply from 10.0.0.1: bytes=32 time=26ms TTL=240
-Reply from 10.0.0.1: bytes=32 time=26ms TTL=240
-Ping statistics for 10.10.0.1:
- Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
-Approximate round trip times in milliseconds:
- Minimum = 26ms, Maximum = 26ms, Average = 26ms
-```
-
- Reply from indicates that our ICMP Echo Request packet was received an ICMP Echo Reply packet was sent back.Bytes=32 tells us that the size of the packet that was sent.time=26ms lets us know how the combined time it took the ICMP Echo Request packet to get to the target and for the ICMP Echo Reply packet to come back to our machine.TTL=240 is a Time To Live value that tells us the maximum number of hops that the packet would take before it would drop.
-
-
-
-
-## Scanning Tools
-There are many tools available to scan but one of the most common is `nmap`. It's a useful tool with functions such as getting information about live hosts on a network, services that are running, and the types and versions of the operating system being used.
-
-## More Information:
-- How to Ping in Linux https://www.wikihow.com/Ping-in-Linux
-- [Video from Gordon Lyon aka Fydor, the creator of the nmap tool](https://www.youtube.com/watch?v=Hk-21p2m8YY)
-
-## Sources
-
- Summarizing The Five Phases of Penetration Testing. (2015, May 06). Retrieved October 26, 2017, from https://www.cybrary.it/2015/05/summarizing-the-five-phases-of-penetration-testing/
- Engebretson, P. (2013). The Basics of Hacking and Penetration Testing: Ethical Hacking and Penetration Testing Made Easy Ed. 2. Syngress.
-
diff --git a/client/src/guide/english/security/social-engineering/index.md b/client/src/guide/english/security/social-engineering/index.md
deleted file mode 100644
index a8973c567b..0000000000
--- a/client/src/guide/english/security/social-engineering/index.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: Social Engineering
----
-## Social Engineering
-
-Social Engineering is the art of gaining access to a secured system or resource by exploiting human behavior. It involves tricking people into breaking normal security procedures. Most attack vectors rely heavily on leveraging technical skills to find gaps in the security system. Social Engineering relies heavily on having a good understanding of human psychology. Thoroughly researching the target before an attack makes social engineering a powerful tool in the hands of the attacker.
-
-#### Traits of a good Social Engineering Hacker
-
-* Demonstrates high emotional intelligence
-* Intuitive understanding of human psychology
-* Charming and persuasive
-* Patient and observant
-* Adept at predicting human behavior based on exploiting the human need to be helpful, curious, greedy and vain
-
-#### Some examples of Social Engineering hacks
-
-* Baiting: Leaving a malware infected USB at a coffee shop in the hope that someone is curious enough to plug it in and check it out. Once the person plugs the USB in, malware is installed on their computer. See "More Information" for a Black Hat talk about leaving infected USB drives behind for potential targets and the results of such attacks.
-
-* Pretexting: Telling lies to gain access to private information. An example would be impersonating a bank officer and asking people for personal information to 'confirm their account'. See "More Inforamtion" for a Pre-texting example where a social engineer makes changes to a target's cell phone account with very little known information.
-
-* Phishing: Sending an email which looks like it is from a trusted source to bait the user into clicking a link (to install malware) or replying with private information.
-See "More Information" for a link to test your phishing knowledge and see if you can tell the differece between a real e-mail and a phishing e-mail.
-
-* Infiltrating: impersonating someone legitimate in order to gain physical access to a building/office etc., e.g. the coffee machine repair person
-
-#### Prevention and Security
-
-Because Social Engineering requires little computer experience, it is a readily-available tool for individuals who wish to access sensitive data.
-
-The steps that an idividual can take to protect themselves from these attacks include:
-* Avoid sharing sensitive data at all, if possible.
-* If you must share, verify the source before giving them sensitive data.
-* Be aware of random emails or phone numbers claiming to be friends, family, coworkers, institutuions, etc.
-* Be aware of people in real life asking for information they shouldn't necessarily reqire.
-* Destroy important documents before throwing them away.
-
-In general, the more you know about these attacks, the better prepared you are. Be concsious of who you share information with and why.
-
-#### More Information:
-* [What is Social Engineering?](https://www.webroot.com/us/en/home/resources/tips/online-shopping-banking/secure-what-is-social-engineering)
-* [Protect Yourself from Social Engineering Attacks](http://www.makeuseof.com/tag/protect-8-social-engineering-attacks/)
-* [7 Best Social Engineering Hacks Ever](https://www.darkreading.com/the-7-best-social-engineering-attacks-ever/d/d-id/1319411?)
-* [Hacking Humans : Social Engineering Techniques and How to Protect Against Them](https://www.youtube.com/watch?v=YVqurfWzB-Q)
-* [Does Dropping USB Drives in Parking Lots and Other Places Really Work?](https://www.youtube.com/watch?v=XJCQBqTmGUU)
-* [Example of Pretexting](https://www.youtube.com/watch?v=lc7scxvKQOo)
-* [Test your Phishing IQ](https://www.sonicwall.com/en-us/phishing-iq-test)
-
-### Recommended Reading:
-*Social Engineering: The Art of Human Hacking by Christopher Hadnagy* [Amazon](https://www.amazon.com/Social-Engineering-Art-Human-Hacking/dp/0470639539)
-- ISBN-13: 978-0470639535
-
-*The Art of Deception by Kevin Mitnick* [Amazon](https://www.amazon.com/Art-Deception-Controlling-Element-Security/dp/076454280X)
-- ISBN-13: 978-0764542800
diff --git a/client/src/guide/english/software-engineering/version-control-system/index.md b/client/src/guide/english/software-engineering/version-control-system/index.md
deleted file mode 100644
index 8a86659899..0000000000
--- a/client/src/guide/english/software-engineering/version-control-system/index.md
+++ /dev/null
@@ -1,74 +0,0 @@
----
-title: Version Control System
----
-## Version Control System
-
-Version control systems (VCS), also called Source Code Management (SCM), are tools used to track changes on files, manage version and ease collaborative file editing.
-There are mainly 2 types of VCS:
-- Centralized Version Control System
-Where a central repository is authoritative. The associate architecture is client/server.
-The first VCS (CVS, SVN...) were Centralized Version Control System.
-- Distributed Version Control System
-Where multiple repository exchange modification. The associate architecture is mostly peer to peer, but one repo can be declared as authoritative.
-The most used modern VCS (Git, Mercurial...) are Distributed Version Control System.
-
-## What is Version Control?
-
-Version control, also known as revision or source control, is defined as "the task of keeping a software system consisting of many versions and configurations well organized."
-
-Using [Git](https://en.wikipedia.org/wiki/Git) allows for software developers, project managers, and [open source](https://en.wikipedia.org/wiki/Open-source_software) contributors to keep track of changes throughout their [source code](https://en.wikipedia.org/wiki/Source_code). Various websites, such as GitHub, GitLab, and Bitbucket allow for better collaboration across time zones and working locations.
-
-In addition to tracking changes, there are numerous benefits of using version control on your next project. For example, version control allows you to branch out your code with commits (save changes locally) without compromising the original code (master branch).
-
-## Why use it?
-
-- **Changes history** - VCS enable the user to browse and search all the changes which are automatically recorded with useful information (date, author, etc.) and the ability to revert those changes whenever necessary.
-- **Versions/tags** - The user can search/retrieve specific state of the files that have been labeled with tags and version names.
-- **Branching/Merging** - Distributed Version Control System make it easy to maintain parallel branch of files and to merge them partially or totally when needed.
-- **Atomic operations** - All modern VCS provide atomic operations: All modifications are guaranteed to succeed or fail as whole which ensure that the files are always in a consistent state.
-
-## Most popular Version Control System
-
-- Git
-
-*Git* is a Distributed Version Control System and probably the most used VCS used nowadays with *Mercurial*.
-
-- Mercurial
-
-*Mercurial* is a Distributed Version Control System and probably the most used VCS used nowadays with *Git*.
-
-- CVS
-
-*CVS* is an old SCM which was proeminent before *SVN* widespread.
-*CVS* and *SVN* are now deprecated in favor of Distributed Version Control System like *Git* and *Mercurial*.
-
-- SVN/Subversion
-
-*SVM* is an old SCM that succeeded *CVS*.
-Eventually *SVN* was deprecated by the wide adoption of Distributed Version Control System like *Git* and *Mercurial*
-
-## Vocabulary
-* Git
-* Repository
-* Branch
-* Merge Conflict
-* Commit
-* Pull Request
-* [Code Review](https://github.com/freeCodeCamp/freeCodeCamp/blob/master/client/src/guide/english/working-in-tech/code-reviews/index.md)
-* Push
-* Pull
-
-## Resources & Examples
-
-* [GitHub](https://github.com)
-* [GitLab](https://about.gitlab.com/)
-* [Bitbucket](https://bitbucket.org/)
-
-## Want to learn more?
-
-* [CVS](http://savannah.nongnu.org/projects/cvs)
-* [Git](https://git-scm.com/)
-* [GitHub Documentation](https://github.com/features/code-review) : Learn how to write better code and document your changes with version control.
-* [Mercurial](https://www.mercurial-scm.org/)
-* [SVN](http://subversion.tigris.org/)
-* [Version Control on Wikipedia](https://en.wikipedia.org/wiki/Version_control)
diff --git a/client/src/guide/english/sql/sql-count-function/index.md b/client/src/guide/english/sql/sql-count-function/index.md
deleted file mode 100644
index 40adb38908..0000000000
--- a/client/src/guide/english/sql/sql-count-function/index.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: SQL COUNT Aggregate Function
----
-
-## SQL COUNT Aggregate Function
-
-The COUNT operator is usually used in combination with a GROUP BY clause. It is one of the SQL "aggregate" functions, which include AVG (average) and SUM.
-
-This function will count the number of rows and return that count as a column in the result set.
-
-Here are examples of what you would use COUNT for:
-* Counting all rows in a table (no group by required)
-* Counting the totals of subsets of data (requires a Group By section of the statement)
-
-For reference, here is the current data for all the rows in our example student database.
-
-```sql
-select studentID, FullName, programOfStudy, sat_score from student; -- all records with fields of interest
-```
-
-
-
-This SQL statement provides a count of all rows. Note that you can give the resulting COUNT column a name using "AS".
-
-```sql
-select count(*) AS studentCount from student; -- count of all records
-```
-
-
-Here we get a count of students in each field of study.
-
-```sql
- select studentID, FullName, count(*) AS studentCount from the student table with a group by programOfStudy;
-```
-
-
-Here we get a count of students with the same SAT scores.
-```sql
- select studentID, FullName, count(*) AS studentCount from the student table with a group by sat_score;
-```
-
-
-Here is an example using the campaign funds table. This is a sum total of the dollars in each transaction and the number of contributions for each political party during the 2016 US Presidential Campaign.
-
-```sql
-select Specific_Party, Election_Year, format(sum(Total_$),2) AS contribution$Total, count(*) AS numberOfContributions
-from combined_party_data
-group by Specific_Party,Election_Year
-having Election_Year = 2016;
-```
-
-
-
-As with all of these things there is much more to it, so please see the manual for your database manager and have fun trying different tests yourself.
diff --git a/client/src/guide/english/ssh/index.md b/client/src/guide/english/ssh/index.md
deleted file mode 100644
index de1b260647..0000000000
--- a/client/src/guide/english/ssh/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: SSH
----
-## SSH
-
-Secure Shell (SSH) is a cryptographic network protocol intended for secure data transfer over insecure networks.
-
-It is most commonly used for accessing remote servers.
-
-SSH is also used in distributed source code versioning software like git.
diff --git a/client/src/guide/english/svg/index.md b/client/src/guide/english/svg/index.md
deleted file mode 100644
index e529f89e36..0000000000
--- a/client/src/guide/english/svg/index.md
+++ /dev/null
@@ -1,153 +0,0 @@
----
-title: SVG
----
-## SVG
-
-SVG or Scalable Vector Graphics is a web standard for defining vector-based graphics in web pages. Based on XML the SVG standard provides markup to describe paths, shapes, and text within a viewport. The markup can be embedded directly into HTML for display or saved to a `.svg` file and inserted like any other image. You can write SVG by hand, but more complicated graphics can be designed in vector graphics editors such as Illustrator or InkScape and exported to SVG files or code.
-
-## SVG Basics
-Developers start an SVG graphic with the `` tag and XML namespace like so:
-```svg
-
-
-
-```
-The sample also includes a `version` attribute. The `version` attribute is optional but it is recommended for complaince with XML specifications.
-
-This sample won't display anything, it merely established a viewport. You can add `height` and `width` attributes to set a display size for the viewport this essentially establishes a canvas for you to work in.
-
-With a viewport in place you can add basic graphics, text, and path elements.
-
-```svg
-
- SVG Text is browser readable!
-
-
-
-```
-
-You can see the output and play with the code in this codepen .
-
-In the opening `svg` tag we add a width attribute to set the width of the viewport to 100% of the container width, you can use percentages or pixel widths. The opening svg tag also has `viewbox` attribute which defines a window through which elements of your svg are visible, in this case, the viewbox spans from (0,0) to (600,300). In SVG space the X-axis starts with zero on the left and increases to the right; the Y-axis starts with zero at the top and increases towards the bottom.
-
-The first new tag is the `` tag. Attributes assigned to the `` tag, like the `stroke` attribute in the example, will be applied to all elements within the group. In this case three ` element. You can give suchan element width and height attributes to determine its size in pixels.A new canvas is empty, meaning it is entirely transparent and thusshows up simply as empty space in the document.
-The tag is intended to support different styles of drawing.To get access to an actual drawing interface, we first need to create a context, which is an object whose methods provide the drawing interface.There are currently two widely supported drawing styles: "2d" for two-dimensional graphics and "webgl" for three-dimensional graphics through the OpenGL interface.
-
-A context is created through the getContext method on the element.
-```
- Before canvas .
-< canvas width ="120" height ="60" >
- After canvas .
-< script >
-var canvas = document . querySelector (" canvas ") ;
-var context = canvas . getContext ("2 d ") ;
-context . fillStyle = " red ";
-context . fillRect (10 , 10 , 100 , 50) ;
-
-```
-
-
-After creating the context object, the example draws a red rectangle 100
-pixels wide and 50 pixels high, with its top-left corner at coordinates
-(10,10).
-
-### Drawing a pie chart
-
-The results variable contains an array of objects that represent the
-survey responses.
-```
-var results = [
-{ name : " Satisfied " , count : 1043 , color : " lightblue "} ,
-{ name : " Neutral " , count : 563 , color : " lightgreen "} ,
-{ name : " Unsatisfied " , count : 510 , color : " pink "} ,
-{ name : " No comment " , count : 175 , color : " silver "}
-];
-```
-To draw a pie chart, we draw a number of pie slices, each made up of an arc and a pair of lines to the center of that arc. We can compute the angle taken up by each arc by dividing a full circle (2 π ) by the total number of responses and then multiplying that number (the angle per response) by the number of people who picked a given choice.
-```
-< canvas width ="200" height ="200" >
-< script >
-var cx = document . querySelector (" canvas ") . getContext ("2 d ") ;
-var total = results . reduce ( function ( sum , choice ) {
-return sum + choice . count ;
-} , 0) ;
-
-// Start at the top
-
-var currentAngle = -0.5 * Math . PI ;
-results . forEach ( function ( result ) {
-var sliceAngle = ( result . count / total ) * 2 * Math . PI ;
-cx . beginPath () ;
-// center =100 ,100 , radius =100
-// from current angle , clockwise by slice ' s angle
-cx . arc (100 , 100 , 100 ,
-currentAngle , currentAngle + sliceAngle );
-currentAngle += sliceAngle ;
-cx . lineTo (100 , 100) ;
-cx . fillStyle = result . color ;
-cx . fill () ;
-}) ;
-
-```
-This draws the following chart:
-
-### Browser Support
-
-[Browser support for SVG](https://caniuse.com/#feat=svg) is available in all modern browsers. There are some issues with scaling in IE 9 through IE 11 however they can be overcome with the use of the `width`, `height`, `viewbox`, and CSS.
-
-## Editors
-
-* [Vectr](https://vectr.com) - web and desktop tool fot creating and editing SVG graphics, free of charge
-
-## Tools to create SVG
-
-There are few tools available to create SVG in the form of drawing program.
-
-- Inkscape - It is an open source tool for state-of-the-art vector drawing with an easy to use graphical interface.
-- Adobe Illustrator - Adobe Illustrator is a commercial tool for Vector Imagery.
-
-For more tools, refer to W3C list of tools that supports SVG
-
-## Why you should use SVGs
-
-As a vector image format, it allows you to resize an image without any loss of quality and a particularly light weight.
-As an XML format, it allows you to benefit from the full power of JavaScript and especially CSS.
-
-## Resources
-
-- W3C, Scalable Vector Graphics (SVG) 1.1 (Second Edition)
-- Mozilla Developer Network, SVG
diff --git a/client/src/guide/english/swift/constants/index.md b/client/src/guide/english/swift/constants/index.md
deleted file mode 100644
index 61b24df49d..0000000000
--- a/client/src/guide/english/swift/constants/index.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: Constants
----
-## Constants
-
-A constant associates a name with a value of a particular type.
-
-#### Example:
-```swift
-let name = "Chris Lattner"
-```
-
-You declare constants with the `let` keyword then give it a name `name` then you use an assignment operator `=` to assign the value `"Chris Lattner"` to the constant `name`.
-
-Once you have declared a constant you don't need to use the `let` keyword anymore you just call it by its name.
-
-The value of a constant can’t be changed once it’s set.
-
-#### More Information:
-- The Swift Programming Language
diff --git a/client/src/guide/english/swift/functions/index.md b/client/src/guide/english/swift/functions/index.md
deleted file mode 100644
index 223e1513a8..0000000000
--- a/client/src/guide/english/swift/functions/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Functions
----
-## Functions
-
-Functions in Swift consists of a parameter and a return type. Functions can be created by using this basic structure:
- ```Swift
- func sayHello(nameOfPerson: String) -> String {
- let hello = "Hello, " + nameOfPerson + "."
- print(hello)
- }
-
- sayHello(nameOfPerson: "Steve")
- ```
-In this example, the function sayHello takes in a string name and prints out the phrase `"Hello, Steve."`.
-
-## Function Parameters
-
-Functions do not require any input parameters or return types. However this require the parentheses after naming the functions.
- ```Swift
- func helloSteve() {
- print("Hello, Steve.")
- }
-
- helloSteve() // This prints out "Hello, Steve."
- ```
diff --git a/client/src/guide/english/terminal-commandline/macos-terminal/index.md b/client/src/guide/english/terminal-commandline/macos-terminal/index.md
deleted file mode 100644
index d494e3fd08..0000000000
--- a/client/src/guide/english/terminal-commandline/macos-terminal/index.md
+++ /dev/null
@@ -1,74 +0,0 @@
----
-title: Mac OS Terminal
----
-
-
-# Using the Terminal in Mac OS
-
-Most of the time users interact through a Graphical User Interface to interact with the computer. You use the mouse to point and click to open, move, or create new files or open applications. But, you can also use the Terminal Application to interact with your machine through written commands. When you use the terminal, it allows you to dig deeper and customize in a way not possible through the GUI.
-
-### Opening the Terminal and Navigating Directories
-Your terminal exists in the Applications directory. Open your Terminal app. You should see a prompt in the terminal window. it shoudl have the computer's name (ABC's Macbook), followed by the User name (ABC), and then a '$.' If you are in the root directory, the last character will be a '#.'
-
-To see what directory you are working in, just type the command
-
-```pwd```
-
-pwd stands for "Print Working Directory." Directory is another word for folder.
-
-If you want to list the contents of your directory use the command:
-
-```ls```
-
-To switch to a new directory you use the command:
-
-```cd```
-
-which stands for change directory.
-
-Here is a list of common commands:
-
-Command | Usage
------------- | -------------
-pwd | Print Working Directory (Where Am I? )
-ls | List contents of current directory
-mkdir | Create a new directory
-touch | Create a new file
-cp| Copy a file
-rm | Remove a file
-rm -rf | Remove a directory
-
-### Usage Examples
-
-Some of the aforementioned commands aren't clear without examples. Below are a few usage examples to help provide you with some context.
-
-#### Making a Directory
-
-```mkdir #YOUR-NEW-FOLDER-NAME-HERE```
-
-#### Making a File
-
-``` touch YOUR-FILE-NAME.JS```
-
-You can make a file with any extension you choose. As long as it is in an a format accepted by the folder or machine.
-
-#### Copying a File
-
-Use the following syntax to copy a file from the terminal:
-
-**cp _source_ _destination_**
-
-For example, if we have a file, _'test.txt'_ that is stored in our _/Desktop_ directory and we want to copy it to the _/Documents_ folder, our command would look like this:
-
- cp ~/Desktop/test.txt ~/Documents
-
-#### Deleting a File
-
-Use the following syntax to delete a file
-
-**rm _#PATH_TO_FILE_**
-
-
-
-
-
diff --git a/client/src/guide/english/typescript/enums/index.md b/client/src/guide/english/typescript/enums/index.md
deleted file mode 100644
index b772e621e5..0000000000
--- a/client/src/guide/english/typescript/enums/index.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: Enums
----
-
-## Enums
-
-Developers can use `Enums` to define a set of named constants.
-
-There are two types of `Enums`
-
-1. numeric
-1. string-based
-
-```typescript
-// numeric enum
-enum NumericEnum {
- numeric1 = 1,
- numeric2,
- numeric3,
- numeric4,
-}
-
-// string based enum
-enum StringBasedEnum {
- Programming = "is fun",
- Pizza = "is good"
-}
-
-// Heterogeneous based enum
-enum HeterogeneousBasedEnum {
- Day = 2,
- Pizza = "is good"
-}
-
-
-```
-
-Like Constants Enums are ready only. its imperative to understand that the benefit of using an Enum vs a Constant is it allow developers to organize collections of related values.
diff --git a/client/src/guide/english/user-experience-design/hicks-law/index.md b/client/src/guide/english/user-experience-design/hicks-law/index.md
deleted file mode 100644
index e041b209ef..0000000000
--- a/client/src/guide/english/user-experience-design/hicks-law/index.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: Hicks Law
----
-## Hicks Law
-Hick’s law states that the time it takes to make a decision increases as the number of alternatives increase. It's named after British and American psychologists William Edmund Hick and Ray Hyman.
-
-### Understanding Hick's Law with an Example
-Do you remember the old video games from over 20 years ago, and how much fun it was to play them? The controls were so simple you could learn to play in seconds. For example, Super Mario with just left, right, and jump controls.
-
-In comparison, today’s input controls of modern gaming consoles and PC games have many choices and combinations. All these controls multiply the available options that a user can choose in any certain situation.
-
-Having so many options makes learning the game and enjoying it much harder and time-consuming.
-
-### What it means in UX Design
-Hick’s law can be used to narrow down big volumes of information without overloading the user. When you need to simplify a complex process, use Hick’s law. Present specific parts of that process at any one time on the screen.
-
-An example can be a payment process. Instead of showing everything at once, you can break it down. Show the screen with shopping cart details, then another with delivery information, then optional account creation, and so on.
-
-Reducing the number of perceived options on the screen makes the interface more user-friendly. It is also more likely that the user will accomplish the goal and not give up or get confused.
-
-**It is important to point out not to oversimplify!** Breaking down choices to a series of too many small chunks can also cause the user to drop off before reaching the goal.
-
-### More Information:
-
-Hicks' Law - Wikipedia
-
-Design Principles: Hick's Law - uxplanet
-
-Understanding Hick's Law - Youtube
diff --git a/client/src/guide/english/user-experience-design/index.md b/client/src/guide/english/user-experience-design/index.md
deleted file mode 100644
index 1f2471b706..0000000000
--- a/client/src/guide/english/user-experience-design/index.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: User Experience Design
----
-## User Experience Design
-
-User Experience Design is a field that focuses on how the end users of a product interact with it, and how they feel about the product.
-
-In this section, we'll have guides to a wide variety of user experience design concepts.
-
-#### Articles for Resources and Inspiration for User Experience Design
-
-[Boxes & Arrows](http://boxesandarrows.com)
-[Usabilla](http://blog.usabilla.com)
-
-#### Textbook for User Experience Design
-
-[Interaction Design: Beyond Human-Computer Interaction (4th Edition) - Amazon](https://www.amazon.com/Interaction-Design-Beyond-Human-Computer/dp/1119020751)
-
-#### Mostly Free Online UX Design Curriculum
-
-[Springboard Learning Path: User Experience Design - Julia Debari](https://www.springboard.com/learning-paths/user-experience-design/learn/#)
diff --git a/client/src/guide/english/user-experience-design/user-flow/index.md b/client/src/guide/english/user-experience-design/user-flow/index.md
deleted file mode 100644
index adc8fe4626..0000000000
--- a/client/src/guide/english/user-experience-design/user-flow/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: User Flow
----
-## User Flow
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/guide/english/vagrant/index.md b/client/src/guide/english/vagrant/index.md
deleted file mode 100644
index b4a079975b..0000000000
--- a/client/src/guide/english/vagrant/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Vagrant
----
-## Vagrant
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/guide/english/vim/basic-usage/index.md b/client/src/guide/english/vim/basic-usage/index.md
deleted file mode 100644
index 115f1d24e6..0000000000
--- a/client/src/guide/english/vim/basic-usage/index.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: Basic Usage
----
-## VIM Basic Usage
-
-### Open File
-- Run vim or vi and open the given filename.
-
-### Insert Mode
-- Once opening the page enter I and you will see the text "Insert Mode" at the bottom of your screen. From here you can make any changes you want to the text of your file.
-
-### Save File
-- :w
-
-### Save and Exit
-- :x
-- SHIFT ZZ
-- :wq
-
-### Exit file if no changes made
-- :q
-
-### Exit file and undo any changes made
-- :q!
-
-### Display line numbers
-- :set nu
-
-### Don't display line numbers
-- :set nonu
-
-### Add syntax color based on prog language used
-- :syntax on
-
-## About Vim
-Vim is the text editor basically used in CLI mode . But now the editor is also available in various versions. There have
-also GVIM which is the graphical version of VIM. vi was the main editor then its improved & named it VI improved Vim.
-
diff --git a/client/src/guide/english/vim/index.md b/client/src/guide/english/vim/index.md
deleted file mode 100644
index 73f8960e98..0000000000
--- a/client/src/guide/english/vim/index.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: Vim
----
-# Vim
-
-
-
-Vim (Vi IMproved) is a highly configurable text editor built to make creating and changing any kind of text very efficient. It is included as "vi" with most UNIX systems, which also includes Apple's macOS. Vim is a major improvement over its predecessor *vi*, which was developed over 40 years ago, and it is still being used.
-
-Vim is rock stable and boasts many features including:
-- persistent, multi-level undo tree
-- extensive plugin system
-- support for hundreds of programming languages and file formats
-- powerful search and replace
-- integrates with many tools
-- built-in macro support for automation text manipulation
-- usable on systems that lack support for GUI based text editors
-
-One of the main differences that Vim (and its predecessor, *vi*) have over other editors like *nano*, is that it is a _modal editor_, which means that it have several modes of operation. For example, the editor starts in *Navigation Mode*, which allows you to quickly move around the document (or, more accurately _blazingly fast_). In this mode, you can enter commands to interact with your document, like using `:i` to enter `insert mode`, `:q` to quit, `/` to search text, among others.
-
-The modal part of Vim is what makes it really powerful. For a interactive tutorial, please visit [OpemVim](http://www.openvim.com/). Here you can try for yourself several of its more powerful features.
-
-## More information
-
-For more information head to Vim's homepage
-
-* [Open Vim](http://www.openvim.com/) is an online, interactive Vim tutorial you can do right in your browser
-* [Vim Adventures](https://vim-adventures.com) is an online game based on VIM's keyboard shortcuts. It's the "Zelda meets text editing" game.
diff --git a/client/src/guide/english/vim/navigation/index.md b/client/src/guide/english/vim/navigation/index.md
deleted file mode 100644
index 9fed69aa02..0000000000
--- a/client/src/guide/english/vim/navigation/index.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: Navigation
----
-
-## Vim Navigation
-
-### Basic movement
-
-There are many ways to move the cursor in Vim, but these basic movements will allow
-new users to get comfortable using normal mode for file navigation.
-
-* In normal mode, the keys `h`, `j`, `k` , `l` correspond to moving the cursor
-one character left, down, up, and right, respectively.
-
-* To navigate one word at a time, the keys `w`, and `b` will move the cursor to
-the beginning of the next word, or the beginning of the previous word. The `e`
-key will move the cursor to the end of the current word.
-
-* To move to the beginning of the current line, type `0`, and to move to the end
-of the current line, type `$`.
-
-* Finally, to move to the first line in the file, type `gg`, and to move to the
-last line in the file, type `G`.
-
-In summary:
-
-```vim
-h moves one character left
-j moves one row down
-k moves one row up
-l moves one character right
-
-w moves to the beginning of the next word
-b moves to the beginning of the previous word
-e moves to the end of the current word
-
-0 moves to the beginning of the current line
-$ moves to the end of the current line
-:n moves to line n (ex. :23 moves to line 23) can also use nG
-
-ZZ moves to the center of the line your on
-H moves to the top of the screen
-M moves to the middle of the screen
-L moves to the bottom of the screen
-
-gg moves to the first line in the file
-G moves to the last line in the file
-```
-
diff --git a/client/src/guide/english/virtualbox/index.md b/client/src/guide/english/virtualbox/index.md
deleted file mode 100644
index d02960b92b..0000000000
--- a/client/src/guide/english/virtualbox/index.md
+++ /dev/null
@@ -1,77 +0,0 @@
----
-title: VirtualBox
----
-# VirtualBox
-body tag.
-```html
-Skip to Main Content
-```
-tabindex="0" is added to ensure the link is keyboard focusable on all browsers. Further information about keyboard accessibility can be found at [webaim.org](https://webaim.org/techniques/keyboard/tabindex).
-2. The "skip navigation" link needs to be associated with the main html tag in your webpage document using the ID tag.
-```html
-
- ...page content
-
-```
-3. Hide the "skip navigation" link by default.
-This ensures that the link is only visible to sighted users when the link is in focus.
-- Create a class for the link that can be styled with CSS. In my example I have added the class skip-link.
-```css
-.skip-link {
- position: absolute;
- width: 1px;
- height: 1px;
- padding: 0;
- overflow: hidden;
- clip: rect(0, 0, 0, 0);
- white-space: nowrap;
- -webkit-clip-path: inset(50%);
- clip-path: inset(50%);
- border: 0;
-}
-.skip-link:active, .skip-link:focus {
- position: static;
- width: auto;
- height: auto;
- overflow: visible;
- clip: auto;
- white-space: normal;
- -webkit-clip-path: none;
- clip-path: none;
-}
-```
-These CSS styles hide the link by default and only display the link when it is receiving keyboard focus. For more information visit the [a11yproject](http://a11yproject.com/posts/how-to-hide-content) and this [blog post](http://hugogiraudel.com/2016/10/13/css-hide-and-seek/).
-
-
-### Accessible Tables
-### Accessible Tabs
diff --git a/client/src/pages/guide/english/accessibility/automated-testing/index.md b/client/src/pages/guide/english/accessibility/automated-testing/index.md
deleted file mode 100644
index da681f48ca..0000000000
--- a/client/src/pages/guide/english/accessibility/automated-testing/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Automated Accessibility Testing Tools
----
-## Automated Accessibility Testing
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
diff --git a/client/src/pages/guide/english/accessibility/index.md b/client/src/pages/guide/english/accessibility/index.md
deleted file mode 100644
index 0c2151a912..0000000000
--- a/client/src/pages/guide/english/accessibility/index.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: Accessibility
----
-## Accessibility
-Web accessibility means that people with disabilities can use the Web .
-
-More specifically, Web accessibility means that people with disabilities can perceive, understand, navigate, and interact with the Web, and that they can
-contribute to the Web. Web accessibility also benefits others, including [older people](https://www.w3.org/WAI/bcase/soc.html#of) with changing abilities
-due to aging.
-
-Web accessibility encompasses all disabilities that affect access to the Web, including visual, auditory, physical, speech, cognitive, and neurological
-disabilities. The document [How People with Disabilities Use the Web](http://www.w3.org/WAI/intro/people-use-web/Overview.html) describes how different
-disabilities affect Web use and includes scenarios of people with disabilities using the Web.
-
-Web accessibility also **benefits** people *without* disabilities. For example, a key principle of Web accessibility is designing Web sites and software
-that are flexible to meet different user needs, preferences, and situations. This **flexibility** also benefits people *without* disabilities in certain
-situations, such as people using a slow Internet connection, people with "temporary disabilities" such as a broken arm, and people with changing abilities
-due to aging. The document [Developing a Web Accessibility Business Case for Your Organization](https://www.w3.org/WAI/bcase/Overview) describes many
-different benefits of Web accessibility, including **benefits for organizations**.
-
-Web accessibility should also include the people who don't have access to the internet or to computers.
-
-A prominent guideline for web development was introduced by the [World Wide Web Consortium (W3C)](https://www.w3.org/), the [Web Accessibility Initiative](https://www.w3.org/WAI/)
-from which we get the [WAI-ARIA](https://developer.mozilla.org/en-US/docs/Learn/Accessibility/WAI-ARIA_basics), the Accessible Rich Internet Applications Suite.
-Where WAI tackles the semantics of html to more easily nagivate the DOM Tree, ARIA attempts to make web apps, especially those developed with javascript and
-AJAX, more accessible.
-
-The use of images and graphics on websites can decrease accessibility for those with visual impairments. However, this doesn't mean designers should avoid
-using these visual elements. When used correctly, visual elements can convey the appropriate look and feel to users without disabilities and should be used
-to do so. In order to use these elements appropriately, web designers must use alt text to communicate the message of these elements to those who cannot see
-them. Alt text should be short and to the point--generally [no more than five to 15 words](https://www.thoughtco.com/writing-great-alt-text-3466185). If a
-graphic is used to convey information that exceeds the limitations of alt text, that information should also exist as web text in order to be read by screen
-readers. [Learn more about alt text](https://webaim.org/techniques/alttext/).
-
-Just like Alt text is for people who are visually impaired, transcripts of the audio are for the people who cannot listen. Providing a written document or a transcript of what is being spoken accessible to people who are hard of hearing.
-
-Copyright © 2005 World Wide Web Consortium , (MIT , ERCIM , Keio ,Beihang ). http://www.w3.org/Consortium/Legal/2015/doc-license
-
-### More Information:
-w3.org introduction to accessibility.
-The A11Y Project
diff --git a/client/src/pages/guide/english/agile/acceptance-criteria/index.md b/client/src/pages/guide/english/agile/acceptance-criteria/index.md
deleted file mode 100644
index 4c2d020e6b..0000000000
--- a/client/src/pages/guide/english/agile/acceptance-criteria/index.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: Acceptance Criteria
----
-## Acceptance Criteria
-
-The User Story, as an item in your backlog, is a placeholder for a conversation. In this conversation,
-the Product Owner and the Delivery Team reach an understanding on the desired outcome.
-
-The Acceptance Criteria tells the Delivery Team how the code should behave. Avoid writing the **"How"** of the User Story; keep to the **"What"**.
-If the team is following Test Driven Development (TDD), it may provide the framework for the automated tests.
-The Acceptance Criteria will be the beginnings of the test plan for the QA team.
-
-Most importantly, if the story does not meet each of the Acceptance Criteria, then the Product Owner should not be accepting the story at the end of the iteration.
-
-Acceptance criteria can be viewed as an instrument to protect the Delivery Team. When the Delivery Team commits to a fixed set of stories in the Sprint planning they commit to fixed set of acceptance criteria as well. This helps to avoid scope creep.
-
-Consider the following situation: when accepting the user story the Product Owner suggests adding something that was not in the scope of the User story. In this case the Delivery team is in the position to reject this request (however small it might be) and ask the Product owner to create a new User story that can be taken care of in another Sprint.
-
-
-#### More Information:
-
-Nomad8 provides an [FAQ on Acceptance Criteria](https://nomad8.com/acceptance_criteria/)
-
-Leading Agile on [Acceptance Criteria](https://www.leadingagile.com/2014/09/acceptance-criteria/)
diff --git a/client/src/pages/guide/english/agile/actual-time-estimation/index.md b/client/src/pages/guide/english/agile/actual-time-estimation/index.md
deleted file mode 100644
index 7d56f7447f..0000000000
--- a/client/src/pages/guide/english/agile/actual-time-estimation/index.md
+++ /dev/null
@@ -1,53 +0,0 @@
----
-title: Actual Time Estimation
----
-## Actual Time Estimation
-
-Actual Time Estimation is the process of predicting the most realistic amount of effort (expressed in terms of person-hours or money) required to develop or maintain software based on incomplete, uncertain and noisy input. Effort estimates may be used as input to project plans, iteration plans, budgets, investment analyses, pricing processes and bidding rounds.
-
-### State-of-practice
-
-Published surveys on estimation practice suggest that expert estimation is the dominant strategy when estimating software development effort.
-
-Typically, effort estimates are over-optimistic and there is a strong over-confidence in their accuracy. The mean effort overrun seems to be about 30% and not decreasing over time. For a review of effort estimation error surveys, see. However, the measurement of estimation error is problematic, see Assessing the accuracy of estimates. The strong overconfidence in the accuracy of the effort estimates is illustrated by the finding that, on average, if a software professional is 90% confident or “almost sure” to include the actual effort in a minimum-maximum interval, the observed frequency of including the actual effort is only 60-70%.
-
-Currently the term “effort estimate” is used to denote as different concepts as most likely use of effort (modal value), the effort that corresponds to a probability of 50% of not exceeding (median), the planned effort, the budgeted effort or the effort used to propose a bid or price to the client. This is believed to be unfortunate, because communication problems may occur and because the concepts serve different goals.
-
-### History
-
-Software researchers and practitioners have been addressing the problems of effort estimation for software development projects since at least the 1960s; see, e.g., work by Farr and Nelson.
-
-Most of the research has focused on the construction of formal software effort estimation models. The early models were typically based on regression analysis or mathematically derived from theories from other domains. Since then a high number of model building approaches have been evaluated, such as approaches founded on case-based reasoning, classification and regression trees, simulation, neural networks, Bayesian statistics, lexical analysis of requirement specifications, genetic programming, linear programming, economic production models, soft computing, fuzzy logic modeling, statistical bootstrapping, and combinations of two or more of these models.
-
-The perhaps most common estimation methods today are the parametric estimation models COCOMO, SEER-SEM and SLIM. They have their basis in estimation research conducted in the 1970s and 1980s and are since then updated with new calibration data, with the last major release being COCOMO II in the year 2000. The estimation approaches based on functionality-based size measures, e.g., function points, is also based on research conducted in the 1970s and 1980s, but are re-calibrated with modified size measures and different counting approaches, such as the use case points or object points in the 1990s and COSMIC in the 2000s.
-
-Actual time estimation is a time-based method of estimating development work.
-
-It is critically important to be able to estimate the time-to-completion of an Agile project, unfortunately, it is also one of the most difficult parts of planning an Agile project.
-
-Its intent is to best approximate the amount of time required to complete a given development task.
-
-One technique you may use is to estimate the time it will take to complete user stories. When you are doing this, remember to consult with other members of your agile team. For each user story, make sure that you estimate a time that is realistic and feasible, yet not so much that the client is overcharged for simple work. Consult members of your team so that you may be able to leverage their expertise to be able to understand how much work is required and how long it will take. When you have a consensus for each user story, you can add up the times to come up with a time estimation.
-
-As the requirements of the project change over time, you can update the estimate. If a project loses some resources originally allocated to it, you may need to cut user stories to be able to complete them in the same amount of total time. Similarly, if you want to improve the quality of the app, you may need to allocate more time to each user story to make sure your team has time to finish the app with the desired quality.
-
-Generally, these estimates are calculated using ideal engineering hours.
-
-Examples:
-
-**This task will be complete in 10 days.**
-
-Or…
-
-**This task will be complete by January 10th.**
-
-Or…
-
-**This task will require 25 development hours for completion.**
-
-### More Information:
-
-- [Agile Constraints](http://www.brighthubpm.com/agile/50212-the-agile-triangle-value-quality-and-constraints/)
-
-- [How do you estimate on an Agile project?](http://info.thoughtworks.com/rs/thoughtworks2/images/twebook-perspectives-estimation_1.pdf)
-
diff --git a/client/src/pages/guide/english/agile/alignment/index.md b/client/src/pages/guide/english/agile/alignment/index.md
deleted file mode 100644
index 178887f1bb..0000000000
--- a/client/src/pages/guide/english/agile/alignment/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Alignment
----
-## Alignment
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/pages/guide/english/agile/application-lifecycle-management/index.md b/client/src/pages/guide/english/agile/application-lifecycle-management/index.md
deleted file mode 100644
index 8b0a38e9e5..0000000000
--- a/client/src/pages/guide/english/agile/application-lifecycle-management/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Application Lifecycle Management
----
-## Application Lifecycle Management
-
-Application Lifecycle Management (ALM), while commonly associated with Software Development Lifecycle (SDLC) is a broader perspective that aligns better with the concept of Product Lifecycle. The development (SDLC) is only a portion of the Application's Lifecycle and therefore is represented as part of the ALM.
-
-ALM can be divided into three distinct areas: Governance, Development, and Operations:
-
-Governance: Encompasses all of the decision making and project management for this application, extends over the entire existance of the application.
-
-Development: Process (SDLC) of actually creating the application. For most applications, the development process reappears again several more times in the application’s lifetime, including bug fixes, improvements and new versions.
-
-Operations: Work required to run and manage the application,typically begins shortly before deployment, then runs continuously until application retirement. Overlaps at times with Development.
-
-Tools can be used to manage ALM; some of the more popular options include:
-
-* Atlassian [JIRA](http://atlassian.com/software/jira)
-* CA Technologies [Rally](http://ca.com/us.html)
-* [Thoughtworks](http://thoughtworks.com/products)
-
-#### More Information:
-
-InfoQ - Gartner and Software Advice examine [Agile Lifecycle Management Tools](http://www.infoq.com/news/2015/02/agile-management-tools/)
-
-
diff --git a/client/src/pages/guide/english/agile/architectural-runway/index.md b/client/src/pages/guide/english/agile/architectural-runway/index.md
deleted file mode 100644
index 7c198dfb5e..0000000000
--- a/client/src/pages/guide/english/agile/architectural-runway/index.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Architectural Runway
----
-The architectural runway is setting everything up the program would need before the project is started. This allows developers to hit the ground running.
-
-
diff --git a/client/src/pages/guide/english/agile/backlog-emergence-and-grooming/index.md b/client/src/pages/guide/english/agile/backlog-emergence-and-grooming/index.md
deleted file mode 100644
index 8ddf742276..0000000000
--- a/client/src/pages/guide/english/agile/backlog-emergence-and-grooming/index.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: Backlog Emergence and Refinement
----
-## Backlog Emergence and Refinement
-
-Product backlog refinement is an on going process that needs to be in sync with the product discovery process. Generally, a Scrum team will collaboratively refine product backlog items for the next two to three sprints.
-
-A product owner (individual responsible for clarifying a sprint's goal) defines the scope of the upcoming sprints by identifying and triaging the most valuable user stories in the product backlog. A product owner is more than a glorified project manager of the product backlog, and performs more roles than simply user stories on behalf of stakeholders.
-
-From the Scrum Guide:
-Product Backlog refinement is the act of adding detail, estimates, and order to items in the Product Backlog. This is an ongoing process in which the Product Owner and the Development Team collaborate on the details of Product Backlog items. During Product Backlog refinement, items are reviewed and revised.
-
-The Scrum Team decides how and when refinement is done. Refinement usually consumes no more than 10% of the capacity of the Development Team. However, Product Backlog items can be updated at any time by the Product Owner or at the Product Owner’s discretion. The objective of refinement is to have enough Product Backlog items "Ready" for the next Sprint's Sprint Planning. Generally, a scrum team will collaboratively refine product backlog items for the next two to three sprints.
-
-Backlog emergence and refinement are essential tasks for every scrum team. The Product Owner defines the scope of the upcoming sprints by identifying and triaging the most valuable user stories in the product backlog. Although the Product Owner is in charge of keeping the product backlog at peak value delivery, they need the assistance of the entire Scrum Team to do so. Changing the Sprint Backlog is part of the ongoing Sprint and is not considered Refinement.
-
-#### More Information:
-- [Optimizing Product Backlog Refinement](https://www.scrum.org/resources/blog/optimizing-product-backlog-refinement)
-- Scrum Guide (http://www.scrumguides.org/)
-
diff --git a/client/src/pages/guide/english/agile/backlog-item-effort/index.md b/client/src/pages/guide/english/agile/backlog-item-effort/index.md
deleted file mode 100644
index 582e2c3e83..0000000000
--- a/client/src/pages/guide/english/agile/backlog-item-effort/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Backlog Item Effort
----
-## Backlog Item Effort
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/pages/guide/english/agile/behavior-driven-development/index.md b/client/src/pages/guide/english/agile/behavior-driven-development/index.md
deleted file mode 100644
index f4c5efcb08..0000000000
--- a/client/src/pages/guide/english/agile/behavior-driven-development/index.md
+++ /dev/null
@@ -1,62 +0,0 @@
----
-title: Behavior Driven Development
----
-## Behavior Driven Development
-
-Behavior Driven Development (BDD) is a software development process that emerged from .
-Behavior Driven Development combines the general techniques and principles of TDD with ideas from domain-driven design and object-oriented analysis and design to provide software development and management teams with shared tools and a shared process to collaborate on software development.
-It is a software development methodology in which an application is specified and designed by describing how its behavior should appear to an outside observer.
-
-Although BDD is principally an idea about how software development should be managed by both business interests and technical insight, the practice of BDD does assume the use of specialized software tools to support the development process.
-
-Although these tools are often developed specifically for use in BDD projects, they can be seen as specialized forms of the tooling that supports test-driven development. The tools serve to add automation to the ubiquitous language that is a central theme of BDD.
-
-BDD focuses on:
-- Where to start in the process
-- What to test and what not to test
-- How much to test in one go
-- What to call the tests
-- How to understand why a test fails
-
-At the heart of BDD is a rethinking of the approach to the unit testing and acceptance testing that naturally arise with these issues.
-For example, BDD suggests that unit test names be whole sentences starting with a conditional verb ("should" in English for example) and should be written in order of business value.
-Acceptance tests should be written using the standard agile framework of a user story: "As a _role_ I want _feature_ so that _benefit_".
-Acceptance criteria should be written in terms of scenarios and implemented as classes: Given _initial context_, when _event occurs_, then _ensure some outcomes_.
-
-Example
-
-```
-Story: Returns go to stock
-
-As a store owner
-In order to keep track of stock
-I want to add items back to stock when they're returned.
-
-Scenario 1: Refunded items should be returned to stock
-Given that a customer previously bought a black sweater from me
-And I have three black sweaters in stock.
-When he returns the black sweater for a refund
-Then I should have four black sweaters in stock.
-
-Scenario 2: Replaced items should be returned to stock
-Given that a customer previously bought a blue garment from me
-And I have two blue garments in stock
-And three black garments in stock.
-When he returns the blue garment for a replacement in black
-Then I should have three blue garments in stock
-And two black garments in stock.
-```
-Along with it are some Benefites:
-
-1. All development work can be traced back directly to business objectives.
-2. Software development meets user need. Satisfied users = good business.
-3. Efficient prioritisation - business-critical features are delivered first.
-4. All parties have a shared understanding of the project and can be involved in the communication.
-5. A shared language ensures everyone (technical or not) has thorough visibility into the project’s progression.
-6. Resulting software design that matches existing and supports upcoming business needs.
-7. Improved quality code reducing costs of maintenance and minimising project risk.
-
-## More Information
-* Wiki on BDD
-* A well-known Behavior Driven Development (BDD) framework is [Cucumber](https://cucumber.io/). Cucumber supports many programming languages and can be integrated with a number of frameworks; for example, [Ruby on Rails](http://rubyonrails.org/), [Spring Framework](http://spring.io/) and [Selenium](http://www.seleniumhq.org/)
-* https://inviqa.com/blog/bdd-guide
diff --git a/client/src/pages/guide/english/agile/build-measure-learn/index.md b/client/src/pages/guide/english/agile/build-measure-learn/index.md
deleted file mode 100644
index c71a26ff99..0000000000
--- a/client/src/pages/guide/english/agile/build-measure-learn/index.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: Build Measure Learn
----
-## Build Measure Learn
-
-The Build-Measure-Learn loop is a method used to build the right product. Coined in the "Lean Startup" book by Eric Reis, the loop enables rapid experimenting, in the sole purpose of achieving market fit. In other words, it is a powerful system to validate assumptions concerning a product you set out to deliver. Breaking down the loop, it consists of the following parts:
-
-
-
-### Idea
-Each loop starts with an idea that will supply business value to some users. Such idea must be consisted of a vision for a product - which will direct you at what to build, and a metric that will point out to whether your assumptions about the business value were correct.
-
-### Build
-To validate your idea, you set out to build a Minimal Viable Product (MVP), combined with predefined metrics (one is preferred), whose purpose is to validate your theory, and help you decide whether you should preserve or pivot.
-
-### Measure
-This stage is focused on collecting data & metrics from the MVP.
-
-### Learn
-Next, using the data collected, a decision has to be made, whether or not your product is used by users and so you should preserve, or whether users are not interested in the product, and as such you must pivot. The learn phase is therefore ending with an idea (either how to expand the product, or how to pivot from the original product), applicable for the next Build Measure Learn loop.
-
-#### More Information:
-[Why Build, Measure, Learn – isn’t just throwing things against the wall to see if they work – the Minimal Viable Product](https://steveblank.com/2015/05/06/build-measure-learn-throw-things-against-the-wall-and-see-if-they-work/)
-[The Build-Measure-Learn Feedback Loop](https://www.mindtools.com/pages/article/build-measure-learn.htm)
diff --git a/client/src/pages/guide/english/agile/burndown-charts-and-burnup-charts/index.md b/client/src/pages/guide/english/agile/burndown-charts-and-burnup-charts/index.md
deleted file mode 100644
index 9f6492cf8a..0000000000
--- a/client/src/pages/guide/english/agile/burndown-charts-and-burnup-charts/index.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: Burndown Charts and Burnup Charts
----
-## Burndown Charts and Burnup Charts
-
-Burndown and burnup charts are used to measure progress of a project-- usually a development sprint under the Agile methodology. Both charts visually represent work versus time.
-
-Burndown charts show how much work is left to be done versus the amount of time remaining. The Y axis represents work left to be done-- usually relating to a time estimate assigned to each task, e.g. story points-- and the X axis represents time left. Two lines are used; the first-- "Ideal Work Remaining Line"-- represents an ideal burndown, where each day an amount of work proportional to the total amount of time is completed, resulting in a straight line. The second "Actual Work Remaining Line" is used to plot actual progress as taks move through development to a done state. An example of a burndown chart is shown below.
-
-
-
-Many Scrum Teams use burndown charts in order to see how they are doing during the sprint. Having an even and steady burndown might be an indicator that the stories are small and manageable. If a team notices in the middle of a sprint that the "Actual Work Remaining Line" is above the "Ideal Work Remaining Line" they can make adjustments to the scope: stories can be taken out of the sprint or the scope of stories can be made smaller. Looking at the burndown during the retrospective in the end of the sprint might spark some interesting discussions and result in process improvements.
-
-Burnup charts are very similar, but they show the work that has been completed versus the total amount of work and time remaining. Three lines are used-- an ideal line, a completed work line, and a total work line. In this chart, the total work line should be somewhat steady across the top of the chart, and is a good representation of scope change. The completed work line should move steadily up towards the total work line for the amount of time in the project-- its ideal trajectory is shown by the ideal line. An example is shown below.
-
-
-
-
-#### More Information:
-Burndown Charts- Wikipedia
-Burn up vs burn down chart- LinkedIn
-
-
diff --git a/client/src/pages/guide/english/agile/business-value/index.md b/client/src/pages/guide/english/agile/business-value/index.md
deleted file mode 100644
index 63d6b9a734..0000000000
--- a/client/src/pages/guide/english/agile/business-value/index.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Business Value
----
-## Business Value
-
-Business Value is the focus of agile delivery. The agile team is charged with evaluating the business value of all work.
-
-Business value describes what the customer will get for a specific piece of work.
-
-This value is discovered through conversations with the customer and analysis of the work involved. Business stakeholders may have data that quantifies the value of a given feature that has been requested. A product owner will use the various sources of information available and devote significant time to understanding, evaluating, and prioritizing the value the customer will receive for a given piece of work.
diff --git a/client/src/pages/guide/english/agile/chickens-versus-pigs/index.md b/client/src/pages/guide/english/agile/chickens-versus-pigs/index.md
deleted file mode 100644
index e52812949e..0000000000
--- a/client/src/pages/guide/english/agile/chickens-versus-pigs/index.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: Chickens Versus Pigs
----
-## Chickens Versus Pigs
-
-"Chickens versus Pigs" refers to a story about a chicken and a pig, where the chicken proposes they open a restaurant called "Ham-n-Eggs".
-The pig refuses, because while the chicken just needs to lay eggs, the pig has more at stake.
-
-In an Agile software development project, the software developer is the pig. If you fail to complete the job, or fail to do it well,
-you have a lot at stake. This could be your reputation, or maybe even your position. Other team members might also be considered pigs,
-depending on how much they have at stake.
-
-On the other hand, many team members are chickens. For example, the client or a high-level project manager would not really be impacted
-by the failure of the project. They are interested in its success, and might make contributions, but have lower stakes and thus
-have significantly less commitment to the project.
-
-You should strive to be a pig rather than a chicken. You can benefit from (but should not rely on) the chickens in order to minimize risk and
-guarantee the project is delivered as efficiently as possible.
-
-#### More Information:
-
-
-Agile Jedi: The Story of the Chicken and Pig
-Wikipedia: The Chicken and the Pig
diff --git a/client/src/pages/guide/english/agile/code-smells/index.md b/client/src/pages/guide/english/agile/code-smells/index.md
deleted file mode 100644
index 3caf00dca5..0000000000
--- a/client/src/pages/guide/english/agile/code-smells/index.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: Code Smells
----
-## Code Smells
-
-A Code Smell in computer programming is a surface indication that there might be a problem regarding your system and the quality of your code. This problem might require refactoring to be fixed.
-
-It is important to understand that smelly code works, but is not of good quality.
-
-#### Examples
-1. Duplicated code - Blocks of code that have been replicated across the code base. This may indicate that you need to generalize the code into a function and call it in two places, or it may be that the way the code works in one place is completely unrelated to the way it works in another place, despite having been copied.
-2. Large classes - Classes having too many lines of code. This may indicate that the class is trying to do too many things, and needs to be broken up into smaller classes.
-
-#### More Information:
-* _Refactoring: Improving the Design of Existing Code - Kent Beck, Martin Fowler_
-* _Clean Code: A Handbook of Agile Software Craftsmanship - Martin, Robert C. (2009)._
-* [Code Smells on Wikipedia](https://en.wikipedia.org/wiki/Code_smell)
-* [Code Smells on Jeff Atwood's Blog (Coding Horror)](https://blog.codinghorror.com/code-smells/)
-* [Code Smells on Ward Cunningham's C2 Wiki](http://wiki.c2.com/?CodeSmell)
-* [Martin Fowler - Code Smell](https://martinfowler.com/bliki/CodeSmell.html)
diff --git a/client/src/pages/guide/english/agile/colocation-vs-distributed/index.md b/client/src/pages/guide/english/agile/colocation-vs-distributed/index.md
deleted file mode 100644
index b631321600..0000000000
--- a/client/src/pages/guide/english/agile/colocation-vs-distributed/index.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Collocation Vs Distributed
----
-## Collocation Vs Distributed
-- Co-located refers to a team that sits together; same office. Ideally, everyone sitting together in adjacent offices or an open workspace.
-- Distributed team members are scattered geographically; different buildings, cities, or even countries.
-In case of distributed team, infrastructure should facilitate processes in order to resolve time difference and distance between team members, thus providing an efficient way of working altogether.
-#### More Information:
-
-
-
diff --git a/client/src/pages/guide/english/agile/continuous-deployment/index.md b/client/src/pages/guide/english/agile/continuous-deployment/index.md
deleted file mode 100644
index b93c079bf6..0000000000
--- a/client/src/pages/guide/english/agile/continuous-deployment/index.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Continuous Deployment
----
-
-## Continuous Deployment
-
-Continuous Deployment is a modern software engineering process which is considered part of a DevOps environment. It involves teams of developers producing, updating and releasing code in very short cycles. This means developers commit smaller amounts of code, much more often.
-
-The goal of Continuous Deployment is to have code in a constant reliable and deployable state to enable this code to be released at any time. This process aims to release code more quickly. To achieve continuous deployment, a development team relies on infrastructure that automates and instruments the various steps leading up to deployment. This is quite often called Infrastructure as Code (IaC).
-
-Two main benefits of Continuous Deployment include an earlier return on investment for each feature after it is developed due to the lower release times as well as earlier feedback on new features.
-
-Other benefits to Continuous Deployment include improved code quality due to less bugs making it to production, more reliable code releases and a much lower time to market.
-
diff --git a/client/src/pages/guide/english/agile/continuous-integration/index.md b/client/src/pages/guide/english/agile/continuous-integration/index.md
deleted file mode 100644
index 45cddc342e..0000000000
--- a/client/src/pages/guide/english/agile/continuous-integration/index.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: Continuous Integration
----
-## Continuous Integration
-
-At it's most basic, continuous integration (CI) is an agile development methodology in which developers regularly merge their code directly to the main source, usually a remote `master` branch. In order to ensure that no breaking changes are introduced, a full test suite is run on every potentiual build to regression test the new code, i.e. test that the new code does not break existing, working features.
-
-This approach requires good test coverage of the code base, meaning that a majority, if not all, of the code has tests which ensure its features are fully functional. Ideally continuous integration would be practiced together with full Test-Driven Development .
-
-### Main Steps
-
-The following basic steps are necessary to do the most standard current approach to continuous integration.
-
-1. Maintain a central repo and an active `master` branch.
-
-There has to be a code repository for everyone to merge into and pull changes from. This can be on Github or any number of code-storage services.
-
-2. Automate the build.
-
-Using NPM scripts or more complex build tools like Yarn, Grunt, Webpack, or Gulp , automate the build so that a single command can build a fully functional version of the product, ready to be deployed in a production environment. Better yet, include deployment as part of the automated build!
-
-3. Make the build run all the tests.
-
-In order to check that nothing in the new code breaks existing functionality, the full test suite needs to be run and the build needs to fail if any tests within it fail.
-
-4. Everyone has to merge changes to `master` every day.
-
-5. Every merge into `master` has to be built and fully tested.
-
-### Best Practices
-
-There are further best practices that make the best use of what CI has to offer and the challenges it presents, such as:
-
-1. Keep the build fast, so that lots of developer time isn't wasted waiting for a build.
-
-2. Test the build in a full clone of the production environment.
-
-If you have, for example, an app deployed on something like Heroku or Digital Ocean, have a separate test deployment there that you can deploy test builds to, to make sure they work not just in tests but in a real production environment. This test environment should be functionally identical to the actual production environment, in order to ensure the test is accurate.
-
-3. Make it easy to stay up to date.
-
-Coders should pull regularly from the `master` branch to keep integrating their code with the changes from their team. The repo should also be made available to stakeholders like product managers, company executives, or sometimes key clients, so that everyone is easily able to see progress.
-
-4. Keep records of builds, so that everyone can see the results of any given build, whether it succeeded or failed, and who or what introduced new changes.
-
-5. Automate deployment.
-
-Keep your app fully up-to-date with any new changes by automating deployment in the production environment as the final stage of the build process, once all tests have passed and the test deployment in the production environment clone has succeeded.
-
-### CI Services
-
-Lots of services exists to handle the process of continuous integration for you, which can make it a lot easier to establish a solid CI pipeline, or build process. When evaluating these, take into account factors like budget, build speed, and what kind of project you're working on. Some services, like Travis CI offer free services for open-source projects, which can make them an easy choice for projects like that, but they might have slower builds than other services, like Circle CI or Codeship , to name just a few.
-
-#### More Information:
-The Wikipedia entry on Continuous Integration .
-
diff --git a/client/src/pages/guide/english/agile/cross-functional-teams/index.md b/client/src/pages/guide/english/agile/cross-functional-teams/index.md
deleted file mode 100644
index 3dab9a3c79..0000000000
--- a/client/src/pages/guide/english/agile/cross-functional-teams/index.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: Cross Functional Teams
----
-
-## Cross Functional Teams
-
-A cross-functional team is a group of people with different functional expertise working toward a common goal.
-
-Typically, it includes employees from all levels of an organization. Members may also come from outside an organization (in particular, from suppliers, key customers, or consultants). Cross-functional teams often function as self-directed teams assigned to a specific task which calls for the input and expertise of numerous departments.
-
-Assigning a task to a team composed of multi-disciplinary individuals increases the level of creativity and out of the box thinking.
-
-Each member offers an alternative perspective to the problem and potential solution to the task. In business today, innovation is a leading competitive advantage and cross-functional teams promote innovation through a creative collaboration process. Members of a cross-functional team must be well versed in multi-tasking as they are simultaneously responsible for their cross-functional team duties as well as their normal day-to-day work tasks.
-
-### Common Goal
-
-* Better for the team , better for the individual
-
-* improve co-ordination and integration
-
-* work accross orgnisational boundaries
-
-* improve efficiency of the team by increasing productivity
-
-* Achieve customer satisfaction by working for the same goal
-
-Some researchers have viewed cross-functional interactions as cooperative or competitive in nature, while others have argued that organization’s functional areas are often forced to compete and cooperate simultaneously with one another (“coopetition”) and it is critical to understand how these complex relationships interplay and affect firm performance.
-
-### Cross Functional Team Skill Composition
-One common challenge of composing Cross Functional Teams is the thought that every technical member on the team is required to have all the technical skills necessary to perform any of the work. It helps that team members can perform more than one technical skill but it is still okay to have specialists. It is just best when not all members of the team are specialists.
-
-#### More Information:
-
-* [17 PROVEN WAYS TO BENEFIT FROM A CROSS-FUNCTIONAL TEAM](https://www.scoro.com/blog/improve-cross-team-collaboration/)
-
-* [11 Reasons to Use Cross Functional Teams](https://blog.kainexus.com/employee-engagement/cross-functional-collaboration/cross-functional-teams/11-reasons)
-
-* [Cross-Functional Scrum Teams](https://www.scrumalliance.org/community/articles/2014/june/success-story-cross-functional-scrum-teams)
-
-* [Cross Functional Doesn’t Mean Everyone Can Do Everything](https://www.mountaingoatsoftware.com/blog/cross-functional-doesnt-mean-everyone-can-do-everything)
-
-* [Cross functional teams](https://dzone.com/articles/cross-functional-scrum-teams)
diff --git a/client/src/pages/guide/english/agile/crystal/index.md b/client/src/pages/guide/english/agile/crystal/index.md
deleted file mode 100644
index bc2415fa1e..0000000000
--- a/client/src/pages/guide/english/agile/crystal/index.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: Crystal
----
-## Crystal
-
-It is a methodology that is a very adaptable, lightweight approach to software development. It is a family of agile methodologies in which are included Crystal Clear, Crystal Yellow, Crystal Orange and others. Which of them has a unique attribute driven by many factors, like the size of the team, how critical the system is and the priorities of the project. Which states that each projects might need a different set of practices, rules, processes according to the project's unique characteristics.
-They were all developed by Alistair Cockburn in the 1990s.
-
-According to him, the faces of the crystal are defined as Methodology, techniques and policies
-
-Methodology - elements which are part of the project
-Techniques - areas of skills
-Policies - organizationals do's and dont's
-
-Those methods are focused on:
-1. People
-2. Interaction
-3. Community
-4. Skills
-5. Talents
-6. Communications
-
-![Different Colors] https://upload.wikimedia.org/wikiversity/en/c/c5/Crystal_Family_example.jpg
-
-
-It takes different strokes to move the world, and according to Crystal, it takes different colors to move a project.
-
-#### More Information:
-
-
-[Wikiversity Article] https://en.wikiversity.org/wiki/Crystal_Methods
diff --git a/client/src/pages/guide/english/agile/customer-units/index.md b/client/src/pages/guide/english/agile/customer-units/index.md
deleted file mode 100644
index f628d45850..0000000000
--- a/client/src/pages/guide/english/agile/customer-units/index.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: Customer Units
----
-## Customer Units
-
-In Agile, Customer units is a people and role that represent the voice, the expectation from customers/market targetted by a product.
-
-Customer units responsible for user experience product, a vision of a product, road map of product, creating and maintaining product backlog, and anything.
-
-Example Person / Roles :
-->Product Managers
-->Sales
-->Marketing
-->End User
-
-#### More Information:
- Customer Unit : Solutions
-
-
diff --git a/client/src/pages/guide/english/agile/daily-standup-and-daily-scrum/index.md b/client/src/pages/guide/english/agile/daily-standup-and-daily-scrum/index.md
deleted file mode 100644
index a61adf4176..0000000000
--- a/client/src/pages/guide/english/agile/daily-standup-and-daily-scrum/index.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: Daily Stand-Up and Daily Scrum
----
-## Daily Stand-Up and Daily Scrum
-
-The Daily Stand-Up (DSU) or Daily Scrum meeting is one of the integral parts of scrum methodology.
-
-As the name suggests, you hold the meeting daily, at the same time and, for a co-located team, in the same location. The meeting should be brief, finished in less than 15 minutes.
-
-Only members of the Development team are required to attend the Daily Stand-up. Typically, the Scrum Master and Product Owners will also attend, but they are not required.
-
-The standard agenda for each person is:
-* What have you done since the last DSU
-* What are you doing after this DSU
-* What are the major obstacles that are stopping your progress, and where do you need help
-
-Team members are to listen carefully to each other's contributions and attempt to identify areas where they can assist each other's progress. The standup meeting will also surface more lengthy topics of discussion that need to take place between different members of the team. These lengthier discussions that arise should then be halted and taken outside of the standup, involving only the relevant participants, and not the entire team.
-
-### Example of Stand-up Meeting
-https://www.youtube.com/watch?v=_3VIC8u1UV8
-
-
-### More Information:
-Stand-up meeting: Wikipedia
diff --git a/client/src/pages/guide/english/agile/delivery-team/index.md b/client/src/pages/guide/english/agile/delivery-team/index.md
deleted file mode 100644
index 8ae80b49b9..0000000000
--- a/client/src/pages/guide/english/agile/delivery-team/index.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: Delivery Team
----
-## Delivery Team
-
-A scrum team is made up of the Product Owner (PO), the Scrum Master (SM), and the Delivery Team.
-
-The delivery team is everyone but the PO and SM; the developers, testers, system analysts, database analysts, UI / UX analysts, and so on.
-
-For a scrum delivery team to be effective, it should be nimble (or agile!) enough for decisions to be agreed upon quickly while diverse enough so the vast majority of specalities required for software development can be covered by the entire team. Idealy, a team between 3 and 9 people generally works well for a scrum development team.
-
-The team must also foster mutual respect througout every member of the team. An effective scrum team will be able to share the workload and put the accomplishments of the team ahead of the accomplishments of the individual.
-
-
-
-#### More Information:
-Atlassian's primer article on Scrum [here.](https://www.atlassian.com/agile/scrum)
-
-
-
diff --git a/client/src/pages/guide/english/agile/design-patterns/index.md b/client/src/pages/guide/english/agile/design-patterns/index.md
deleted file mode 100644
index eaf3a7e269..0000000000
--- a/client/src/pages/guide/english/agile/design-patterns/index.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Design Patterns
----
-## Design Patterns
-A design pattern is a common design solution to a common design problem. A collection of design patterns for a related field or domain is called a pattern language. Note that there are also patterns at other levels: code, concurrency, architecture, interaction design ...
-
-In software engineering, a software design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. It is not a finished design that can be transformed directly into source or machine code. It is a description or template for how to solve a problem that can be used in many different situations. Design patterns are formalized best practices that the programmer can use to solve common problems when designing an application or system.
-
-Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Patterns that imply mutable state may be unsuited for functional programming languages, some patterns can be rendered unnecessary in languages that have built-in support for solving the problem they are trying to solve, and object-oriented patterns are not necessarily suitable for non-object-oriented languages.
-
-Design patterns may be viewed as a structured approach to computer programming intermediate between the levels of a programming paradigm and a concrete algorithm.
-
-The book that popularised the field is Gang of Four's (GoF) **Design Patterns: Elements of Reusable Object-Oriented Software** (1994). It present a series (23) of patterns for an conventional (C++) OO language classified in three types:
-* **Creational** (to create objects): abstract factory, builder, factory method, prototype, singleton.
-* **Structural** (to compose objects): adapter, bridge, composite, decorator, facade, flyweight, proxy.
-* **Behavioral** (to communicate between objects): chain of responsibility, command, interpreter, iterator, mediator, memmento, observer, state, strategy, template method, visitor.
-
-Patterns can be used for multiple objectives (learning, communication, improving your tooling) but in agile they should be refactored from code with technical debt and not just added at the start (emergent design/architecture) as initially you don't have enough knowledge about the (future) system that is going to evolve. Note that what requires a pattern in a language or tool may not be needed or already be part of another language or tool. A framework is a set of cooperating classes that make up a reusable design for a specific type of software and are typically pattern-heavy.
-
-
-#### More Information:
-
-- [Wikipedia on Design Patterns](https://en.wikipedia.org/wiki/Software_design_pattern)
-- [Wikipedia on GoF Book](https://en.wikipedia.org/wiki/Design_Patterns)
-- [Design Patterns by Source Making](https://sourcemaking.com/design_patterns): list of well known patterns available online
-- [Game Programming Patterns](http://gameprogrammingpatterns.com/): book about Design Patterns commonly used in Game Development, available to be read online for free
-- [Object Oriented Design](http://www.oodesign.com/)
-- [A Beginner’s Guide to Design Patterns](https://code.tutsplus.com/articles/a-beginners-guide-to-design-patterns--net-12752)
-- [From design patterns to category theory](http://blog.ploeh.dk/2017/10/04/from-design-patterns-to-category-theory/)
-
diff --git a/client/src/pages/guide/english/agile/dsdm/index.md b/client/src/pages/guide/english/agile/dsdm/index.md
deleted file mode 100644
index f0297316a2..0000000000
--- a/client/src/pages/guide/english/agile/dsdm/index.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: DSDM
----
-## DSDM
-
-DSDM stands for Dynamic Systems Development Method. It is an Agile rapid development methodology, and aims to address the ongoing problem of the length of time it takes to develop information systems. DSDM is more of a framework than a tightly-defined method, and much of the detail of how things should actually be done is left to the software development organisation or individual to decide. DSDM adopts an incremental approach and uses the RAD (rapid application development) concept of timeboxing. It also emphasizes the key role of people in the development process and is described as a user-centred approach.
-
-DSDM has 9 core principles, as follows:
-
-1) Active user involvement is imperative.
-2) Teams must be empowered to make decisions. The four key variables of empowerment are: authority, resources, information, and accountability.
-3) Frequent delivery of products is essential.
-4) Fitness for business purpose is the essential criterion for acceptance of deliverables.
-5) Iterative and incremental development is necessary to converge on an accurate business solution.
-6) All changes during development are reversible (ie you do not proceed further down a particular path if problems are encountered; you backtrack to the last safe or agreed point, and then start down a new path).
-7) Requirements are baselined at a high level (ie the high-level business requirements, once agreed, are frozen). This is essentially the scope of the project.
-8) Testing is integrated throughout the life cycle (ie test as you go rather than testing just at the end where it frequently gets squeezed).
-9) A collaborative and co-operative approach between all stakeholders is essential.
-
-The 5 main phases of the DSDM development cycle are:
-
-1) Feasibility study.
-2) Business study.
-3) Functional model iteration.
-4) System design and build iteration.
-5) Implementation.
-
-#### More Information:
-You can read the following links to find out more.
-- Agile Business - What is DSDM?
-- Wikipedia - Dynamic Systems Development Method
-
diff --git a/client/src/pages/guide/english/agile/epics/index.md b/client/src/pages/guide/english/agile/epics/index.md
deleted file mode 100644
index fdcd5320eb..0000000000
--- a/client/src/pages/guide/english/agile/epics/index.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Epics
----
-## Epics
-An epic is a large user story that cannot be delivered as defined within a single iteration or is large enough that it can be split into smaller user stories. Epics usually cover a particular persona and give an overall idea of what is important to the user. An epic can be further broken down into various user stories that show individual tasks that a persona/user would like to perform.
-
-There is no standard form to represent epics. Some teams use the familiar user story formats (As A, I want, So That or In Order To, As A, I want) while other teams represent the epics with a short phrase.
-
-* While the stories that comprise an epic may be completed independently, their business value isn’t realized until the entire epic is complete
-
-### Epic Example
-In an application what helps freelance painters track their projects, a possible epic could be.
-
-Paul the Painter would like an easier way to manage his projects and provide his client with accurate changes and also bill them.
diff --git a/client/src/pages/guide/english/agile/extreme-programming/index.md b/client/src/pages/guide/english/agile/extreme-programming/index.md
deleted file mode 100644
index 9d16931442..0000000000
--- a/client/src/pages/guide/english/agile/extreme-programming/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Extreme Programming
----
-## Extreme Programming
-
-Extreme programming (XP) is a software development methodology which is intended to improve software quality and responsiveness to changing customer requirements.1 2 Rules of Extreme Programming
diff --git a/client/src/pages/guide/english/agile/feature-based-planning/index.md b/client/src/pages/guide/english/agile/feature-based-planning/index.md
deleted file mode 100644
index abeb665e3c..0000000000
--- a/client/src/pages/guide/english/agile/feature-based-planning/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Feature Based Planning
----
-## Feature Based Planning
-
-**Feature Based Planning** is a planning methodology that can be used to decide when to release software based on the features that will be delivered to the customers, rather than an arbitrary deadline based release.
-
-In this method of release planning, teams decide what feature/features should be prioritised. Based on the scope of these features the team can then predict when the next release can be deployed.
-
-
-
-#### More Information:
-[Feature-driven development](https://en.wikipedia.org/wiki/Feature-driven_development)
-
-
diff --git a/client/src/pages/guide/english/agile/five-levels-of-agile-planning/index.md b/client/src/pages/guide/english/agile/five-levels-of-agile-planning/index.md
deleted file mode 100644
index 83e02215f4..0000000000
--- a/client/src/pages/guide/english/agile/five-levels-of-agile-planning/index.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: Five Levels of Agile Planning
----
-## Five Levels of Agile Planning
-
-A product owner needs to be familiar with the five levels of agile planning:
- - Defining the product vision
- - Defining the product roadmap
- - Release planning
- - Sprint planning
- - Accounting for the outcome of daily scrums
-
-Agile planning is always continuous and should be revised at least every three months.
-
-## Brief Synopsis of the Five Levels of Agile Planning
-
- 1. Product Vision: What (Summary of the major benefits & features the product will provide), Who (Stakeholders), Why (Need & Opportunity), When (Project scheduling & time expectations), Constraints and Assumptions (impacts risk & cost).
-
- 2. Product Roadmap: Releases - Date, Theme/Feature Set, Objective, Development Approach.
-
- 3. Release Planning: Iteration, Team Capacity, Stories, Priority, Size, Estimates, Definition of Done.
-
- 4. Sprint Planning: Stories - Tasks, Definition of Done, Level-of Effort, Commitment
-
- 5. Daily Planning: What did I do yesterday? What will I do today? What is blocking me?
-
-#### More Information:
-
-Five Levels of Agile Planning
diff --git a/client/src/pages/guide/english/agile/functional-managers/index.md b/client/src/pages/guide/english/agile/functional-managers/index.md
deleted file mode 100644
index 2d2dac9c0f..0000000000
--- a/client/src/pages/guide/english/agile/functional-managers/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Functional Managers
----
-
-## Functional Managers
-
-A functional manager is a person that have management authority over group of people. That authority comes from the formal position of that person in the organization (eg. director of the department, quality department manager, development team manager). Role of functional managers is different then Project Managers or ScrumMasters and is not project based.
-In more agile organizations different models exists. Functional manager often are responsible for developing people in their groups, securing budgets and time for people.
-However there are also some Agile company models where functions usually assigned to functional managers are distributed to other roles within organization (eg. Spotify model with Tribes, Guilds, Chapters, Squads).
-
-Out in the traditional world of work companies organize people into a hierarchy. People with similar work roles are grouped into functional areas and led by a Functional Manager. The functional manager is generally responsible for the guidance and well-being of the employees who report directly to her.
-
-Agile project teams will often work with functional managers who control the resources the team needs to get work done. An example would be working with a functional manager in procurement to assign a person to work with the team to procure software licenses.
\ No newline at end of file
diff --git a/client/src/pages/guide/english/agile/integration-hell/index.md b/client/src/pages/guide/english/agile/integration-hell/index.md
deleted file mode 100644
index a18edbb148..0000000000
--- a/client/src/pages/guide/english/agile/integration-hell/index.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: Integration Hell
----
-## Integration Hell
-
-Integration Hell is a slang term for when all the members of a development team goes through the process of implementing their code at random times with no way to incorporate the different pieces of code into one seamless sring of code. The development team will have to spend several hours or days testing and tweaking the code to get it all to work.
-
-In practice, the longer components are developed in isolation, the more the interfaces tend to diverge from what is expected. When the components are finally integrated at the end of the project, it would take a great deal more time than allocated, often leading to deadline pressures, and difficult integration. This painful integration work at the end of the project is the eponymous hell.
-
-Continuous Integration, the idea that a development team should use specific tools to "continously integrate" the parts of the code they are working on multiple times a day so that the tools can match the different "chunks" of code together to integrate much more seamlessly than before.
-
-Code Repositories, like Git (and it's open source interface we all know and love, GitHub) allow development teams to organize their efforts so that more time can be spent coding and less time on worrying if the different parts of the code will all integrate.
-
-Continuous Integration is the Agile antidote to this problem. Integration is still painful, but doing it at least daily keeps interfaces from diverging too much.
-
-#### More Information:
-- Avoiding Integration Hell
-- Integration Hell
-- Top 5 Tips to Avoid “Integration Hell” with Continuous Integration
-- D-Zone article on Integration Hell and how Continous Integration has help make it almost a thing of the past
\ No newline at end of file
diff --git a/client/src/pages/guide/english/agile/invest/index.md b/client/src/pages/guide/english/agile/invest/index.md
deleted file mode 100644
index b86d0243a6..0000000000
--- a/client/src/pages/guide/english/agile/invest/index.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: INVEST
----
-## INVEST
-
-**I** | **independent**
------ | -----
-**N** | **negotiable**
-**V** | **valuable**
-**E** | **estimable**
-**S** | **small**
-**T** | **testable**
-
-When you are refining and sizing the User Stories in the backlog, the INVEST mnemonic can help you determine if they are ready
-
-- Independent
- - The story is as distinct as possible from the other stories. Avoid "2-stories in one".
-- Negotiable
- - As a part of the conversation between the Product Owner and the Delivery Team during grooming, the details for the story can be discussed, refined, and improved. The acceptance criteria can be adjusted based on the ebb and flow of customer need and technical capability.
-- Valuable
- - There is a value to the customer. Money earned, time saved, efficiency gained, loss stopped, etc. by the implementation of the story.
-- Estimable
- - During grooming, the description and conversation for the story have addressed enough of the questions from the Delivery Team that they can confidently and comfortably Size the story.
-- Small
- - You can complete the story within the established iteration.
-- Testable
- - The story includes acceptance criteria you will use to confirm that the code meets the customer's needs.
-
-
-
-#### More Information:
-
-Lots on Google
-
diff --git a/client/src/pages/guide/english/agile/kano-analysis/index.md b/client/src/pages/guide/english/agile/kano-analysis/index.md
deleted file mode 100644
index 59a2552109..0000000000
--- a/client/src/pages/guide/english/agile/kano-analysis/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Kano Analysis
----
-## Kano Analysis
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/pages/guide/english/agile/lean-software-development/index.md b/client/src/pages/guide/english/agile/lean-software-development/index.md
deleted file mode 100644
index 79cbb9febf..0000000000
--- a/client/src/pages/guide/english/agile/lean-software-development/index.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: Lean Software Development
----
-## Lean Software Development
-
-### Introduction
-
-Lean Software Development is the process of building software with the focus on using techniques which minimize extra work and wasted effort. These techniques are borrowed from the Lean manufacturing movement and applied to the context of software development.
-
-### Key Concepts
-
-There are seven principles within the methodology which include:
- 1. Eliminate waste
- 2. Amplify learning
- 3. Decide as late as possible
- 4. Deliver as fast as possible
- 5. Empower the team
- 6. Build integrity in
- 7. See the whole
-
-### Metaphors
-
-The act of programming is viewed as an assembly line, where every feature or bug fix is called a "change request". This assembly line of "change requests" can then be considered as a "value stream" with the goal being to minimize the time that each "change request" is on the line prior to being delivered.
-
-Software which is not yet delivered is considered as "inventory" since it has not yet provided value to the company or the customer. This includes any software which is partially complete. Therefore to maximize throughput it is important to deliver many small complete working pieces of software.
-
-In order to minimize the "inventory" it is important to secede control to the "workers" who would be the software developers, as they would be best equipped to create automated processes to "mistake proof" the various parts of the assembly line.
-
-### References
-
-The original source of written documentation on the Lean techniques is the book Lean Software Development, An Agile Toolkit by Mary and Tom Poppendieck.
-
-Additional books by the author(s) include:
- - Implementing Lean Software Development: From Concept to Cash by Mary Poppendieck
- - Leading Lean Software Development: Results Are not the Point by Mary Poppendieck
diff --git a/client/src/pages/guide/english/agile/minimum-viable-product/index.md b/client/src/pages/guide/english/agile/minimum-viable-product/index.md
deleted file mode 100644
index f0087097d9..0000000000
--- a/client/src/pages/guide/english/agile/minimum-viable-product/index.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Minimum Viable Product
----
-## Minimum Viable Product
-The idea is to rapidly build a minimum set of features that is enough to deploy the product and test key assumptions about customers’ interactions with the product.
-
-#### A Minimum Viable Product has three key characteristics:
-- It has enough value that people are willing to use it or buy it initially.
-- It demonstrates enough future benefit to retain early adopters.
-- It provides a feedback loop to guide future development.
-
-Learn more about MVP:
-what is a mvp?
-
diff --git a/client/src/pages/guide/english/agile/moscow/index.md b/client/src/pages/guide/english/agile/moscow/index.md
deleted file mode 100644
index 9a44ba7050..0000000000
--- a/client/src/pages/guide/english/agile/moscow/index.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title: Moscow
----
-## Moscow
-
-## MoSCoW Method
-
-One of the meaning of this word is the MoSCoW method - a prioritization technique used in management, business analysis, project management, and software development to reach a common understanding with stakeholders on the importance they place on the delivery of each requirement - also known as MoSCoW prioritization or MoSCoW analysis.
-
-## Prioritization of MoSCoW requirements
-
-All requirements are important, but they are prioritized to deliver the greatest and most immediate business benefits early. Developers will initially try to deliver all the Must have, Should have and Could have requirements but the Should and Could requirements will be the first to be removed if the delivery timescale looks threatened.
-
-The plain English meaning of the prioritization categories has value in getting customers to better understand the impact of setting a priority, compared to alternatives like High, Medium and Low.
-
-The categories are typically understood as:
-
-## Must have
- Requirements labeled as Must have are critical to the current delivery timebox in order for it to be a success. If even one Must have requirement is not included, the project delivery should be considered a failure. MUST can also be considered an acronym for the Minimum Usable SubseT.
-
-## Should have
- Requirements labeled as Should have are important but not necessary for delivery in the current delivery timebox. While Should have requirements can be as important as Must have, they are often not as time-critical or there may be another way to satisfy the requirement, so that it can be held back until a future delivery timebox.
-
-## Could have
- Requirements labeled as Could have are desirable but not necessary, and could improve user experience or customer satisfaction for little development cost. These will typically be included if time and resources permit.
-
-## Won't have
- Requirements labeled as Won't have have been agreed by stakeholders as the least-critical, lowest-payback items, or not appropriate at that time. As a result, Won't have requirements are not planned into the schedule for the next delivery timebox. Won't have requirements are either dropped or reconsidered for inclusion in a later timebox.
-
-MoSCoW is a coarse-grain method to prioritise (categorise) Product Backlog Items (or requirements, use cases, user stories ... depending on the methodology used).
-MoSCoW is often used with timeboxing, where a deadline is fixed so that the focus must be on the most important requirements.
-The term MoSCoW itself is an acronym derived from the first letter of each of four prioritization categories (Must have, Should have, Could have, and Won't have):
-
-* **Must have**: Critical to the current delivery timebox in order for it to be a success. It is typically part of the MVP (Minimum Viable Product).
-* **Should have**: Important but not necessary for delivery in the current delivery timebox.
-* **Could have**: Desirable but not necessary, an improvement.
-* **Won't have**: Least-critical, lowest-payback items, or not appropriate at this time.
-
-By prioritizing in this way, a common definition of the project can be reached and stakeholders' expectations set accordingly. Note That MoSCoW is a bit lax about how to distinguish the category of an item and when something will be done, if not in this timebox.
-
-#### More Information:
-
-[Wikipedia](https://en.wikipedia.org/wiki/MoSCoW_method)
-
diff --git a/client/src/pages/guide/english/agile/nonfunctional-requirements/index.md b/client/src/pages/guide/english/agile/nonfunctional-requirements/index.md
deleted file mode 100644
index 596cf2e288..0000000000
--- a/client/src/pages/guide/english/agile/nonfunctional-requirements/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Nonfunctional Requirements
----
-## Nonfunctional Requirements
-
-A non-functional requirement (NFR) is a requirement that specifies criteria that can be used to judge the operation of a system, rather than specific behaviors (a functional requirement). Non-functional requirements are often called "quality attributes", "constraints" or "non-behavioral requirements".
-
-Informally, these are sometimes called the "ilities", from attributes like stability and portability. NFRs can be divided into two main categories:
-* **Execution qualities**, such as safety, security and usability, which are observable during operation (at run time).
-* **Evolution qualities**, such as testability, maintainability, extensibility and scalability, which are embodied in the static structure of the system
-
-Usually you can refine a non-functional requirement into a set of functional requirements as a way of detailing and allowing (partial) testing and validation.
-
-### Examples:
-
-* The printer should print 5 seconds after the button is pressed
-* The code should be written in Java
-* The UI should be easily navigable
-
-#### More Information:
-
-* [Wikipedia article](https://en.wikipedia.org/wiki/Non-functional_requirement)
-* [ReQtest](http://reqtest.com/requirements-blog/functional-vs-non-functional-requirements/) Explains the difference between functional and nonfunctional requirements
-* [Scaled Agile](http://www.scaledagileframework.com/nonfunctional-requirements/) Works through the process from finding to testing nonfunctional requirements
-
-
diff --git a/client/src/pages/guide/english/agile/osmotic-communications/index.md b/client/src/pages/guide/english/agile/osmotic-communications/index.md
deleted file mode 100644
index 1108700685..0000000000
--- a/client/src/pages/guide/english/agile/osmotic-communications/index.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Osmotic Communications
----
-## Osmotic Communications
-**Osmotic Communications** is one of the important factors of a successful agile project.
-
-In agile project, team members usually co-located, any discussion among some of the team members will flow to other team members. They can then pick up relevant information and join in discussion wherever necessary.
-
-#### More Information:
-https://www.projectmanagement.com/wikis/295442/Osmotic-Communications
-http://agilemodeling.com/essays/communication.htm
diff --git a/client/src/pages/guide/english/agile/pair-programming/index.md b/client/src/pages/guide/english/agile/pair-programming/index.md
deleted file mode 100644
index be345a0850..0000000000
--- a/client/src/pages/guide/english/agile/pair-programming/index.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Pair Programming
----
-## Pair Programming
-
-Extreme Programming (XP) recommends that all production code be written by two programmers working at the same time at the same computer, taking turns on the keyboard. Several academic studies have demonstrated that pair programming results in fewer bugs and more maintainable software. Pair programming can also help spread knowledge within the team, contributing to a larger Bus Factor and helping to promote Collective Code Ownership .
-
-#### More Information:
-
-- Pair Programming Fundamentals (training course)
-- Agile Software Programming Best Practices
-
diff --git a/client/src/pages/guide/english/agile/parallel-development/index.md b/client/src/pages/guide/english/agile/parallel-development/index.md
deleted file mode 100644
index 8ed328be52..0000000000
--- a/client/src/pages/guide/english/agile/parallel-development/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Parallel Development
----
-## Parallel Development
-
-Parallel Development stands for the development process separated into multiple branches, to provide a versatile product with stable releases and new features. In a more common straightforward software development process you have only one branch with bug fixes and improvements, alongside with new features. In parallel development multiple branches can coexist.
-
-Usually parallel development contains a main, "master" branch which is the most stable and contains important fixes for existing code. From the main branch, more branches are created to add new "paths" to the existing code. These branches provide new features, but do not include fixes, applied in the mean time from the master branch. Clients know about these releases and have special equipment, or test machines to be able to test the new features. When QA tests are passed, side branch can be merged with the main branch to introduce new features to the release version.
-
-#### More Information:
-
-
-
diff --git a/client/src/pages/guide/english/agile/pirate-metrics/index.md b/client/src/pages/guide/english/agile/pirate-metrics/index.md
deleted file mode 100644
index f51c11dc23..0000000000
--- a/client/src/pages/guide/english/agile/pirate-metrics/index.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: Pirate Metrics
----
-## Pirate Metrics
-
-Dave McClure identified five high-level metric categories critical to a startup’s success:
-Acquisition, Activation, Retention, Revenue, Referral.
-
-He coined the term “Pirate Metrics” from the acronym for these five metric categories (AARRR).
-
-In their book Lean Analytics, Croll and Yoskovitz interpret these metrics visually as a funnel:
-
-Lean Analytics, 2013
-
-
-And with more pointed explanations as a table:
-
-Lean Analytics, 2013
-
-#### More Information:
-
-- Original Pirate Metrics Slideshow (McClure) https://www.slideshare.net/dmc500hats/startup-metrics-for-pirates-long-version
-- Lean Analytics Book Website http://leananalyticsbook.com/
-- Notion has a really good guide on Pirate Metrics (including Team measures) on their [website](http://usenotion.com/aarrrt/)
diff --git a/client/src/pages/guide/english/agile/planning-poker/index.md b/client/src/pages/guide/english/agile/planning-poker/index.md
deleted file mode 100644
index 64a625257b..0000000000
--- a/client/src/pages/guide/english/agile/planning-poker/index.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: Planning Poker
----
-## Planning Poker
-
-### Introduction
-Planning poker is an estimation and planning technique in the Agile development model. It is used to estimate the development effort required for a [user story](../user-stories/index.md) or a feature.
-
-### Process
-The planning poker is done for one user story at a time.
-
-Each estimator holds an identical set of poker cards consisting of cards with various values. The card values are usually from the Fibonacci Sequence. The unit used for the values can be the number of days, story points, or any other kind of estimation unit agreed on by the team.
-
-The product owner (PO) or stakeholder explains the story that is to be estimated.
-
-The team discusses the story, asking any clarifying questions that they might have. This helps the team get a better understanding on *what* the PO wants.
-
-At the end of the discussion, each person first selects a card (representing their estimate for the story) without showing it to the others. Then, they reveal their cards at the same time.
-
-If all the cards have the same value, the value becomes the estimate for the story. If there are differences, the team discusses the reasons for the values that they have chosen. It is of high value that the team members who gave the lowest and highest estimates provide justifications for their estimates.
-
-After this discussion, the process of picking a card in private and then revealing it at the same time is repeated. This is done until there is a consensus on the estimate.
-
-Because planning poker is a tool to moderate a *joint* expert estimation, it leads to a better common understanding and perhaps even refinement of the feature request. It is of high value even when the team is operating in a No-Estimates mode.
-
-A moderator should try to avoid confirmation bias.
-
-Things worth mentioning:
-- Estimations are not comparable between teams, as every team has its own scala.
-- Estimations should include everything that needs to be done in order for a piece of work to be done: designing, coding, testing, communicating, code reviews (+ all possible risks)
-- The value of using planning poker is in the resulting discussions, as they reveal different views on a possible implementation
-
-### More Information:
-- Planning poker video: YouTube
diff --git a/client/src/pages/guide/english/agile/product-management/index.md b/client/src/pages/guide/english/agile/product-management/index.md
deleted file mode 100644
index 7656faaa47..0000000000
--- a/client/src/pages/guide/english/agile/product-management/index.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-title: Product Management
----
-## Product Management
-
-Product Management is an organisational function that assumes responsibility for the entire lifecycle of the products that are being sold. As a business function, Product Management, is held accountable for creating customer value and measurable benefits to the business.
-
-There are a few core responsibilities common to most product management roles inside both established enterprise companies and at startups. Most often product management is responsible for understanding customer requirements, defining and prioritizing them, and working with the engineering team to build them. Setting strategy and defining the roadmap is often considered to be inbound work and bringing the product to market is often considered to be "outbound."
-
-It is important to understand the differences between inbound and outbound product management because a great product manager has the diverse set of skills to do both well.
-
-Difference between Product Management and Project Management is, the scale and life cycle. Project Managers ensure multiple products/services/projects are delivered to a customer, while Product Managers go beyond development and work towards longjevity and operation of a product/service.
-
-In Game development we can see the clear shift from Projects to Products due to games having more detailed post launch plans and monetization strategies.
-
-### Inbound Product Management
-
-Inbound product management involves gathering customer research, competitive intelligence, and industry trends as well as setting strategy and managing the product roadmap.
-
-Product Strategy and Definition (Inbound)
-
-- Strategy and vision
-- Customer interviews
-- Defining features and requirements
-- Building roadmaps
-- Release management
-- Go-to-resource for engineering
-- Sales and support training
-
-### Outbound Product Management
-
-Outbound product management involve product marketing responsibilities such as: messaging and branding, customer communication, new product launches, advertising, PR, and events. Depending on the organization these roles can be performed by the same person or two different people or groups that work closely together.
-
-Product Marketing and Go-to-Market (Outbound)
-
-- Competitive differentiation
-- Positioning and messaging
-- Naming and branding
-- Customer communication
-- Product launches
-- Press and analyst relations
-
-### Product Manager
-
-Product management continues to expand as a profession. Demand for qualified product managers is growing at every level. There are a variety of roles and responsibilities depending on experience level. Opportunities range from an Associate Product Manager all the way to CPO.
-
-Most Product Managers have been in different roles earlier in their careers. Very often software engineers, sales engineers or professional services consultant grow into the role of Product Manager. But in some companies (e.g. Google, Facebook, ...), junior Product Managers are recruited straight out of school, supported by career programs to teach them on the job.
-
-#### More Information:
-Wikipedia page: https://en.wikipedia.org/wiki/Product_management
-
-
diff --git a/client/src/pages/guide/english/agile/product-owners/index.md b/client/src/pages/guide/english/agile/product-owners/index.md
deleted file mode 100644
index 0830a2a5c7..0000000000
--- a/client/src/pages/guide/english/agile/product-owners/index.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Product Owners
----
-## Product Owners
-
-Product Owners lead the product vision and release planning. They are in charge of defining the features, the release date, and the content that makes up a shippable product. The goal of a Product Owner is to build the right thing quickly and correctly.
-
-At a high-level, the Product Owner is responsible for the following:
-
-* Owner of the product vision
-* Leads release planning
-* Defines features and content of the release
-* Manages team's understanding of the release
-* Creates and curates the product backlog
-* Prioritizes the product backlog
-* Guides team through the release cycle
-* Makes trade-off decisions
-* Accepts or rejections work
-
-The Product Owner creates a backlog of items that they think would make a good product. This knowledge is based on their understanding of the market, user testing, and market projection. Product Owners adjust the long-term goals of the product based on the feedback they receive from users and stakeholders. They also act as the point of contact with stakeholders and manage scope and expectations.
-
-Once the Product Owner has received feedback from the various stakeholders, they then refine the backlog to add as much detail as possible in order to create a Minimum Viable Product (MVP)for that release.
-
-The Product Owner then prioritizes the workload to ensure that the stories that are completed address both business value and user goals. Also, if there are risks associated with certain stories, the Product Owner puts those at the top of the backlog so that the risks are addressed early.
-
-Working with the team and the Scrum Master, the Product owner attends sprint planning meetings to loop groomed stories into the sprint. Throughout the sprint, the Product Owner ensures that the team completes the work according to the Definition of Done (DoD), answers any questions that may arise, and update stakeholders.
-
-When the sprint is complete, the Product Owner participates in the Sprint Review along with other stakeholders. Making sure that each story meets the DoD, the Product Owner prepares for the next sprint by gathering feedback and prioritizing work based on what was completed.
-
-
-### More Information:
-- Agile Product Ownership in a Nutshell video: [YouTube](https://www.youtube.com/watch?v=502ILHjX9EE)
-
diff --git a/client/src/pages/guide/english/agile/rapid-application-development/index.md b/client/src/pages/guide/english/agile/rapid-application-development/index.md
deleted file mode 100644
index 189bcac8db..0000000000
--- a/client/src/pages/guide/english/agile/rapid-application-development/index.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: Rapid Application Development
----
-## Rapid Application Development
-
-Rapid Application Development (RAD) was devised as a reaction to the problems of traditional software development methodologies, particularly the problems of long development lead times. It also addresses the problems associated with changing requirements during the development process.
-
-The main principles of RAD are as follows:
-1) Incremental development. This is the main means by which RAD handles changing requirements. Some requirements will only emerge when the users see and experience the system in use. Requirements are never seen as complete - they evolve over time due to changing circumstances. The RAD process starts with a high-level, non-specific list of requirements which are refined during the development process.
-2) Timeboxing. With timeboxing, the system is divided up into a number of components or timeboxes that are developed separately. The most important requirements are developed in the first timebox. Features are delivered quickly and often.
-3) The Pareto principle. Also known as the 80/20 rule, this means that around 80% of a system's functionality can be delivered with around 20% of the total effort needed. Therefore, the last (and most complex) 20% of requirements take the most effort and time to deliver. So, you should choose as much of the 80% to deliver as possible within the first few timeboxes. The rest, if it proves necessary, can be delivered in subsequent timeboxes.
-4) MoSCoW rules. MoSCoW is a method used for prioritising work items in software development. Items are ranked as Must Have, Should Have, Could Have or Would Like to Have. Must Have items are those which must be included in a product for it to be accepted into release, with the other classifications in descending priority.
-5) JAD workshops. Joint Application Development (JAD) is a facilitated meeting where requirements gathering is carried out, in particular interviewing users of the system to be developed. The JAD workshop usually takes place early on in the development process, although additional meetings can be organised if required later in the process.
-6) Prototyping. Building a prototype helps to establish and clarify the user requirements, and in some cases it evolves to become the system itself.
-7) Sponsor and champion. An executive sponsor is someone within the organisation who wants the system, is committed to achieving it and is prepared to fund it. A champion is someone, usually at a lower level of seniority than an executive, who is committed to the project and is prepared to drive it forward to completion.
-8) Toolsets. RAD usually adopts toolsets as a means of speeding up the development process and improving productivity. Tools are available for change control, configuration management and code reuse.
-
-#### More Information:
-- https://en.wikipedia.org/wiki/Rapid_application_development - Wikipedia article on RAD
-- https://www.tutorialspoint.com/sdlc/sdlc_rad_model.htm - TutorialsPoint tutorial on RAD
-
-
diff --git a/client/src/pages/guide/english/agile/rational-unified-process/index.md b/client/src/pages/guide/english/agile/rational-unified-process/index.md
deleted file mode 100644
index f6365f9900..0000000000
--- a/client/src/pages/guide/english/agile/rational-unified-process/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Rational Unified Process
----
-## Rational Unified Process
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/pages/guide/english/agile/release-planning/index.md b/client/src/pages/guide/english/agile/release-planning/index.md
deleted file mode 100644
index 144c9e0f78..0000000000
--- a/client/src/pages/guide/english/agile/release-planning/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Release Planning
----
-## Release Planning
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/pages/guide/english/agile/release-trains/index.md b/client/src/pages/guide/english/agile/release-trains/index.md
deleted file mode 100644
index aac483100e..0000000000
--- a/client/src/pages/guide/english/agile/release-trains/index.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: Release Trains
----
-## Release Trains
-
-The Release Train (also known as the Agile Release Train or ART) is a long-lived team of Agile teams, which, along with other stakeholders, develops and delivers solutions incrementally, using a series of fixed-length Iterations within a Program Increment (PI) timebox. The ART aligns teams to a common business and technology mission.
-
-## Details
-
-ARTs are cross-functional and have all the capabilities—software, hardware, firmware, and other—needed to define, implement, test, and deploy new system functionality. An ART operates with a goal of achieving a continuous flow of value.
-
-ARTs include the teams that define, build, and test features and components. SAFe teams have a choice of Agile practices, based primarily on Scrum, XP, and Kanban. Software quality practices include continuous integration, test-first, refactoring, pair work, and collective ownership. Hardware quality is supported by exploratory early iterations, frequent system-level integration, design verification, modeling, and Set-Based Design.
-
-Agile architecture supports software and hardware quality. Each Agile team has five to nine dedicated individual contributors, covering all the roles necessary to build a quality increment of value for an iteration. Teams can deliver software, hardware, and any combination. And of course, Agile teams within the ART are themselves cross-functional.
-
-
-
-#### More Information:
-
-Scaled Agile .
diff --git a/client/src/pages/guide/english/agile/retrospectives/index.md b/client/src/pages/guide/english/agile/retrospectives/index.md
deleted file mode 100644
index ad47f9a6b3..0000000000
--- a/client/src/pages/guide/english/agile/retrospectives/index.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: Retrospectives
----
-
-## Retrospectives
-
-The Sprint Retrospective can really be the most useful and important of the scrum ceremonies.
-
-The concept of *"Inspect and Adapt"* is crucial to creating a successful and thriving team.
-
-The standard agenda for the retrospective is:
-
-* What do we keep doing?
-* What do we stop doing?
-* What do we start doing?
-* Who do we want to say thank you to? (Not necessary but good practice)
-
-And from this discussion, the team creates a list of behaviors that they work on, collectively, over time.
-
-When commiting to action items, make sure you focus on 1 - 3. It is better to get a couple done, than commiting to more and not doing them. If it is difficult to come up with actions, try running experiments: Write down what you will do and what you want to achieve with that. In the following retro check if what you did achieved what you had planned. If it did not - you can learn out of the experiment and try out something else.
-
-A good approach to find out which topics should be discussed is *"Discuss and mention"*. It consists on a board with as many columns as people in the team (you can use something like Trello or just a regular whiteboard) and two more for the things to "discuss" and those to be "mentioned". Everybody has 10 minutes to fill their column with things from the last sprint they want to highlight (these are represented with cards or Post-it's). Afterwards, each team member explains each of their own items. Finally, each team member chooses which topics they think should be mentioned or discussed, by moving the card/post-it to the respectively column. The team then decides which topics should be discussed and talk about them for about 10 minutes.
-
-Invite the scrum team only to the Retrospective. (Delivery Team, Product Owner, Scrum Master). Discourage managers, stakeholders, business partners, etc. They are a distraction and can hinder the sense of openness the team needs.
-
-When conducting a retrospective make sure that in the first 5 - 10 minutes everyone says at least a couple of words. When team members speak up in the beginning of the meeting, it is more likely that they contribute during the whole meeting.
-
-During the retrospective it is important that the team stays productive. A simple way to keep people in a positive mood is to focus on what is in the control of the team.
-
-- For a co-located team, index cards and post-its work great for this process.
-- For distributed teams, there are a variety of online tools and apps to facilitate the discussion
- - https://www.senseitool.com/home
- - http://www.leancoffeetable.com/
-
-Action items should be notated on a board to make tracking progress visual and more distinguishable. Every new retrospective should start with reviewing the status of the action items decided upon during the *previous* restrospective.
-
-#### More Information:
-
-
-- Inspirations for preparing a retrospective:
- - https://plans-for-retrospectives.com/en/
- - http://www.funretrospectives.com/
-- How to run experiments with the popcorn flow:
- - https://www.slideshare.net/cperrone/popcornflow-continuous-evolution-through-ultrarapid-experimentation
-
diff --git a/client/src/pages/guide/english/agile/safe/index.md b/client/src/pages/guide/english/agile/safe/index.md
deleted file mode 100644
index 7311c61b7e..0000000000
--- a/client/src/pages/guide/english/agile/safe/index.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: SAFe
----
-## SAFe
-
-SAFe stands for "Scaled Agile Framework" and is an agile software development framework that is designed for large-scale agile development involving many teams.
-
-The main website (http://www.scaledagileframework.com/ ) is an freely available online knowledge base on implementing SAFe.
-
-## Principles
-
-There are nine, underlying principles for SAFe
-
-1. **Take an economic view** - evaluate economic costs of decisions, developments, and risks
-2. **Apply systems thinking** - development processes are interactions among the systems used by workers and thus need to view progress with systems thinking
-3. **Assume variability; preserve options** - requirements change, be flexible, and use empirical data to narrow focus
-4. **Build incrementally with fast, integrated learning cycles** - fast, incremental builds allow rapid feedback in order to change the project if necessary
-5. **Base milestones on objective evaluation on working systems** - objective evaluation provides important information such as financials and governance as feedback
-6. **Visualize and limit WIP, reduce batch sizes, and manage queue lengths** - do these to achieve continuous flow to move quickly and visualize progress; WIP = work-in-progress
-7. **Apply cadence, synchronize with cross-domain planning** - cadence is setting dates when certain events happen (e.g. release weekly) and synchronizing makes sure everyone has the same goals in mind
-8. **Unlock the intrinsic motivation of knowledge workers** - people work better when you make use of their personal motivations
-9. **Decentralize decision-making** - allows faster action, which may be not the best solution, but allows faster communication among teams; centralized decision-making may be necessary for more strategic or global decisions
-
-## Configurations
-
-There are four variations of SAFe, varying in complexity and needs of your project:
-
-1. Essential SAFe
-2. Portfolio SAFe
-3. Large Solution SAFe
-4. Full SAFe
-
-#### More Information:
-
-- Scaled Agile Framework
-- What is SAFe?
-- The Ten Essential Elements
-- SAFe Principles
diff --git a/client/src/pages/guide/english/agile/scrum/index.md b/client/src/pages/guide/english/agile/scrum/index.md
deleted file mode 100644
index 7d0e92d902..0000000000
--- a/client/src/pages/guide/english/agile/scrum/index.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title: Scrum
----
-## Scrum
-
-Scrum is one of the methodologies under the Agile umbrella. The name is derived from a method of resuming play in the sport of rugby, in which the entire team moves together to make ground. Similarly, a scrum in Agile involves all parts of the team working on the same set of goals. In the scrum method, a prioritized list of tasks is presented to the team, and over the course of a "sprint" (usually two weeks), those tasks are completed, in order, by the team. This insures that the highest-priority tasks or deliverables are completed before time or funds run out.
-
-### Components of a Scrum
-
-Scrum is one of the methodologies under the Agile umbrella. It originates from 'scrummage' which is a term used in rugby to denote players huddling together to get possession of the ball.
-The practice revolves around
-
-- A set of roles (delivery team, product owner, and scrum master)
-- Ceremonies (sprint planning, daily standup, sprint review, sprint retrospective, and backlog grooming)
-- Artifacts (product backlog, sprint backlog, product increment, and info radiators and reports).
-- The main goal is to keep the team aligned on project progress to facilitate rapid iteration.
-- Many organisations have opted for Scrum, because unlike the Waterfall model, it ensures a deliverable at the end of each Sprint.
-
-## Artifacts
-- Sprint: It is the time duration, mostly in weeks, for which a Team works to achieve or create a deliverable. A deliverable can defined as a piece of code of fragment of the Final Product which the team wants o achieve. Scrum advises to keep the duration of a Sprint between 2-4 weeks.
-- Product Backlog: It is the list of tasks a Team is supposed to finish within the current Sprint. It is decided by the Product Owner, in agreement with the Management as well as Delivery Team.
-
-## Roles
-- Product Owner(PO): The ONLY Accountable person to the Management. PO decides what goes in or out of the Product Backlog.
-- Delivery Team: They are required to work in accordance with the tasks set by their PO in the product backlog and deliver the required delivarable at the end of the sprint.
-- Scrum Masters: - Scrum Master's has to strictly adhere to Scrum Guide and make the team understand the need to adhere to Scrum guide when following Scrum. It is a Scrum Master's job to ensure all Scrum ceremonies being conducted on time and participated by all the required people as per the scrum guide. The SM has to ensure that the Daily Scrum is conducted regularly and actively participated by the team.
-
-#### More Information:
-
-There are several online tools that can be used to do scrum for your team:
-
-- [Scrum Do](https://www.scrumdo.com/)
-- [Asana](http://www.asana.com)
-- [Trello](http://trello.com)
-- [Monday](https://monday.com)
-- [Basecamp](https://basecamp.com)
-- [Airtable](https://airtable.com)
-- [SmartSheet](https://www.smartsheet.com)
-
-Here are some more resources:
-
-- [Why Scrum](https://www.scrumalliance.org/why-scrum) from The Scrum Alliance
-- [Scrum Guide](http://www.scrumguides.org/scrum-guide.html) from Scrum.org
-- [Doing vs Being Agile](http://agilitrix.com/2016/04/doing-agile-vs-being-agile/)
diff --git a/client/src/pages/guide/english/agile/scrummasters/index.md b/client/src/pages/guide/english/agile/scrummasters/index.md
deleted file mode 100644
index af71b00247..0000000000
--- a/client/src/pages/guide/english/agile/scrummasters/index.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: Scrummasters
----
-## Scrum Master
-
-The Scrum Master is responsible for ensuring Scrum is understood and enacted. Scrum Masters do this by ensuring that the Scrum Team adheres to Scrum theory, practices, and rules.
-
-The Scrum Master is a servant-leader for the Scrum Team. The Scrum Master helps those outside the Scrum Team understand which of their interactions with the Scrum Team are helpful and which aren’t. The Scrum Master helps everyone change these interactions to maximize the value created by the Scrum Team.
-
-### Scrum Master's Job
-
-- Facilitating (not participating in) the daily standup
-- Helping the team maintain their burndown chart
-- Setting up retrospectives, sprint reviews or sprint planning sessions
-- Shielding the team from interruptions during the sprint
-- Removing obstacles that affect the team
-- Walking the product owner through more technical user stories
-- Encouraging collaboration between the Scrum team and product owner .
-
-Typically a Scrummaster will ask the following qustions:
-1. What did you do yesterday?
-2. What are you going to do today?
-3. Is there anything stopping your progress?
-
-Scrum masters are part of an Agile team. They can be developers or other functional members (wearing multiple hats) or functioning individually as a sole role in a team. Their main objective is to enhance the development using the Scrum framework.
-
-Often their role is to: guide the sprint planning, monitor daily standup, conduct retrospectives, ensure velocity is present, help Scoping of Sprints.
-
-#### More Information:
-
-- What is a Scrum Master
-- Scrum Guide
\ No newline at end of file
diff --git a/client/src/pages/guide/english/agile/self-organization/index.md b/client/src/pages/guide/english/agile/self-organization/index.md
deleted file mode 100644
index 21d9c62568..0000000000
--- a/client/src/pages/guide/english/agile/self-organization/index.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: Self Organization
----
-## Self Organization
-
-
-In order to maintain high dynamics and agility of developed projects, all team members should mindfully share responsibility for product that is being developed.
-
-Vertically oriented organisational structures proved themself to be slow and inflexible with many levels of decision making. If a team wants to act fast and react dynamically to constantly changing environment, the organisational structure needs to be flat with members feeling strongly responsible for their input into the project.
-
-It does not mean that management is obsolete process in an agile self-organised team. It just has a different characteristic than in traditional approach (especially in large organisations, but not only), proving to be more effective when more supportive and advisory than despotic and direct.
-
-Foundation of self-organisation is trust and commitment of team's members.
-
-Scrum teams are said to be self organising. This means that the work done and generally the way it is done is left up to the team to decide - they are
-empowered by their managers to guide themselves in the ways that makes them most effective. The members of the team (Delivery Team, Product Owner, and
-Scrum Master) regularly inspect their behaviors to continuously improve.
-
-During Sprint Planning the team will look at the product backlog (which will have been prioritised by the product owner) and decide which stories they
-will work on in the upcoming sprint and the tasks which will need completing to mark the story as Done. The team will estimate a score or size for the
-story to denote effort.
-
-During a sprint it is up to the members of the team to pick up sprint backlog stories to work on, generally they will pick ones they think they can
-achieve. Due to it being a self organising team, there should be no assigning a task to a team member by someone else.
-
-#### More Information:
-- Scrum.org on [Scrum Promoting Self Organization](https://www.scrum.org/resources/blog/how-does-scrum-promote-self-organization)
-- Scrum.org on [Scrum Roles Promoting Self Organization](https://www.scrum.org/resources/blog/how-do-3-scrum-roles-promote-self-organization)
-- Scrum Alliance on [What and How of Self Organization](https://scrumalliance.org/community/articles/2013/january/self-organizing-teams-what-and-how)
diff --git a/client/src/pages/guide/english/agile/spikes/index.md b/client/src/pages/guide/english/agile/spikes/index.md
deleted file mode 100644
index 899135724c..0000000000
--- a/client/src/pages/guide/english/agile/spikes/index.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: Spikes
----
-## Spikes
-
-Not everything your team works on during the Sprint are User Stories. Sometimes, a user story cannot be effectively estimated or research is required. Maybe help is needed to decide between different architectures, to rule out some risks, or it may be a Proof of Concept (POC) to demonstrate a capability.
-
-In these cases, a Spike is added to the Sprint Backlog. The Acceptance Criteria for the Spike should be an answer to the question being posed. If the experiment is more difficult than anticipated, then maybe the answer is negative. (That's why the Spike should be limited in time.)
-
-The time and energy invested in the Spike are intentionally limited so that the work can be completed within the Sprint while other User Stories are minimally impacted. The Spike does not usually receive a Story Point Estimate, but is given a fixed number of hours to be worked on.
-
-Demonstrate the results of the Spike in the Sprint Review. Based on the new information, the original question is reframed as a new User Story in a future Sprint.
-
-Your team gained the information necessary to make better decisions; to reduce uncertainty. With a small, measured amount of its resources to increase the quality and value of work in future Sprints, as opposed to making decisions based on guess-work.
-
-
-#### More Information:
-
-- Mountain Goat Software [Spikes](https://www.mountaingoatsoftware.com/blog/spikes)
-- Scrum.org Forum [How to Integrate a Spike](https://www.scrum.org/forum/scrum-forum/5512/how-integrate-spike-scrum)
-- Scrum Alliance [Spikes and Effort-to-Grief Ratio](https://www.scrumalliance.org/community/articles/2013/march/spikes-and-the-effort-to-grief-ratio)
-- Wikipedia [Spike](https://en.wikipedia.org/wiki/Spike_(software_development))
-
diff --git a/client/src/pages/guide/english/agile/sprint-backlog/index.md b/client/src/pages/guide/english/agile/sprint-backlog/index.md
deleted file mode 100644
index 7c0a6d2e9c..0000000000
--- a/client/src/pages/guide/english/agile/sprint-backlog/index.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Sprint Backlog
----
-## Sprint Backlog
-
-The Sprint Backlog is a list of tasks identified by the Scrum Team to be completed during the Scrum Sprint. During the Sprint Planning meeting, the team selects a number of Product Backlog items, usually in the form of user stories, and identifies the tasks necessary to complete each user story.
-
-It is critical that the team itself selects the items and size of the Sprint Backlog. Because they are the people implementing / completing the tasks, they must be the people to choose what they are forecating to achive during the Sprint.
-
-#### More Information:
-[Scrum Guide: Sprint Backlog](http://www.scrumguides.org/scrum-guide.html#artifacts-sprintbacklog)
diff --git a/client/src/pages/guide/english/agile/sprint-planning-meetings/index.md b/client/src/pages/guide/english/agile/sprint-planning-meetings/index.md
deleted file mode 100644
index c4f4be818e..0000000000
--- a/client/src/pages/guide/english/agile/sprint-planning-meetings/index.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: Sprint Planning Meeting
----
-## Sprint Planning Meeting
-
-The Sprint Planning is facilitated by the team's Scrum Master and consists of the Scrum Team: Development Team, Product Owner (PO) and Scrum Master (SM). It aims to plan a subset of Product Backlog items into a Sprint Backlog. The Scrum Sprint is normally started in after the Sprint Planning meeting.
-
-### Main part
-It is of high value for the team to part the meeting in two parts by asking this two questions:
-* **What** should the team plan for the upcoming Sprint?
-* **How** should the team (roughly) takle the items planned?
-
-#### What
-In What phase the team starts with the top of the ordered Product Backlog. The team at least implicitly estimates the items by forecasting what they could take into Sprint Backlog. If needed they could ask / discuss items with the PO, who has to be in place for this meeting.
-
-#### How
-In How phase the team shortly discusses every picked Sprint Backlog item with the focus on how they will takle it. SM helps the team not to deep dive into discussion and implementation details. It is very likely and good if more questions to the PO are asked or refinements to the items, or backlog is done by the team.
-
-### Sprint Goal / Closing
-The team should come up with a shared Sprint Goal for the Sprint to keep the focus in the Sprint time box. At the end of the Sprint Planning the team forecasts that they can achieve the Sprint Goal and complete most likely all Sprint Backlog items. The SM should prevent the team to overestimate by providing useful insights or statistics.
-
-#### More Information:
-[Scrum Guide: Sprint Planning](http://www.scrumguides.org/scrum-guide.html#events-planning)
-[Simple Cheat Sheet to Sprint Planning Meetings](https://www.leadingagile.com/2012/08/simple-cheat-sheet-to-sprint-planning-meeting/)
-[Four Steps for Better Sprint Planning](https://www.atlassian.com/blog/agile/sprint-planning-atlassian)
\ No newline at end of file
diff --git a/client/src/pages/guide/english/agile/sprint-planning/index.md b/client/src/pages/guide/english/agile/sprint-planning/index.md
deleted file mode 100644
index 3138b18f6c..0000000000
--- a/client/src/pages/guide/english/agile/sprint-planning/index.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: Sprint Planning
----
-
-## Sprint Planning
-
-In Scrum, the sprint planning meeting is attended by the product owner, ScrumMaster and the entire Scrum team. Outside stakeholders may attend by invitation of the team, although this is rare in most companies.
-During the sprint planning meeting, the product owner describes the highest priority features to the team. The team asks enough questions that they can turn a high-level user story of the product backlog into the more detailed tasks of the sprint backlog.
-
-There are two defined artifacts that result from a sprint planning meeting:
-- A sprint goal
-- A sprint backlog
-
-Sprint Planning is time-boxed to a maximum of eight hours for a one-month Sprint. For shorter Sprints, the event is usually shorter. The Scrum Master ensures that the event takes place and that attendants understand its purpose. The Scrum Master teaches the Scrum Team to keep it within the time-box.
-
-#### More Information:
-* https://www.mountaingoatsoftware.com/agile/scrum/meetings/sprint-planning-meeting
-* [Scrum Guide](http://www.scrumguides.org/scrum-guide.html)
diff --git a/client/src/pages/guide/english/agile/sprint-review/index.md b/client/src/pages/guide/english/agile/sprint-review/index.md
deleted file mode 100644
index e18ef4142b..0000000000
--- a/client/src/pages/guide/english/agile/sprint-review/index.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: Sprint Review
----
-## Sprint Review
-
-The Sprint Review is one of the key Scrum ceremonies (along with Sprint Planning, the Daily Stand Up, the Retrospective, and Grooming).
-
-At the end of the Sprint, your Scrum team hosts an "Invite the World" session to showcase what has just been Completed and Accepted. Invited are the Scrum Team, Stakeholders, Managers, Users; anyone with an interest in the project.
-
-Holding these sessions every Sprint is important. It may be a mindset shift; showing unfinished work to your managers and stakeholders. But in the concept of "Fail Fast", there is incredible value in getting feedback on your incremental work. Your team can course-correct if necessary, minimizing work lost.
-
-Since the Product Owner (PO) is often presenting at the Sprint Review, the Scrum Master will usually capture the feedback, perhaps facilitate the discussions, and then work with the PO to get new User Stories added to the Backlog and prioritized.
-
-The agenda may also include a review of the Backlog (including value and priority), what is scheduled for the next Iteration or two, and what can be removed from the Backlog.
-
-**IMPORTANT** The Sprint Review is completely different than the Retrospective. The Retrospective is stricly for the Scrum team (Scrum Master, PO and Delivery Team). The other parties that are invited to the Review are excused from, and will likely interfere with, the Retrospective. (Yes, including Managers.)
-
-
-
-#### More Information:
-
-Ken Rubin of Innolution Stop Calling Your Sprint Review a Demo
-
-Scrum.org What is a Sprint Review
-
-Mountain Goat Software Sprint Review Meeting
-
-Atlassian Three Steps for Better Sprint Reviews
-
-Age of Product Sprint Review Anti Patterns
-
diff --git a/client/src/pages/guide/english/agile/sprints/index.md b/client/src/pages/guide/english/agile/sprints/index.md
deleted file mode 100644
index a3b78d9ba6..0000000000
--- a/client/src/pages/guide/english/agile/sprints/index.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: Sprints
----
-## Sprints
-
-In Scrum, the **Sprint** is a period of working time usually between one and four weeks in which the delivery team works on your project. Sprints are iterative, and continue until the project is completed. Each sprint begins with a Sprint Planning session, and ends with Sprint Review and Retrospective meetings. Using sprints, as opposed to months-long waterfall or linear sequential development methodologies, allows regular feedback loops between project owners and stakeholders on the output from the delivery team.
-
-## Properties of a Sprint
--Sprints should remain the same pretetermined length of time throughout the length of the project.
--The team works to break up the User Stories to a size that can be completed within the duration of the Sprint without carrying over to the next.
--"Sprint" and "Iteration" are often used interchangeably.
-
-#### More Information:
-
-- Agile Alliance on Iterations
-- Agile Alliance on Timeboxes
-- Agile Coach on Sprint vs Iteration
-- Scrum Alliance Timeboxing as a Motivational Factor
-- Scrum Alliance Sprint is More Than Just a Timebox
-- Scrum Inc What is Timeboxing
-- Scrum.org What is a Sprint in Scrum
diff --git a/client/src/pages/guide/english/agile/stakeholders/index.md b/client/src/pages/guide/english/agile/stakeholders/index.md
deleted file mode 100644
index 7291e14ccb..0000000000
--- a/client/src/pages/guide/english/agile/stakeholders/index.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: Stakeholders
----
-## Stakeholders
-
-The Stakeholders are the people that will benefit from your project. It is up to the Product Owner to understand the outcome required by the Stakeholders, and to communicate that need to the Delivery Team.
-Stakeholders may be made up from any of the following
-- Users
-- Customers
-- Managers
-- Funders / investors
-
-Their participation in the project is essential for success.
-
-For example, when your team is performing the Sprint Review meetings, the demonstration of the project is for the stakeholders, and their feedback is captured and added to the backlog.
-
-#### More Information:
-
-- Scrum Study Stakeholders in Scrum
-- Scrum.org Key Stakeholders
-- Agile Modelling Active Stakeholder Participation
-
-
diff --git a/client/src/pages/guide/english/agile/story-points-and-complexity-points/index.md b/client/src/pages/guide/english/agile/story-points-and-complexity-points/index.md
deleted file mode 100644
index e2ed6e5561..0000000000
--- a/client/src/pages/guide/english/agile/story-points-and-complexity-points/index.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: Story Points and Complexity Points
----
-## Story Points and Complexity Points
-
-In Scrum/Agile, the functionality of a product in development is explored by way of **stories** a user might tell about what they want from a product. A team uses **Story Points** when they estimate the amount of effort required to deliver a user story.
-
-Notable features of story points are that they:
-
-* represent the contributions of the whole team
-* do not equate directly to time the task might take
-* are a rough measure for planning purposes - similar to orders of magnitude
-* are assigned in a Fibonacci-like sequence: 0, 1, 2, 3, 5, 8, 13, 20, 40, 100
-* estimate the 'size' of stories *relative to each other*
-
-The concept of story points can be quite elusive if you are new to Agile ways of doing things. You will find many online sources discussing story points in different ways, and it can be hard to get a clear idea of what they are and how they are used.
-
-As you learn about the principles and terminology of practices like Scrum, the reasons for some of these properties will become apparent. The use of story points, especially in 'ceremonies' such as planning poker, is much easier to understand by observing or taking part than in a written explanation!
-
-### More Information:
-- User Stories: freeCodeCamp
-- Common mistakes when using story points: Medium
-- Planning Poker: Mountain Goat Software
diff --git a/client/src/pages/guide/english/agile/sustainable-pace/index.md b/client/src/pages/guide/english/agile/sustainable-pace/index.md
deleted file mode 100644
index 9da5840c6d..0000000000
--- a/client/src/pages/guide/english/agile/sustainable-pace/index.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Sustainable Pace
----
-## Sustainable Pace
-
-A Sustainable Pace is the pace at which you and your team can work for extended periods, even forever.
-It respects your weekends, evenings, holidays, and vacations. It allows for necessary meetings and personal development time.
-
-
-
-#### More Information:
-[What is Sustainable Pace?](http://www.sustainablepace.net/what-is-sustainable-pace)
-
diff --git a/client/src/pages/guide/english/agile/task-boards-and-kanban/index.md b/client/src/pages/guide/english/agile/task-boards-and-kanban/index.md
deleted file mode 100644
index f425465919..0000000000
--- a/client/src/pages/guide/english/agile/task-boards-and-kanban/index.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Task Boards and Kanban
----
-## Task Boards and Kanban
-Kanban is an excellent method both for teams doing software development and individuals tracking their personal tasks.
-
-Derived from the Japanese term for "signboard" or "billboard" to represent a signal, the key principal is to limit your work-in-progress (WIP) to a finite number of tasks at a given time. The amount that can be In Progress is determined by the team's (or individual's) constrained capacity. As one task is finished, that's the signal for you to move another task forward into its place.
-
-Your Kanban tasks are displayed on the Task Board in a series of columns that show the state of the tasks. In its simplest form, three columns are used
-- To Do
-- Doing
-- Done
-
-
-
-*Image courtesy of Wikipedia *
-
-But many other columns, or states, can be added. A software team may also include Waiting to Test, Complete, or Accepted, for example.
-
-
-
-*Image courtesy of leankit *
-
-### More Information:
-- What is Kanban: Leankit
-- What is Kanban: Atlassian
-
-Some online boards
-- Trello
-- KanbanFlow
diff --git a/client/src/pages/guide/english/agile/technical-debt/index.md b/client/src/pages/guide/english/agile/technical-debt/index.md
deleted file mode 100644
index 60298920bf..0000000000
--- a/client/src/pages/guide/english/agile/technical-debt/index.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Technical Debt
----
-## Technical Debt
-Often in agile development, if you are producing software in the "good enough" practice, you will also be adding to your technical debt. This is the accumulation of short cuts and work-arounds.
-
-Compare it to money. When you charge something on a credit card, you've made a commitment to pay it back later. When you create technical debt, your team *should* commit to addressing those issues on a schedule.
-
-One of the benefits of working iteratively is to frequently showcase your increments and gather feedback. If your first pass is "good enough", and changes are required as a result of that feedback, you may have avoided some unnecessary work. Capture this in your backlog, and include a portion in each sprint to be refactored or improved.
-
-
-#### More Information:
-
-- The Agile Alliance on Technical Debt
-- Scrum Alliance on Managing Technical Debt
-
diff --git a/client/src/pages/guide/english/agile/test-driven-development/index.md b/client/src/pages/guide/english/agile/test-driven-development/index.md
deleted file mode 100644
index 22c5fcaafa..0000000000
--- a/client/src/pages/guide/english/agile/test-driven-development/index.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: Test Driven Development
----
-## Test Driven Development
-
-Test Driven Development (TDD) is one of Agile Software Development approaches. It is based on the concept that
-> you must write a test case for your code even before you write the code
-
-Here, we write unit test first and then write the code to complete the test successfully. This saves time spend to perform unit test and other similar test, as we are going ahead with the successful iteration of the test as well leading to achieve modularity in the code.
-It's basically composed of 4 steps
-
- - Write a test case
- - See the test fail (Red)
- - Make the test pass, comitting whatever crimes in the process (Green)
- - Refactor the code to be up to standards (Refactor)
-
- These steps follow the principle of Red-Green-Refactor. Red-Green make sure that you write the simplest code possible to solve the problem while the last step makes sure that the code that you write is up to the standards.
-
-Each new feature of your system should follow the steps above.
-
-
-
-
-#### More Information:
-
-Agile Data's Introduction to TDD
-
-Wiki on TDD
-
-Martin Fowler Is TDD Dead?
- (A series of recorded conversations on the subject)
-
- Kent Beck's book Test Driven Development by Example
-
-Uncle Bob's The Cycles of TDD
diff --git a/client/src/pages/guide/english/agile/the-agile-manifesto/index.md b/client/src/pages/guide/english/agile/the-agile-manifesto/index.md
deleted file mode 100644
index fb1cca8104..0000000000
--- a/client/src/pages/guide/english/agile/the-agile-manifesto/index.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: The Manifesto
----
-## The Manifesto
-
-
-### Origin
-
-> On February 11-13, 2001, at The Lodge at Snowbird ski resort in the Wasatch mountains of Utah, seventeen people met to talk, ski, relax, and try to find common ground—and of course, to eat. […] Now, a bigger gathering of organizational anarchists would be hard to find, so what emerged from this meeting was symbolic—a Manifesto for Agile Software Development—signed by all participants. (1)
-
-### Manifesto for agile software development
-
-We are uncovering better ways of developing software by doing it and helping others do it.
-
-Through this work, we have come to value
-
-- **Individuals and interactions** over process and tools.
-- **Working software** over comprehensive documentation.
-- **Customer collaboration** over contract negotiation.
-- **Responding to change** over following a plan.
-
-That is, while there is value in the items on the right, we value the items on the left more.
-
-### Twelve Principles of Agile Software
-
- 1. Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
- 2. Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.
- 3. Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
- 4. Business people and developers must work together daily throughout the project.
- 5. Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
- 6. The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
- 7. Working software is the primary measure of progress.
- 8. Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
- 9. Continuous attention to technical excellence and good design enhances agility.
- 10. Simplicity–the art of maximizing the amount of work not done–is essential.
- 11. The best architectures, requirements, and designs emerge from self-organizing teams.
- 12. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.
-
-
-#### More Information:
-
-* [(1) History: The Agile Manifesto](http://agilemanifesto.org/history.html)
-* [Agile Manifesto](http://agilemanifesto.org/)
diff --git a/client/src/pages/guide/english/agile/user-acceptance-tests/index.md b/client/src/pages/guide/english/agile/user-acceptance-tests/index.md
deleted file mode 100644
index eda55b1cac..0000000000
--- a/client/src/pages/guide/english/agile/user-acceptance-tests/index.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: User Acceptance Tests
----
-## User Acceptance Tests
-
-In engineering and its various subdisciplines, acceptance testing is a test conducted to determine if the requirements of a specification or contract are met. It may involve chemical tests, physical tests, or performance tests.
-
-In systems engineering it may involve black-box testing performed on a system (for example: a piece of software, lots of manufactured mechanical parts, or batches of chemical products) prior to its delivery.
-
-In software testing the ISTQB defines acceptance as: formal testing with respect to user needs, requirements, and business processes conducted to determine whether a system satisfies the acceptance criteria and to enable the user, customers or other authorized entity to determine whether or not to accept the system. Acceptance testing is also known as user acceptance testing (UAT), end-user testing, operational acceptance testing (OAT) or field (acceptance) testing.
-
-A smoke test may be used as an acceptance test prior to introducing a build of software to the main testing process.
-
-One of the final steps in software testing is user acceptance testing (UAT). UAT makes sure actual users can use the software. Also referred to as beta, application, and end-user testing.
-
-UAT checks that everything works properly and that there are no crashes. Those of the intended audience should complete the testing; this could be comprised of many people involved from the process and anyone who is able to test before going live. The feedback from this testing is forwarded to the development team for any specific changes.
-
-
-#### Why do we need UAT
-
-* Requirement changes might not have communicated to the developers
-
-* The software may not be delivering actually what it meant for
-
-* Some logic or business process may need user's attention
-
-
-#### What is required before we start UAT
-
-* Complete requriement is signed off and is available as documented
-
-* The code is in working or in demoable condition
-
-* UAT is environment is ready for access
-
-* There should not be any defect which will break the code
-
-* Test data prepared in accordance with the LIVE scneario
-
-
-#### Framework & tools used
-
-* FitNesse
-
-
-#### Articles about UAT
-
-* [7 KEYS TO A SUCCESSFUL USER ACCEPTANCE TESTING](http://blog.debugme.eu/successful-user-acceptance-testing/)
-
-* [AgileUAT: A Framework for User Acceptance Testing
-based on User Stories and Acceptance Criteria](http://research.ijcaonline.org/volume120/number10/pxc3903533.pdf)
-
-
-#### More Information:
-https://en.wikipedia.org/wiki/Acceptance_testing
-
diff --git a/client/src/pages/guide/english/agile/user-stories/index.md b/client/src/pages/guide/english/agile/user-stories/index.md
deleted file mode 100644
index 7fe1331531..0000000000
--- a/client/src/pages/guide/english/agile/user-stories/index.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: User Stories
----
-User stories are part of an agile approach that helps shift the focus from writing about requirements to talking about them. All agile user stories include a written sentence or two and, more importantly, a series of conversations about the desired functionality.
-
-User stories are typically written using the following pattern:
-#### As a [ type of user ], I want [ some goal ] so that [ some reason or need ]
-
-User stories should be written in non-technical terms from the perspective of the user. The story should emphasize the need of the user, and not the how. There should be no solution provided in the user story.
-
-One common mistake that is made when writing user stories is writing from the perspective of the developer or the solution. Be sure to state the goal and the need, and the functional requirements come later.
-
-#### Sizing a User Story: Epics and Smaller Stories
-An epic is a big, coarse-grained story. It is typically broken into several user stories over time—leveraging the user feedback on early prototypes and product increments. You can think of it as a headline and a placeholder for more detailed stories.
-
-Starting with epics allows you to sketch the product functionality without committing to the details. This is particularly helpful for describing new products and features: It allows you to capture the rough scope, and it buys you time to learn more about how to best address the needs of the users.
-
-It also reduces the time and effort required to integrate new insights. If you have many detailed stories in the product backlog, then it’s often tricky and time-consuming to relate feedback to the appropriate items and it carries the risk of introducing inconsistencies.
-
-When thinking about possible stories, it is also important to consider "mis-user cases" and "unhappy path" stories. How will exceptions be handled by the system? What kind of messaging will you provide back to user? How would a malicious user abuse this application function? These mal-stories can save rework and become usful test cases in QA.
-
-#### More Information:
-- Mountain Goat Software Guide to User Stories
-- Roman Pichler Guide to User Stories
diff --git a/client/src/pages/guide/english/agile/value-stream-mapping/index.md b/client/src/pages/guide/english/agile/value-stream-mapping/index.md
deleted file mode 100644
index 0a6a00a0b1..0000000000
--- a/client/src/pages/guide/english/agile/value-stream-mapping/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Value Stream Mapping
----
-## Value Stream Mapping
-
-**Value stream mapping** is a lean software development technique. It helps to identity the waste in resources in terms of material, effort, cost and time.
-
-Calculating the process cycle efficiency is one of the ways to find out the efficiency of the AS-IS process.
-
-**Process cycle efficiency = Value-added time spent / total cycle time.**
-
-The higher the value the better the efficiency.
-
-#### More Information:
-* [Wikipedia](https://en.wikipedia.org/wiki/Value_stream_mapping)
diff --git a/client/src/pages/guide/english/agile/vanity-metrics/index.md b/client/src/pages/guide/english/agile/vanity-metrics/index.md
deleted file mode 100644
index 7bf8927d50..0000000000
--- a/client/src/pages/guide/english/agile/vanity-metrics/index.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: Vanity Metrics
----
-## Vanity Metrics
-
-Where Vanity is the value of appearance over quality, Vanity Metrics are measurements that, without context or explanation, are used to make someone or something look good. Eric Ries, posting at Harvard Business Review , suggests metrics should be **actionable**, **accessible**, and **auditable** to have meaning.
-
-
-
-Examples:
-- Registered users vs Active users
-- User stories accepted vs Value delivered to the customer
-- Twitter followers vs Retweets
-
-
-_image via kissmetrics_
-
-
-
-#### More Information:
-
-
-Fizzle on Actionable vs Vanity Metrics
-
-Harvard Business Review on Vanity Metrics
-
-Forbes Ignore Vanity Metrics and Focus on Engagement
-
-kissmetrics Throw Away Vanity Metrics
diff --git a/client/src/pages/guide/english/agile/velocity/index.md b/client/src/pages/guide/english/agile/velocity/index.md
deleted file mode 100644
index 26f8838c71..0000000000
--- a/client/src/pages/guide/english/agile/velocity/index.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Velocity
----
-## Velocity
-
-On a Scrum team, you determine the velocity at the end of each Iteration. It is simply the sum of Story Points completed within the timebox.
-
-Having a predictable, consistent velocity allows your team to plan your iterations with some confidence, to work sustainably, and to forecast, with empirical data, the amount of scope to include in each release.
-
-#### More Information:
-The Scrum Alliance on Velocity
diff --git a/client/src/pages/guide/english/agile/voice-of-the-customer/index.md b/client/src/pages/guide/english/agile/voice-of-the-customer/index.md
deleted file mode 100644
index 9343f854ca..0000000000
--- a/client/src/pages/guide/english/agile/voice-of-the-customer/index.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Voice of the Customer
----
-## Voice of the Customer
-
-You, as the Product Owner (PO), are the Voice of the Customer to the Delivery Team. When the team needs clarification on a story, to better understand the What and the Why, they will ask you.Product Owner
-
-Agile Alliance on the Product Owner
-
-
-
diff --git a/client/src/pages/guide/english/algorithms/algorithm-design-patterns/behavioral-patterns/index.md b/client/src/pages/guide/english/algorithms/algorithm-design-patterns/behavioral-patterns/index.md
deleted file mode 100644
index a1fc560e91..0000000000
--- a/client/src/pages/guide/english/algorithms/algorithm-design-patterns/behavioral-patterns/index.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Behavioral patterns
----
-
-## Behavioral patterns
-
-Behavioral design patterns are design patterns that identify common communication problems between objects and realize these patterns. By doing so, these patterns increase flexibility in carrying out this communication, making the software more reliable and easy to mantain.
-
-Examples of this type of design pattern include:
-
-1. **Chain of responsibility pattern**: Command objects are handled or passed on to other objects by logic-containing processing objects.
-2. **Command pattern**: Command objects encapsulate an action and its parameters.
-3. **Interpreter pattern**: Implement a specialized computer language to rapidly solve a specific set of problems.
-4. **Iterator pattern**: Iterators are used to access the elements of an aggregate object sequentially without exposing its underlying representation.
-5. **Mediator pattern**: Provides a unified interface to a set of interfaces in a subsystem.
-6. **Memento pattern**: Provides the ability to restore an object to its previous state (rollback).
-7. **Null Object pattern**: Designed to act as a default value of an object.
-8. **Observer pattern**: a.k.a. P**ublish/Subscribe** or **Event Listener**. Objects register to observe an event that may be raised by another object.
-9. **Weak reference pattern**: De-couple an observer from an observable.
-10. **Protocol stack**: Communications are handled by multiple layers, which form an encapsulation hierarchy.
-11. **Scheduled-task pattern**: A task is scheduled to be performed at a particular interval or clock time (used in real-time computing).
-12. **Single-serving visitor pattern**: Optimize the implementation of a visitor that is allocated, used only once, and then deleted.
-13. **Specification pattern**: Recombinable business logic in a boolean fashion.
-14. **State pattern**: A clean way for an object to partially change its type at runtime.
-15. **Strategy pattern**: Algorithms can be selected on the fly.
-16. **Template method pattern**: Describes the program skeleton of a program.
-17. **Visitor pattern**: A way to separate an algorithm from an object.
-
-### Sources
-[https://en.wikipedia.org/wiki/Behavioral_pattern](https://en.wikipedia.org/wiki/Behavioral_pattern)
diff --git a/client/src/pages/guide/english/algorithms/algorithm-design-patterns/creational-patterns/index.md b/client/src/pages/guide/english/algorithms/algorithm-design-patterns/creational-patterns/index.md
deleted file mode 100644
index 98252c6381..0000000000
--- a/client/src/pages/guide/english/algorithms/algorithm-design-patterns/creational-patterns/index.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: Creational patterns
----
-
-
-## Creational patterns
-
-Creational design patterns are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or in added complexity to the design. Creational design patterns solve this problem by somehow controlling this object creation.
-
-Creational design patterns are composed of two dominant ideas. One is encapsulating knowledge about which concrete classes the system uses. Another is hiding how instances of these concrete classes are created and combined.
-
-Five well-known design patterns that are parts of creational patterns are:
-
-1. **Abstract factory pattern**, which provides an interface for creating related or dependent objects without specifying the objects' concrete classes.
-2. **Builder pattern**, which separates the construction of a complex object from its representation so that the same construction process can create different representations.
-3. **Factory method pattern**, which allows a class to defer instantiation to subclasses.
-4. **Prototype pattern**, which specifies the kind of object to create using a prototypical instance, and creates new objects by cloning this prototype.
-5. **Singleton pattern**, which ensures that a class only has one instance, and provides a global point of access to it.
-
-### Sources
-1. [Gamma, Erich; Helm, Richard; Johnson, Ralph; Vlissides, John (1995). Design Patterns. Massachusetts: Addison-Wesley. p. 81. ISBN 978-0-201-63361-0. Retrieved 2015-05-22.](http://www.pearsoned.co.uk/bookshop/detail.asp?item=171742)
diff --git a/client/src/pages/guide/english/algorithms/algorithm-design-patterns/index.md b/client/src/pages/guide/english/algorithms/algorithm-design-patterns/index.md
deleted file mode 100644
index 37eea0a1dd..0000000000
--- a/client/src/pages/guide/english/algorithms/algorithm-design-patterns/index.md
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: Algorithm Design Patterns
----
-## Algorithm Design Patterns
-
-In software engineering, a design pattern is a general repeatable solution to a commonly occurring problem in software design. A design pattern isn't a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations.
-
-Design patterns can speed up the development process by providing tested, proven development paradigms.
-
-This patterns are divided in three major categories:
-
-### Creational patterns
-
-These are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or in added complexity to the design. Creational design patterns solve this problem by somehow controlling this object creation.
-
-### Structural patterns
-
-These are design patterns that ease the design by identifying a simple way to realize relationships between entities.
-
-### Behavioral patterns
-
-These are design patterns that identify common communication patterns between objects and realize these patterns. By doing so, these patterns increase flexibility in carrying out this communication.
-
-#### More Information:
-
-[Design patterns - Wikipedia](https://en.wikipedia.org/wiki/Design_Patterns)
-
diff --git a/client/src/pages/guide/english/algorithms/algorithm-design-patterns/structual-patterns/index.md b/client/src/pages/guide/english/algorithms/algorithm-design-patterns/structual-patterns/index.md
deleted file mode 100644
index 92aaf1f979..0000000000
--- a/client/src/pages/guide/english/algorithms/algorithm-design-patterns/structual-patterns/index.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: Structural patterns
----
-
-## Structural patterns
-
-Structural design patterns are design patterns that ease the design by identifying a simple way to realize relationships between entities and are responsible for building simple and efficient class hierarchies between different classes.
-
-Examples of Structural Patterns include:
-
-1. **Adapter pattern**: 'adapts' one interface for a class into one that a client expects.
-2. **Adapter pipeline**: Use multiple adapters for debugging purposes.
-3. **Retrofit Interface Pattern**: An adapter used as a new interface for multiple classes at the same time.
-4. **Aggregate pattern**: a version of the Composite pattern with methods for aggregation of children.
-5. **Bridge pattern**: decouple an abstraction from its implementation so that the two can vary independently.
-6. **Tombstone**: An intermediate "lookup" object contains the real location of an object.
-7. **Composite pattern**: a tree structure of objects where every object has the same interface.
-8. **Decorator pattern**: add additional functionality to a class at runtime where subclassing would result in an exponential rise of new classes.
-9. **Extensibility pattern**: a.k.a. Framework - hide complex code behind a simple interface.
-10. **Facade pattern**: create a simplified interface of an existing interface to ease usage for common tasks.
-11. **Flyweight pattern**: a large quantity of objects share a common properties object to save space.
-12. **Marker pattern**: an empty interface to associate metadata with a class.
-13. **Pipes and filters**: a chain of processes where the output of each process is the input of the next.
-14. **Opaque pointer**: a pointer to an undeclared or private type, to hide implementation details.
-15. **Proxy pattern** a class functioning as an interface to another thing.
-
-### Sources
-[https://en.wikipedia.org/wiki/Structural_pattern](https://en.wikipedia.org/wiki/Structural_pattern)
diff --git a/client/src/pages/guide/english/algorithms/algorithm-performance/index.md b/client/src/pages/guide/english/algorithms/algorithm-performance/index.md
deleted file mode 100644
index 6d8efc5a06..0000000000
--- a/client/src/pages/guide/english/algorithms/algorithm-performance/index.md
+++ /dev/null
@@ -1,90 +0,0 @@
----
-title: Algorithm Performance
----
-
-In mathematics, big-O notation is a symbolism used to describe and compare the _limiting behavior_ of a function.
-A function's limiting behavior is how the function acts as it tends towards a particular value and in big-O notation it is usually as it trends towards infinity.
-In short, big-O notation is used to describe the growth or decline of a function, usually with respect to another function.
-
-
-in algorithm design we usualy use big-O notation because we can see how bad or good an algorithm will work in worst mode. but keep that in mind it isn't always the case because the worst case may be super rare and in those cases we calculate average case. for now lest's disscus big-O notation.
-
-In mathematics, big-O notation is a symbolism used to describe and compare the _limiting behavior_ of a function.
-
-A function's limiting behavior is how the function acts as it trends towards a particular value and in big-O notation it is usually as it trends towards infinity.
-
-In short, big-O notation is used to describe the growth or decline of a function, usually with respect to another function.
-
-NOTE: x^2 is equivalent to x * x or 'x-squared']
-
-For example we say that x = O(x^2) for all x > 1 or in other words, x^2 is an upper bound on x and therefore it grows faster.
-The symbol of a claim like x = O(x^2) for all x > _n_ can be substituted with x <= x^2 for all x > _n_ where _n_ is the minimum number that satisfies the claim, in this case 1.
-
-Effectively, we say that a function f(x) that is O(g(x)) grows slower than g(x) does.
-
-
-Comparitively, in computer science and software development we can use big-O notation in order to describe the efficiency of algorithms via its time and space complexity.
-
-**Space Complexity** of an algorithm refers to its memory footprint with respect to the input size.
-
-Specifically when using big-O notation we are describing the efficiency of the algorithm with respect to an input: _n_, usually as _n_ approaches infinity.
-When examining algorithms, we generally want a lower time and space complexity. Time complexity of o(1) is indicative of constant time.
-
-Through the comparison and analysis of algorithms we are able to create more efficient applications.
-
-For algorithm performance we have two main factors:
-
-- **Time**: We need to know how much time it takes to run an algorithm for our data and how it will grow by data size (or in some cases other factors like number of digits and etc).
-
-- **Space**: our memory is finate so we have to know how much free space we need for this algorithm and like time we need to be able to trace its growth.
-
-The following 3 notations are mostly used to represent time complexity of algorithms:
-
-1. **Θ Notation**: The theta notation bounds a functions from above and below, so it defines exact behavior. we can say that we have theta notation when worst case and best case are the same.
- >Θ(g(n)) = {f(n): there exist positive constants c1, c2 and n0 such that 0 <= c1*g(n) <= f(n) <= c2*g(n) for all n >= n0}
-
-2. **Big O Notation**: The Big O notation defines an upper bound of an algorithm. For example Insertion Sort takes linear time in best case and quadratic time in worst case. We can safely say that the time complexity of Insertion sort is *O*(*n^2*).
- >O(g(n)) = { f(n): there exist positive constants c and n0 such that 0 <= f(n) <= cg(n) for all n >= n0}
-
-3. **Ω Notation**: Ω notation provides an lower bound to algorithm. it shows fastest possible answer for that algorithm.
- >Ω (g(n)) = {f(n): there exist positive constants c and n0 such that 0 <= cg(n) <= f(n) for all n >= n0}.
-
-## Examples
-
-As an example, we can examine the time complexity of the [bubble sort] algorithm and express it using big-O notation.
-
-#### Bubble Sort:
-```javascript
- // Function to implement bubble sort
- void bubble_sort(int array], int n)
- {
- // Here n is the number of elements in array
- int temp;
- for(int i = 0; i < n-1; i++)
- {
- // Last i elements are already in place
- for(int j = 0; j < n-i-1; j++)
- {
- if (array[j] > array[j+1])
- {
- // swap elements at index j and j+1
- temp = array[j];
- array[j] = array[j+1];
- array[j+1] = temp;
- }
- }
- }
- }
-```
-Looking at this code, we can see that in the best case scenario where the array is already sorted, the program will only make _n_ comparisons as no swaps will occur.
-Therefore we can say that the best case time complexity of bubble sort is O(_n_).
-
-Examining the worst case scenario where the array is in reverse order, the first iteration will make _n_ comparisons while the next will have to make _n_ - 1 comparisons and so on until only 1 comparison must be made.
-The big-O notation for this case is therefore _n_ * [(_n_ - 1) / 2] which = 0.5*n*^2 - 0.5*n* = O(_n_^2) as the _n_^2 term dominates the function which allows us to ignore the other term in the function.
-
-We can confirm this analysis using [this handy big-O cheat sheet that features the big-O time complexity of many commonly used data structures and algorithms
-
-It is very apparent that while for small use cases this time complexity might be alright, at a large scale bubble sort is simply not a good solution for sorting.
-This is the power of big-O notation: it allows developers to easily see the potential bottlenecks of their application, and take steps to make these more scalable.
-
-For more information on why big-O notation and algorithm analysis is important visit this video challenge !
diff --git a/client/src/pages/guide/english/algorithms/avl-trees/index.md b/client/src/pages/guide/english/algorithms/avl-trees/index.md
deleted file mode 100644
index 897bf1a920..0000000000
--- a/client/src/pages/guide/english/algorithms/avl-trees/index.md
+++ /dev/null
@@ -1,63 +0,0 @@
----
-title: AVL Trees
----
-## AVL Trees
-
-
-An AVL tree is a subtype of binary search tree.
-
-A BST is a data structure composed of nodes. It has the following guarantees:
-
-1. Each tree has a root node (at the top).
-2. The root node has zero or more child nodes.
-3. Each child node has zero or more child nodes, and so on.
-4. Each node has up to two children.
-5. For each node, its left descendents are less than the current node, which is less than the right descendents.
-
-AVL trees have an additional guarantee:
-6. The difference between the depth of right and left subtrees cannot be more than one. In order to maintain this guarantee, an implementation of an AVL will include an algorithm to rebalance the tree when adding an additional element would upset this guarantee.
-
-AVL trees have a worst case lookup, insert and delete time of O(log n).
-
-### Right Rotation
-
-
-
-### Left Rotation
-
-
-
-### AVL Insertion Process
-
-You will do an insertion similar to a normal Binary Search Tree insertion. After inserting, you fix the AVL property using left or right rotations.
-
- - If there is an imbalance in left child of right subtree, then you perform a left-right rotation.
- - If there is an imbalance in left child of left subtree, then you perform a right rotation.
- - If there is an imbalance in right child of right subtree, then you perform a left rotation.
- - If there is an imbalance in right child of left subtree, then you perform a right-left rotation.
-
-
-#### More Information:
-[YouTube - AVL Tree](https://www.youtube.com/watch?v=7m94k2Qhg68)
-
-An AVL tree is a self-balancing binary search tree.
-An AVL tree is a binary search tree which has the following properties:
-->The sub-trees of every node differ in height by at most one.
-->Every sub-tree is an AVL tree.
-
-AVL tree checks the height of the left and the right sub-trees and assures that the difference is not more than 1. This difference is called the Balance Factor.
-The height of an AVL tree is always O(Logn) where n is the number of nodes in the tree.
-
-AVL Tree Rotations:-
-
-In AVL tree, after performing every operation like insertion and deletion we need to check the balance factor of every node in the tree. If every node satisfies the balance factor condition then we conclude the operation otherwise we must make it balanced. We use rotation operations to make the tree balanced whenever the tree is becoming imbalanced due to any operation.
-
-Rotation operations are used to make a tree balanced.There are four rotations and they are classified into two types:
-->Single Left Rotation (LL Rotation)
-In LL Rotation every node moves one position to left from the current position.
-->Single Right Rotation (RR Rotation)
-In RR Rotation every node moves one position to right from the current position.
-->Left Right Rotation (LR Rotation)
-The LR Rotation is combination of single left rotation followed by single right rotation. In LR Rotation, first every node moves one position to left then one position to right from the current position.
-->Right Left Rotation (RL Rotation)
-The RL Rotation is combination of single right rotation followed by single left rotation. In RL Rotation, first every node moves one position to right then one position to left from the current position.
diff --git a/client/src/pages/guide/english/algorithms/b-trees/index.md b/client/src/pages/guide/english/algorithms/b-trees/index.md
deleted file mode 100644
index 1bff5668a7..0000000000
--- a/client/src/pages/guide/english/algorithms/b-trees/index.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: B Trees
----
-## B Trees
-
-# Introduction
-
-B-Tree is a self-balancing search tree. In most of the other self-balancing search trees (like AVL and Red Black Trees), it is assumed that everything is in main memory. To understand use of B-Trees, we must think of huge amount of data that cannot fit in main memory. When the number of keys is high, the data is read from disk in the form of blocks. Disk access time is very high compared to main memory access time. The main idea of using B-Trees is to reduce the number of disk accesses. Most of the tree operations (search, insert, delete, max, min, ..etc ) require O(h) disk accesses where h is height of the tree. B-tree is a fat tree. Height of B-Trees is kept low by putting maximum possible keys in a B-Tree node. Generally, a B-Tree node size is kept equal to the disk block size. Since h is low for B-Tree, total disk accesses for most of the operations are reduced significantly compared to balanced Binary Search Trees like AVL Tree, Red Black Tree, ..etc.
-
-Properties of B-Tree:
-1) All leaves are at same level.
-2) A B-Tree is defined by the term minimum degree ‘t’. The value of t depends upon disk block size.
-3) Every node except root must contain at least t-1 keys. Root may contain minimum 1 key.
-4) All nodes (including root) may contain at most 2t – 1 keys.
-5) Number of children of a node is equal to the number of keys in it plus 1.
-6) All keys of a node are sorted in increasing order. The child between two keys k1 and k2 contains all keys in range from k1 and k2.
-7) B-Tree grows and shrinks from root which is unlike Binary Search Tree. Binary Search Trees grow downward and also shrink from downward.
-8) Like other balanced Binary Search Trees, time complexity to search, insert and delete is O(Logn).
-
-Search:
-Search is similar to search in Binary Search Tree. Let the key to be searched be k. We start from root and recursively traverse down. For every visited non-leaf node, if the node has key, we simply return the node. Otherwise we recur down to the appropriate child (The child which is just before the first greater key) of the node. If we reach a leaf node and don’t find k in the leaf node, we return NULL.
-
-Traverse:
-Traversal is also similar to Inorder traversal of Binary Tree. We start from the leftmost child, recursively print the leftmost child, then repeat the same process for remaining children and keys. In the end, recursively print the rightmost child.
diff --git a/client/src/pages/guide/english/algorithms/backtracking-algorithms/index.md b/client/src/pages/guide/english/algorithms/backtracking-algorithms/index.md
deleted file mode 100644
index 2b27ef3f3f..0000000000
--- a/client/src/pages/guide/english/algorithms/backtracking-algorithms/index.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: Backtracking Algorithms
----
-
-# Backtracking Algorithms
-
-Backtracking is a general algorithm for finding all (or some) solutions to some computational problems, notably constraint satisfaction problems, that incrementally builds candidates to the solutions, and abandons each partial candidate *("backtracks")* as soon as it determines that the candidate cannot possibly be completed to a valid solution.
-
-### Example Problem (The Knight’s tour problem)
-
- *The knight is placed on the first block of an empty board and, moving according to the rules of chess, must visit each square exactly once.*
-
-
-
- ### Path followed by Knight to cover all the cells
- Following is chessboard with 8 x 8 cells. Numbers in cells indicate move number of Knight.
- [](https://commons.wikimedia.org/wiki/File:Knights_tour_(Euler).png)
-
-### Naive Algorithm for Knight’s tour
-The Naive Algorithm is to generate all tours one by one and check if the generated tour satisfies the constraints.
-```
-while there are untried tours
-{
- generate the next tour
- if this tour covers all squares
- {
- print this path;
- }
-}
-```
-
-### Backtracking Algorithm for Knight’s tour
-Following is the Backtracking algorithm for Knight’s tour problem.
-```
-If all squares are visited
- print the solution
-Else
- a) Add one of the next moves to solution vector and recursively
- check if this move leads to a solution. (A Knight can make maximum
- eight moves. We choose one of the 8 moves in this step).
- b) If the move chosen in the above step doesn't lead to a solution
- then remove this move from the solution vector and try other
- alternative moves.
- c) If none of the alternatives work then return false (Returning false
- will remove the previously added item in recursion and if false is
- returned by the initial call of recursion then "no solution exists" )
-```
-
-
-### More Information
-
-[Wikipedia](https://en.wikipedia.org/wiki/Backtracking)
-
-[Geeks 4 Geeks](http://www.geeksforgeeks.org/backtracking-set-1-the-knights-tour-problem/)
-
-[A very interesting introduction to backtracking](https://www.hackerearth.com/practice/basic-programming/recursion/recursion-and-backtracking/tutorial/)
diff --git a/client/src/pages/guide/english/algorithms/boundary-fill/index.md b/client/src/pages/guide/english/algorithms/boundary-fill/index.md
deleted file mode 100644
index 4399dd61c4..0000000000
--- a/client/src/pages/guide/english/algorithms/boundary-fill/index.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: Boundary Fill
----
-
-## Boundary Fill
-Boundary fill is the algorithm used frequently in computer graphics to fill a desired color inside a closed polygon having the same boundary
-color for all of its sides.
-
-The most approached implementation of the algorithm is a stack-based recursive function.
-
-### Working:
-The problem is pretty simple and usually follows these steps:
-
-1. Take the position of the starting point and the boundary color.
-2. Decide wether you want to go in 4 directions (N, S, W, E) or 8 directions (N, S, W, E, NW, NE, SW, SE).
-3. Choose a fill color.
-4. Travel in those directions.
-5. If the pixel you land on is not the fill color or the boundary color , replace it with the fill color.
-6. Repeat 4 and 5 until you've been everywhere within the boundaries.
-### Certain Restrictions:
-- The boundary color should be the same for all the edges of the polygon.
-- The starting point should be within the polygon.
-### Code Snippet:
-```
-void boundary_fill(int pos_x, int pos_y, int boundary_color, int fill_color)
-{
- current_color= getpixel(pos_x,pos_y); //get the color of the current pixel position
- if( current_color!= boundary_color || currrent_color != fill_color) // if pixel not already filled or part of the boundary then
- {
- putpixel(pos_x,pos_y,fill_color); //change the color for this pixel to the desired fill_color
- boundary_fill(pos_x + 1, pos_y,boundary_color,fill_color); // perform same function for the east pixel
- boundary_fill(pos_x - 1, pos_y,boundary_color,fill_color); // perform same function for the west pixel
- boundary_fill(pos_x, pos_y + 1,boundary_color,fill_color); // perform same function for the north pixel
- boundary_fill(pos_x, pos_y - 1,boundary_color,fill_color); // perform same function for the south pixel
- }
-}
-```
-From the given code you can see that for any pixel that you land on, you first check whether it can be changed to the fill_color and then you do so
-for its neighbours till all the pixels within the boundary have been checked.
diff --git a/client/src/pages/guide/english/algorithms/brute-force-algorithms/index.md b/client/src/pages/guide/english/algorithms/brute-force-algorithms/index.md
deleted file mode 100644
index 83422db9b4..0000000000
--- a/client/src/pages/guide/english/algorithms/brute-force-algorithms/index.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Brute Force Algorithms
----
-## Brute Force Algorithms
-
-Brute Force Algorithms refers to a programming style that does not include any shortcuts to improve performance, but instead relies on sheer computing power to try all possibilities until the solution to a problem is found.
-
-A classic example is the traveling salesman problem (TSP). Suppose a salesman needs to visit 10 cities across the country. How does one determine the order in which cities should be visited such that the total distance traveled is minimized? The brute force solution is simply to calculate the total distance for every possible route and then select the shortest one. This is not particularly efficient because it is possible to eliminate many possible routes through clever algorithms.
-
-Another example: 5 digit password, in the worst case scenario would take 105 tries to crack.
-
-The time complexity of brute force is O(n*m) . So, if we were to search for a string of 'n' characters in a string of 'm' characters using brute force, it would take us n * m tries.
-
-#### More Information:
-
- Wikipedia
diff --git a/client/src/pages/guide/english/algorithms/embarassingly-parallel-algorithms/index.md b/client/src/pages/guide/english/algorithms/embarassingly-parallel-algorithms/index.md
deleted file mode 100644
index b48b58b3fd..0000000000
--- a/client/src/pages/guide/english/algorithms/embarassingly-parallel-algorithms/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Embarassingly Parallel Algorithms
----
-## Embarassingly Parallel Algorithms
-
-In parallel programming, an embarrassingly parallel algorithm is one that requires no communication or dependency between the processes. Unlike distributed computing problems that need communication between tasks—especially on intermediate results, embarrassingly parallel algorithms are easy to perform on server farms that lack the special infrastructure used in a true supercomputer cluster. Due to the nature of embarrassingly parallel algorithms, they are well suited to large, internet-based distributed platforms, and do not suffer from parallel slowdown. The opposite of embarrassingly parallel problems are inherently serial problems, which cannot be parallelized at all.
-The ideal case of embarrassingly parallel algorithms can be summarized as following:
-* All the sub-problems or tasks are defined before the computations begin.
-* All the sub-solutions are stored in independent memory locations (variables, array elements).
-* Thus, the computation of the sub-solutions is completely independent.
-* If the computations require some initial or final communication, then we call it nearly embarrassingly parallel.
-
-Many may wonder the etymology of the term “embarrassingly”. In this case, embarrassingly has nothing to do with embarrassment; in fact, it means an overabundance—here referring to parallelization problems which are “embarrassingly easy”.
-
-A common example of an embarrassingly parallel problem is 3d video rendering handled by a graphics processing unit, where each frame or pixel can be handled with no interdependency. Some other examples would be protein folding software that can run on any computer with each machine doing a small piece of the work, generation of all subsets, random numbers, and Monte Carlo simulations.
diff --git a/client/src/pages/guide/english/algorithms/evaluating-polynomials-direct-analysis/index.md b/client/src/pages/guide/english/algorithms/evaluating-polynomials-direct-analysis/index.md
deleted file mode 100644
index 950c9e9c4e..0000000000
--- a/client/src/pages/guide/english/algorithms/evaluating-polynomials-direct-analysis/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Evaluating Polynomials Direct Analysis
----
-## Evaluating Polynomials Direct Analysis
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/pages/guide/english/algorithms/evaluating-polynomials-synthetic-division/index.md b/client/src/pages/guide/english/algorithms/evaluating-polynomials-synthetic-division/index.md
deleted file mode 100644
index 27362df742..0000000000
--- a/client/src/pages/guide/english/algorithms/evaluating-polynomials-synthetic-division/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Evaluating Polynomials Synthetic Division
----
-## Evaluating Polynomials Synthetic Division
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/pages/guide/english/algorithms/exponentiation/index.md b/client/src/pages/guide/english/algorithms/exponentiation/index.md
deleted file mode 100644
index 811b24bea0..0000000000
--- a/client/src/pages/guide/english/algorithms/exponentiation/index.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: Exponentiation
----
-## Exponentiation
-
-Given two integers a and n, write a function to compute a^n.
-
-#### Code
-
-Algorithmic Paradigm: Divide and conquer.
-
-```C
-int power(int x, unsigned int y) {
- if (y == 0)
- return 1;
- else if (y%2 == 0)
- return power(x, y/2)*power(x, y/2);
- else
- return x*power(x, y/2)*power(x, y/2);
-}
-```
-Time Complexity: O(n) | Space Complexity: O(1)
-
-#### Optimized Solution: O(logn)
-
-```C
-int power(int x, unsigned int y) {
- int temp;
- if( y == 0)
- return 1;
- temp = power(x, y/2);
- if (y%2 == 0)
- return temp*temp;
- else
- return x*temp*temp;
-}
-```
-
-## Modular Exponentiation
-
-Given three numbers x, y and p, compute (x^y) % p
-
-```C
-int power(int x, unsigned int y, int p) {
- int res = 1;
- x = x % p;
- while (y > 0) {
- if (y & 1)
- res = (res*x) % p;
-
- // y must be even now
- y = y>>1;
- x = (x*x) % p;
- }
- return res;
-}
-```
-Time Complexity: O(Log y).
diff --git a/client/src/pages/guide/english/algorithms/flood-fill/index.md b/client/src/pages/guide/english/algorithms/flood-fill/index.md
deleted file mode 100644
index 189045653e..0000000000
--- a/client/src/pages/guide/english/algorithms/flood-fill/index.md
+++ /dev/null
@@ -1,112 +0,0 @@
----
-title: Flood Fill Algorithm
----
-## Flood Fill Algorithm
-
-Flood fill is an algorithm mainly used to determine a bounded area connected to a given node in a multi-dimensional array. It is
-a close resemblance to the bucket tool in paint programs.
-
-The most approached implementation of the algorithm is a stack-based recursive function, and that's what we're gonna talk about
-next.
-
-### How does it work?
-
-The problem is pretty simple and usually follows these steps:
-
- 1. Take the position of the starting point.
- 2. Decide wether you want to go in 4 directions (**N, S, W, E**) or 8 directions (**N, S, W, E, NW, NE, SW, SE**).
- 3. Choose a replacement color and a target color.
- 4. Travel in those directions.
- 5. If the tile you land on is a target, reaplce it with the chosen color.
- 6. Repeat 4 and 5 until you've been everywhere within the boundaries.
-
-Let's take the following array as an example:
-
-
-
-The red square is the starting point and the gray squares are the so called walls.
-
-For further details, here's a piece of code describing the function:
-
-
-```c++
-
-int wall = -1;
-
-void flood_fill(int pos_x, int pos_y, int target_color, int color)
-{
-
- if(a[pos_x][pos_y] == wall || a[pos_x][pos_y] == color) // if there is no wall or if i haven't been there
- return; // already go back
-
- if(a[pos_x][pos_y] != target_color) // if it's not color go back
- return;
-
- a[pos_x][pos_y] = color; // mark the point so that I know if I passed through it.
-
- flood_fill(pos_x + 1, pos_y, color); // then i can either go south
- flood_fill(pos_x - 1, pos_y, color); // or north
- flood_fill(pos_x, pos_y + 1, color); // or east
- flood_fill(pos_x, pos_y - 1, color); // or west
-
- return;
-
-}
-
-
-```
-
-As seen above, my starting point is (4,4). After calling the function for the start coordinates **x = 4** and **y = 4**,
-I can start checking if there is no wall or color on the spot. If that is valid i mark the spot with one **"color"**
-and start checking the other adiacent squares.
-
-Going south we will get to point (5,4) and the function runs again.
-
-
-### Excercise problem
-
-I always considered that solving a (or more) problem/s using a newly learned algorithm is the best way to fully understand
-the concept.
-
-So here's one:
-
-**Statement:**
-
- In a bidimensional array you are given n number of **"islands"**. Try to find the largest area of an island and
-the corresponding island number. 0 marks water and any other x between 1 and n marks one square from the surface corresponding
-to island x.
-
-**Input**
-
- * **n** - the number of islands.
- * **l,c** - the dimensions of the matrix.
- * the next **l** lines, **c** numbers giving the **l**th row of the matrix.
-
-**Output**
-
- * **i** - the number of the island with the largest area.
- * **A** - the area of the **i**'th island.
-
-**Ex:**
-
-You have the following input:
-```c++
-2 4 4
-0 0 0 1
-0 0 1 1
-0 0 0 2
-2 2 2 2
-```
-For which you will get island no. 2 as the biggest island with the area of 5 squares.
-
-
-### Hints
-
-The problem is quite easy, but here are some hints:
-
- 1. Use the flood-fill algorithm whenever you encounter a new island.
- 2. As opposed to the sample code, you should go through the area of the island and not on the ocean (0 tiles).
-
-
-
-
diff --git a/client/src/pages/guide/english/algorithms/graph-algorithms/breadth-first-search/index.md b/client/src/pages/guide/english/algorithms/graph-algorithms/breadth-first-search/index.md
deleted file mode 100644
index f8e2f1d748..0000000000
--- a/client/src/pages/guide/english/algorithms/graph-algorithms/breadth-first-search/index.md
+++ /dev/null
@@ -1,128 +0,0 @@
----
-title: Breadth First Search (BFS)
----
-## Breadth First Search (BFS)
-
-Breadth First Search is one of the most simple graph algorithms. It traverses the graph by first checking the current node and then expanding it by adding its successors to the next level. The process is repeated for all nodes in the current level before moving to the next level. If the solution is found the search stops.
-
-### Visualisation
-
-
-
-
-### Evaluation
-
-Space Complexity: O(n)
-
-Worse Case Time Complexity: O(n)
-
-Breadth First Search is complete on a finite set of nodes and optimal if the cost of moving from one node to another is constant.
-
-### C++ code for BFS implementation
-
-```cpp
-
-// Program to print BFS traversal from a given
-// source vertex. BFS(int s) traverses vertices
-// reachable from s.
-#include
-#include
-
-using namespace std;
-
-// This class represents a directed graph using
-// adjacency list representation
-class Graph
-{
- int V; // No. of vertices
-
- // Pointer to an array containing adjacency
- // lists
- list *adj;
-public:
- Graph(int V); // Constructor
-
- // function to add an edge to graph
- void addEdge(int v, int w);
-
- // prints BFS traversal from a given source s
- void BFS(int s);
-};
-
-Graph::Graph(int V)
-{
- this->V = V;
- adj = new list[V];
-}
-
-void Graph::addEdge(int v, int w)
-{
- adj[v].push_back(w); // Add w to v’s list.
-}
-
-void Graph::BFS(int s)
-{
- // Mark all the vertices as not visited
- bool *visited = new bool[V];
- for(int i = 0; i < V; i++)
- visited[i] = false;
-
- // Create a queue for BFS
- list queue;
-
- // Mark the current node as visited and enqueue it
- visited[s] = true;
- queue.push_back(s);
-
- // 'i' will be used to get all adjacent
- // vertices of a vertex
- list::iterator i;
-
- while(!queue.empty())
- {
- // Dequeue a vertex from queue and print it
- s = queue.front();
- cout << s << " ";
- queue.pop_front();
-
- // Get all adjacent vertices of the dequeued
- // vertex s. If a adjacent has not been visited,
- // then mark it visited and enqueue it
- for (i = adj[s].begin(); i != adj[s].end(); ++i)
- {
- if (!visited[*i])
- {
- visited[*i] = true;
- queue.push_back(*i);
- }
- }
- }
-}
-
-// Driver program to test methods of graph class
-int main()
-{
- // Create a graph given in the above diagram
- Graph g(4);
- g.addEdge(0, 1);
- g.addEdge(0, 2);
- g.addEdge(1, 2);
- g.addEdge(2, 0);
- g.addEdge(2, 3);
- g.addEdge(3, 3);
-
- cout << "Following is Breadth First Traversal "
- << "(starting from vertex 2) \n";
- g.BFS(2);
-
- return 0;
-}
-
-```
-
-#### More Information:
-
-
-Graphs
-
-Depth First Search (DFS)
diff --git a/client/src/pages/guide/english/algorithms/graph-algorithms/depth-first-search/index.md b/client/src/pages/guide/english/algorithms/graph-algorithms/depth-first-search/index.md
deleted file mode 100644
index 2fd89d85cf..0000000000
--- a/client/src/pages/guide/english/algorithms/graph-algorithms/depth-first-search/index.md
+++ /dev/null
@@ -1,160 +0,0 @@
----
-title: Depth First Search (DFS)
----
-## Depth First Search (DFS)
-
-Depth First Search is one of the most simple graph algorithms. It traverses the graph by first checking the current node and then moving to one of its sucessors to repeat the process. If the current node has no sucessor to check, we move back to its predecessor and the process continues (by moving to another sucessor). If the solution is found the search stops.
-
-
-### Visualisation
-
-
-
-### Implementation (C++14)
-
- ```c++
-#include
-#include
-#include
-#include
- using namespace std;
-
-class Graph{
- int v; // number of vertices
-
- // pointer to a vector containing adjacency lists
- vector < int > *adj;
-public:
- Graph(int v); // Constructor
-
- // function to add an edge to graph
- void add_edge(int v, int w);
-
- // prints dfs traversal from a given source `s`
- void dfs();
- void dfs_util(int s, vector < bool> &visited);
-};
-
-Graph::Graph(int v){
- this -> v = v;
- adj = new vector < int >[v];
-}
-
-void Graph::add_edge(int u, int v){
- adj[u].push_back(v); // add v to u’s list
- adj[v].push_back(v); // add u to v's list (remove this statement if the graph is directed!)
-}
- void Graph::dfs(){
- // visited vector - to keep track of nodes visited during DFS
- vector < bool > visited(v, false); // marking all nodes/vertices as not visited
- for(int i = 0; i < v; i++)
- if(!visited[i])
- dfs_util(i, visited);
-}
- // notice the usage of call-by-reference here!
-void Graph::dfs_util(int s, vector < bool > &visited){
- // mark the current node/vertex as visited
- visited[s] = true;
- // output it to the standard output (screen)
- cout << s << " ";
-
- // traverse its adjacency list and recursively call dfs_util for all of its neighbours!
- // (only if the neighbour has not been visited yet!)
- for(vector < int > :: iterator itr = adj[s].begin(); itr != adj[s].end(); itr++)
- if(!visited[*itr])
- dfs_util(*itr, visited);
-}
-
-int main()
-{
- // create a graph using the Graph class we defined above
- Graph g(4);
- g.add_edge(0, 1);
- g.add_edge(0, 2);
- g.add_edge(1, 2);
- g.add_edge(2, 0);
- g.add_edge(2, 3);
- g.add_edge(3, 3);
-
- cout << "Following is the Depth First Traversal of the provided graph"
- << "(starting from vertex 0): ";
- g.dfs();
- // output would be: 0 1 2 3
- return 0;
-}
-```
-
-
-### Evaluation
-
-Space Complexity: O(n)
-
-Worse Case Time Complexity: O(n)
-Depth First Search is complete on a finite set of nodes. I works better on shallow trees.
-
-### Implementation of DFS in C++
-```c++
-#include
-#include
-#include
-
-using namespace std;
-
-struct Graph{
- int v;
- bool **adj;
- public:
- Graph(int vcount);
- void addEdge(int u,int v);
- void deleteEdge(int u,int v);
- vector DFS(int s);
- void DFSUtil(int s,vector &dfs,vector &visited);
-};
-Graph::Graph(int vcount){
- this->v = vcount;
- this->adj=new bool*[vcount];
- for(int i=0;iadj[i]=new bool[vcount];
- for(int i=0;iadj[u][w]=true;
- this->adj[w][u]=true;
-}
-
-void Graph::deleteEdge(int u,int w){
- this->adj[u][w]=false;
- this->adj[w][u]=false;
-}
-
-void Graph::DFSUtil(int s, vector &dfs, vector &visited){
- visited[s]=true;
- dfs.push_back(s);
- for(int i=0;iv;i++){
- if(this->adj[s][i]==true && visited[i]==false)
- DFSUtil(i,dfs,visited);
- }
-}
-
-vector Graph::DFS(int s){
- vector visited(this->v);
- vector dfs;
- DFSUtil(s,dfs,visited);
- return dfs;
-}
-```
-
-#### More Information:
-
-
-Graphs
-
-Breadth First Search (BFS)
-
-
-
-
-[Depth First Search (DFS) - Wikipedia](https://en.wikipedia.org/wiki/Depth-first_search)
diff --git a/client/src/pages/guide/english/algorithms/graph-algorithms/dijkstra/index.md b/client/src/pages/guide/english/algorithms/graph-algorithms/dijkstra/index.md
deleted file mode 100644
index e810bb02fa..0000000000
--- a/client/src/pages/guide/english/algorithms/graph-algorithms/dijkstra/index.md
+++ /dev/null
@@ -1,93 +0,0 @@
----
-title: Dijkstra's Algorithm
----
-# Dijkstra's Algorithm
-
-Dijkstra's Algorithm is a graph algorithm presented by E.W. Dijkstra. It finds the single source shortest path in a graph with non-negative edges.(why?)
-
-We create 2 arrays : visited and distance, which record whether a vertex is visited and what is the minimum distance from the source vertex respectively. Initially visited array is assigned as false and distance as infinite.
-
-We start from the source vertex. Let the current vertex be u and its adjacent vertices be v. Now for every v which is adjacent to u, the distance is updated if it has not been visited before and the distance from u is less than its current distance. Then we select the next vertex with the least distance and which has not been visited.
-
-Priority Queue is often used to meet this last requirement in the least amount of time. Below is an implementation of the same idea using priority queue in Java.
-
-```java
-import java.util.*;
-public class Dijkstra {
- class Graph {
- LinkedList> adj[];
- int n; // Number of vertices.
- Graph(int n) {
- this.n = n;
- adj = new LinkedList[n];
- for(int i = 0;i();
- }
- // add a directed edge between vertices a and b with cost as weight
- public void addEdgeDirected(int a, int b, int cost) {
- adj[a].add(new Pair(b, cost));
- }
- public void addEdgeUndirected(int a, int b, int cost) {
- addEdgeDirected(a, b, cost);
- addEdgeDirected(b, a, cost);
- }
- }
- class Pair {
- E first;
- E second;
- Pair(E f, E s) {
- first = f;
- second = s;
- }
- }
-
- // Comparator to sort Pairs in Priority Queue
- class PairComparator implements Comparator> {
- public int compare(Pair a, Pair b) {
- return a.second - b.second;
- }
- }
-
- // Calculates shortest path to each vertex from source and returns the distance
- public int[] dijkstra(Graph g, int src) {
- int distance[] = new int[g.n]; // shortest distance of each vertex from src
- boolean visited[] = new boolean[g.n]; // vertex is visited or not
- Arrays.fill(distance, Integer.MAX_VALUE);
- Arrays.fill(visited, false);
- PriorityQueue> pq = new PriorityQueue<>(100, new PairComparator());
- pq.add(new Pair(src, 0));
- distance[src] = 0;
- while(!pq.isEmpty()) {
- Pair x = pq.remove(); // Extract vertex with shortest distance from src
- int u = x.first;
- visited[u] = true;
- Iterator> iter = g.adj[u].listIterator();
- // Iterate over neighbours of u and update their distances
- while(iter.hasNext()) {
- Pair y = iter.next();
- int v = y.first;
- int weight = y.second;
- // Check if vertex v is not visited
- // If new path through u offers less cost then update distance array and add to pq
- if(!visited[v] && distance[u]+weight
-
-Graphs
-
-Floyd Warshall - Wikipedia
diff --git a/client/src/pages/guide/english/algorithms/greatest-common-divisor-direct-analysis/index.md b/client/src/pages/guide/english/algorithms/greatest-common-divisor-direct-analysis/index.md
deleted file mode 100644
index 42cf19ebf1..0000000000
--- a/client/src/pages/guide/english/algorithms/greatest-common-divisor-direct-analysis/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Greatest Common Divisor Direct Analysis
----
-## Greatest Common Divisor Direct Analysis
-
-This is a stub. Help our community expand it .
-
-This quick style guide will help ensure your pull request gets accepted .
-
-
-
-#### More Information:
-
-
-
diff --git a/client/src/pages/guide/english/algorithms/greatest-common-divisor-euclidean/index.md b/client/src/pages/guide/english/algorithms/greatest-common-divisor-euclidean/index.md
deleted file mode 100644
index 3ace3db34d..0000000000
--- a/client/src/pages/guide/english/algorithms/greatest-common-divisor-euclidean/index.md
+++ /dev/null
@@ -1,74 +0,0 @@
----
-title: Greatest Common Divisor Euclidean
----
-## Greatest Common Divisor Euclidean
-
-For this topic you must know about Greatest Common Divisor (GCD) and the MOD operation first.
-
-#### Greatest Common Divisor (GCD)
-The GCD of two or more integers is the largest integer that divides each of the integers such that their remainder is zero.
-
-Example-
-GCD of 20, 30 = 10 *(10 is the largest number which divides 20 and 30 with remainder as 0)*
-GCD of 42, 120, 285 = 3 *(3 is the largest number which divides 42, 120 and 285 with remainder as 0)*
-
-#### "mod" Operation
-The mod operation gives you the remainder when two positive integers are divided.
-We write it as follows-
-`A mod B = R`
-
-This means, dividing A by B gives you the remainder R, this is different than your division operation which gives you the quotient.
-
-Example-
-7 mod 2 = 1 *(Dividing 7 by 2 gives the remainder 1)*
-42 mod 7 = 0 *(Dividing 42 by 7 gives the remainder 0)*
-
-With the above two concepts understood you will easily understand the Euclidean Algorithm.
-
-### Euclidean Algorithm for Greatest Common Divisor (GCD)
-The Euclidean Algorithm finds the GCD of 2 numbers.
-
-You will better understand this Algorithm by seeing it in action.
-Assuming you want to calculate the GCD of 1220 and 516, lets apply the Euclidean Algorithm-
-
-Assuming you want to calculate the GCD of 1220 and 516, lets apply the Euclidean Algorithm-
-
-
-Pseudo Code of the Algorithm-
-Step 1: **Let `a, b` be the two numbers**
-Step 2: **`a mod b = R`**
-Step 3: **Let `a = b` and `b = R`**
-Step 4: **Repeat Steps 2 and 3 until `a mod b` is greater than 0**
-Step 5: **GCD = b**
-Step 6: Finish
-
-Javascript Code to Perform GCD-
-```javascript
-function gcd(a, b) {
- var R;
- while ((a % b) > 0) {
- R = a % b;
- a = b;
- b = R;
- }
- return b;
-}
-```
-
-Javascript Code to Perform GCD using Recursion-
-```javascript
-function gcd(a, b) {
- if (b == 0)
- return a;
- else
- return gcd(b, (a % b));
-}
-```
-
-You can also use the Euclidean Algorithm to find GCD of more than two numbers.
-Since, GCD is associative, the following operation is valid- `GCD(a,b,c) == GCD(GCD(a,b), c)`
-
-Calculate the GCD of the first two numbers, then find GCD of the result and the next number.
-Example- `GCD(203,91,77) == GCD(GCD(203,91),77) == GCD(7, 77) == 7`
-
-You can find GCD of `n` numbers in the same way.
diff --git a/client/src/pages/guide/english/algorithms/greedy-algorithms/index.md b/client/src/pages/guide/english/algorithms/greedy-algorithms/index.md
deleted file mode 100644
index e90563e690..0000000000
--- a/client/src/pages/guide/english/algorithms/greedy-algorithms/index.md
+++ /dev/null
@@ -1,91 +0,0 @@
----
-title: Greedy Algorithms
----
-## What is a Greedy Algorithm
-You must have heard about a lot of algorithmic design techniques while sifting through some of the articles here. Some of them are :
-* Brute Force
-* Divide and Conquer
-* Greedy Programming
-* Dynamic Programming
-to name a few. In this article, you will learn about what a greedy algorithm is and how you can use this technique to solve a lot of programming problems that otherwise do not seem trivial.
-
-Imagine you are going for hiking and your goal is to reach the highest peak possible. You already have the map before you start, but there are thousands of possible paths shown on the map. You are too lazy and simply don’t have the time to evaluate each of them. Screw the map! You started hiking with a simple strategy – be greedy and short-sighted. Just take paths that slope upwards the most. This seems like a good strategy for hiking. But is it always the best ?
-
-After the trip ended and your whole body is sore and tired, you look at the hiking map for the first time. Oh my god! There’s a muddy river that I should’ve crossed, instead of keep walking upwards. This means that a greedy algorithm picks the best immediate choice and never reconsiders its choices. In terms of optimizing a solution, this simply means that the greedy solution will try and find local optimum solutions - which can be many - and might miss out on a global optimum solution.
-
-## Formal Definition
-
-Assume that you have an objective function that needs to be optimized (either maximized or minimized) at a given point. A Greedy algorithm makes greedy choices at each step to ensure that the objective function is optimized. The Greedy algorithm has only one shot to compute the optimal solution so that it never goes back and reverses the decision.
-
-### Greedy algorithms have some advantages and disadvantages:
-
-* It is quite easy to come up with a greedy algorithm (or even multiple greedy algorithms) for a problem.
-Analyzing the run time for greedy algorithms will generally be much easier than for other techniques (like Divide and conquer). For the Divide and conquer technique, it is not clear whether the technique is fast or slow. This is because at each level of recursion the size of gets smaller and the number of sub-problems increases.
-
-* The difficult part is that for greedy algorithms you have to work much harder to understand correctness issues. Even with the correct algorithm, it is hard to prove why it is correct. Proving that a greedy algorithm is correct is more of an art than a science. It involves a lot of creativity. Usually, coming up with an algorithm might seem to be trivial, but proving that it is actually correct, is a whole different problem.
-
-## Interval Scheduling Problem
-
-Let's dive into an interesting problem that you can encounter in almost any industry or any walk of life. Some instances of the problem are as follows :
-
-* You are given a set of N schedules of lectures for a single day at a university. The schedule for a specific lecture is of the form (s_time, f_time) where s_time represents the start time for that lecture and similarly the f_time represents the finishing time. Given a list of N lecture schedules, we need to select maximum set of lectures to be held out during the day such that **none of the lectures overlap with one another i.e. if lecture Li and Lj are included in our selection then the start time of j >= finish time of i or vice versa**.
-
-* Your friend is working as a camp counselor, and he is in charge of organizing activities for a set of campers. One of his plans is the following mini-triathlon exercise: each contestant must swim 20 laps of a pool, then bike 10 miles, then run 3 miles.
-
-* The plan is to send the contestants out in a staggered fashion, via the following rule: the contestants must use the pool one at a time. In other words, first one contestant swims the 20 laps, gets out, and starts biking.
-
-* As soon as this first person is out of the pool, a second contestant begins swimming the 20 laps; as soon as he or she is out and starts biking, a third contestant begins swimming, and so on.
-
-* Each contestant has a projected swimming time, a projected biking time, and a projected running time. Your friend wants to decide on a schedule for the triathlon: an order in which to sequence the starts of the contestants.
-
-* Let's say that the completion time of a schedule is the earliest time at which all contestants will be finished with all three legs of the triathlon, assuming the time projections are accurate. What is the best order for sending people out, if one wants the whole competition to be over as soon as possible? More precisely, give an efficient algorithm that produces a schedule whose completion time is as small as possible
-
-### The Lecture Scheduling Problem
-
-Let's look at the various approaches for solving this problem.
-
-1. **Earliest Start Time First** i.e. select the interval that has the earliest start time. Take a look at the following example that breaks this solution. This solution failed because there could be an interval that starts very early but that is very long. This means the next strategy that we could try would be where we look at smaller intervals first.
-
-
-2. **Smallest Interval First** i.e. you end up selecting the lectures in order of their overall interval which is nothing but their `finish time - start time`. Again, this solution is not correct. Look at the following case.
-
-
-You can clearly see that the shortest interval lecture is the one in the middle, but that is not the optimal solution here. Let's look at yet another solution for this problem deriving insights from this solution.
-
-3. **Least Conflicting Interval First** i.e. you should look at intervals that cause the least number of conflicts. Yet again we have an example where this approach fails to find an optimal solution.
-
-
-The diagram shows us that the least confliciting interval is the one in the middle with just 2 conflicts. After that we can only pick the two intervals at the very ends with conflicts 3 each. But the optimal solution is to pick the 4 intervals on the topmost level.
-
-4. **Earliest Finishing time first**. This is the approach that always gives us the most optimal solution to this problem. We derived a lot of insights from previous approaches and finally came upon this approach. We sort the intervals according to increasing order of their finishing times and then we start selecting intervals from the very beginning. Look at the following pseudo code for more clarity.
-
-```
-function interval_scheduling_problem(requests)
- schedule \gets \{\}
- while requests is not yet empty
- choose a request i_r \in requests that has the lowest finishing time
- schedule \gets schedule \cup \{i_r\}
- delete all requests in requests that are not compatible with i_r
- end
- return schedule
-end
-```
-
-## When do we use Greedy Algorithms
-
-Greedy Algorithms can help you find solutions to a lot of seemingly tough problems. The only problem with them is that you might come up with the correct solution but you might not be able to verify if its the correct one. All the greedy problems share a common property that a local optima can eventually lead to a global minima without reconsidering the set of choices already considered.
-
-Greedy Algorithms help us solve a lot of different kinds of problems. Stay tuned for upcoming tutorials on each one of these.
-1. Shortest Path Problem.
-2. Minimum Spanning Tree Problem in a Graph.
-3. Huffman Encoding Problem.
-4. K Centers Problem
-
-#### More Information:
-
-
-
-
-
diff --git a/client/src/pages/guide/english/algorithms/lee-algorithm/index.md b/client/src/pages/guide/english/algorithms/lee-algorithm/index.md
deleted file mode 100644
index 74f7b3c4bd..0000000000
--- a/client/src/pages/guide/english/algorithms/lee-algorithm/index.md
+++ /dev/null
@@ -1,66 +0,0 @@
----
-title: Lee's Algorithm
----
-
-## Lee's Algorithm
-
-The Lee algorithm is one possible solution for maze routing problems. It always gives an optimal solution, if one exists, but is
-slow and requires large memory for dense layout.
-
-### Understanding how it works
-
-The algorithm is a `breadth-first` based algorithm that uses `queues` to store the steps. It usually uses the following steps:
-
- 1. Choose a starting point and add it to the queue.
- 2. Add the valid neighboring cells to the queue.
- 3. Remove the position you are on from the queue and continue to the next element.
- 4. Repeat steps 2 and 3 until the queue is empty.
-
-### Implementation
-
-C++ has the queue already implemented in the `` library, but if you are using something else you are welcome to implement
-your own version of queue.
-
-C++ code:
-
-```c++
-
-int dl[] = {-1, 0, 1, 0}; // these arrays will help you travel in the 4 directions more easily
-int dc[] = {0, 1, 0, -1};
-
-queue X, Y; // the queues used to get the positions in the matrix
-
-X.push(start_x); //initialize the queues with the start position
-Y.push(start_y);
-
-void lee()
-{
- int x, y, xx, yy;
- while(!X.empty()) // while there are still positions in the queue
- {
- x = X.front(); // set the current position
- y = Y.front();
- for(int i = 0; i < 4; i++)
- {
- xx = x + dl[i]; // travel in an adiacent cell from the current position
- yy = y + dc[i];
- if('position is valid') //here you should insert whatever conditions should apply for your position (xx, yy)
- {
- X.push(xx); // add the position to the queue
- Y.push(yy);
- mat[xx][yy] = -1; // you usually mark that you have been to this position in the matrix
- }
-
- }
-
- X.pop(); // eliminate the first position, as you have no more use for it
- Y.pop();
-
- }
-
-
-}
-
-```
-
-
diff --git a/client/src/pages/guide/english/algorithms/red-black-trees/index.md b/client/src/pages/guide/english/algorithms/red-black-trees/index.md
deleted file mode 100644
index 3c5acf6966..0000000000
--- a/client/src/pages/guide/english/algorithms/red-black-trees/index.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: Red Black Trees
----
-## Red Black Trees
-
-Red-Black Tree is a self-balancing Binary Search Tree (BST) where every node follows following rules.
-
-1. Every node has two children, colored either red or black.
-2. Every tree leaf node is always black.
-3. Every red node has both of its children colored black.
-3. There are no two adjacent red nodes (A red node cannot have a red parent or red child).
-4. Every path from root to a tree leaf node has the same number of black nodes (called "black height").
-
-Reference-style:
-![alt text][fibonacci]
-
-[fibonacci]: https://upload.wikimedia.org/wikipedia/commons/thumb/a/ab/Fibonacci_Tree_as_Red-Black_Tree.svg/2000px-Fibonacci_Tree_as_Red-Black_Tree.svg.png "Fibonacci example of red black trees"
-
-### Why Red-Black Trees?
-Most of the BST operations (e.g., search, max, min, insert, delete.. etc) take O(h) time where h is the height of the BST. The cost of these operations may become O(n) for a skewed Binary tree. If we make sure that height of the tree remains O(Logn) after every insertion and deletion, then we can guarantee an upper bound of O(Logn) for all these operations. The height of a Red Black tree is always O(Logn) where n is the number of nodes in the tree.
-
-### Comparison with AVL Tree
-The AVL trees are more balanced compared to Red Black Trees, but they may cause more rotations during insertion and deletion. So if your application involves many frequent insertions and deletions, then Red Black trees should be preferred. And if the insertions and deletions are less frequent and search is more frequent operation, then AVL tree should be preferred over Red Black Tree.
-
-### Left-Leaning Red–Black Tree
-A left-leaning red–black (LLRB) tree is a type of self-balancing binary search tree. It is a variant of the red–black tree and guarantees the same asymptotic complexity for operations, but is designed to be easier to implement.
-
-### Properties of Left Leaning Red-Black Trees
-All of the red-black tree algorithms that have been proposed are characterized by a worst-case search time bounded by a small constant multiple of log N in a tree of N keys, and the behavior observed in practice is typically that same multiple faster than the worst-case bound, close to the optimal log N nodes examined that would be observed in a perfectly balanced tree.
-
-Specifically, in a left-leaning red-black 2-3 tree built from N random keys:
-->A random successful search examines log2 N − 0.5 nodes.
-->The average tree height is about 2 log2 N
-
-#### More Information:
-* [Video from Algorithms and Data Structures](https://www.youtube.com/watch?v=2Ae0D6EXBV4)
diff --git a/client/src/pages/guide/english/algorithms/search-algorithms/exponential-search/index.md b/client/src/pages/guide/english/algorithms/search-algorithms/exponential-search/index.md
deleted file mode 100644
index 19a48ca05b..0000000000
--- a/client/src/pages/guide/english/algorithms/search-algorithms/exponential-search/index.md
+++ /dev/null
@@ -1,92 +0,0 @@
----
-title: Exponential Search
----
-
-## Exponential Search
-Exponential Search also known as finger search, searchs for an element in a sorted array by jumping `2^i` elements every iteration where i represents the
-value of loop control variable, and then verifying if the search element is present between last jump and the current jump
-
-# Complexity Worst Case
-O(log(N))
-Often confused because of the name, the algorithm is named so not because of the time complexity.
-The name arises as a result of the algorithm jumping elements with steps equal to exponents of 2
-
-# Works
-1. Jump the array `2^i` elements at a time searching for the condition `Array[2^(i-1)] < valueWanted < Array[2^i]`. If `2^i` is greater than the lenght of array, then set the upper bound to the length of the array.
-2. Do a binary search between `Array[2^(i-1)]` and `Array[2^i]`
-
-
-# Code
-```
-// C++ program to find an element x in a
-// sorted array using Exponential search.
-#include
-using namespace std;
-
-int binarySearch(int arr[], int, int, int);
-
-// Returns position of first ocurrence of
-// x in array
-int exponentialSearch(int arr[], int n, int x)
-{
- // If x is present at firt location itself
- if (arr[0] == x)
- return 0;
-
- // Find range for binary search by
- // repeated doubling
- int i = 1;
- while (i < n && arr[i] <= x)
- i = i*2;
-
- // Call binary search for the found range.
- return binarySearch(arr, i/2, min(i, n), x);
-}
-
-// A recursive binary search function. It returns
-// location of x in given array arr[l..r] is
-// present, otherwise -1
-int binarySearch(int arr[], int l, int r, int x)
-{
- if (r >= l)
- {
- int mid = l + (r - l)/2;
-
- // If the element is present at the middle
- // itself
- if (arr[mid] == x)
- return mid;
-
- // If element is smaller than mid, then it
- // can only be present n left subarray
- if (arr[mid] > x)
- return binarySearch(arr, l, mid-1, x);
-
- // Else the element can only be present
- // in right subarray
- return binarySearch(arr, mid+1, r, x);
- }
-
- // We reach here when element is not present
- // in array
- return -1;
-}
-
-int main(void)
-{
- int arr[] = {2, 3, 4, 10, 40};
- int n = sizeof(arr)/ sizeof(arr[0]);
- int x = 10;
- int result = exponentialSearch(arr, n, x);
- (result == -1)? printf("Element is not present in array")
- : printf("Element is present at index %d", result);
- return 0;
-}
-```
-# More Information
--
` is therefore legal HTML5 code.
-
-Should you therefore fill in alt-tags for all images? It depends on the image, really. For background images, the answer is usually no, but you should use CSS for those anyway.
-
-For purely decorative images that have no information in them at all, you're basically free to choose. Either put in something useful and descriptive or nothing at all.
-
-For images that contain information, like a brochure, a map, a chart etc., not adding alt text breaks WCAG unless you provide a textual alternative. This is usually an alt-attribute, but can also be a block of text right below or next to the image.
-
-For images of text, the text can either be included in the alt-attribute or offered in some alternative manner. The problem is that adding the textual alternative on the same page would basically make the same content show twice for people who can see the image, which is why the alt-attribute is better in this case.
-
-The text should provide the context and information that is an alternative to seeing the image. It is simply not enough to write "image of hot air balloons" - why are the balloon pictures there? If the image is stylized or conveys an emotional meaning, this can be included.
-
-### I can't read your scrawl, son
-
-Even people who don't wear glasses and have no problem with their eyesight at all benefit from an easy to read font and proper contrast. I'm sure you would cringe if you had to fill in a form where light yellow, hopelessly loopy letters are placed on a white background. For people who's eyesight is not as good, like your grandma, for example, this becomes hopelessly worse.
-
-The WCAG has contrast ratios for smaller and larger letters and there's plenty of tools out there to check if the contrast ratios are strong enough. The information and tooling is there, go use it.
-
-A good place to start checking color contrast is by using the [WebAIM](https://webaim.org/resources/contrastchecker/) color contrast checker.
-
-### What does this button do?
-While we are on the topic of forms, let's quickly glance at the