├── 01 - Linux
    ├── 01 - Shell
    │   ├── 01 - Introduction
    │   │   └── README.md
    │   ├── 02 - Basic Linux Commands
    │   │   └── README.md
    │   └── README.md
    ├── 02 - Linux Core Concepts
    │   ├── 01 - Kernel 
    │   │   └── README.md
    │   ├── 02 - Boot Sequence
    │   │   └── README.md
    │   ├── 03 - File Types
    │   │   └── README.md
    │   ├── 04 - Filesystem Hierarchy
    │   │   └── README.md
    │   └── README.md
    ├── 03 - Package Management
    │   └── README.md
    ├── Archiving Files
    │   └── README.md
    ├── Command Line Pipes
    │   └── README.md
    ├── Environment Variables
    │   └── README.md
    ├── IO Redirection
    │   └── README.md
    ├── README.md
    ├── Searching for Files and Patterns
    │   └── README.md
    ├── Security and File Permissions
    │   ├── 01 - Linux Accounts
    │   │   └── README.md
    │   ├── 02 - User Management
    │   │   └── README.md
    │   ├── 03 - Access control files
    │   │   └── README.md
    │   ├── 04 - File Permissions and Ownership
    │   │   └── README.md
    │   ├── 05 - SSH and SCP
    │   │   └── README.md
    │   ├── 06 - IPTABLES
    │   │   └── README.md
    │   ├── 07 - Cronjobs
    │   │   └── README.md
    │   └── README.md
    └── Service Management with SYSTEMD
    │   ├── 01 - Creating a SYSTEMD Service
    │       └── README.md
    │   ├── 02 - SYSTEMD Tools
    │       └── README.md
    │   └── README.md
├── 02 - Shell Scripting
    ├── 01 - Introduction
    │   ├── 01 - Creating your first shell script
    │   │   └── README.md
    │   ├── 02 - Variables
    │   │   └── README.md
    │   ├── 03 - Command Line Arguments
    │   │   └── README.md
    │   ├── 04 - Read Inputs
    │   │   └── README.md
    │   ├── 05 - Arithmetic Operations
    │   │   └── README.md
    │   └── README.md
    ├── 02 - Flow Control
    │   ├── 01 - Conditional Logic
    │   │   └── README.md
    │   ├── 02 - For loop
    │   │   └── README.md
    │   ├── 03 - While Loop
    │   │   └── README.md
    │   ├── 04 - Case Statements 
    │   │   └── README.md
    │   └── README.md
    ├── 03 - Shebang
    │   ├── 01 - Exit Codes
    │   │   └── README.md
    │   ├── 02 - Functions
    │   │   └── README.md
    │   ├── 03 - Tips and Tricks
    │   │   └── README.md
    │   └── README.md
    ├── 04 - Styling 
    │   └── README.md
    ├── 05 - Sample Project
    │   └── README.md
    └── README.md
├── 03 - Basic Networking 
    └── README.md
├── 04 - YAML
    ├── 01 - What is YAML 
    │   └── README.md
    ├── 02 - Data serialization and deserialization
    │   └── README.md
    └── README.md
├── 05 - GIT
    ├── 01 - Introduction
    │   ├── 01 - Local and Remote Repositories
    │   │   └── README.md
    │   ├── 02 - Initialize a GIT Repository
    │   │   └── README.md
    │   ├── 03 - GIT log
    │   │   └── README.md
    │   └── README.md
    ├── 02 - Branches
    │   ├── 01 - What is Branch?
    │   │   └── README.md
    │   ├── 02 - Merging branches
    │   │   └── README.md
    │   └── README.md
    ├── 03 - Initialize Remote Repositories
    │   ├── 01 - Initialize Remote Repositories
    │   │   └── README.md
    │   ├── 02 - Pushing to remote repositories
    │   │   └── README.md
    │   ├── 03 - Cloning remote repositories
    │   │   └── README.md
    │   ├── 04 - Fetching and Pulling
    │   │   └── README.md
    │   ├── 05 - Pull Requests
    │   │   └── README.md
    │   ├── 06 - Merge Conflicts
    │   │   └── README.md
    │   ├── 07 - Fork
    │   │   └── README.md
    │   └── README.md
    ├── 04 - Rebasing
    │   ├── 01 - Rebasing 
    │   │   └── README.md
    │   ├── 02 - Interactive Rebasing
    │   │   └── README.md
    │   ├── 03 - Cherry Picking
    │   │   └── README.md
    │   └── README.md
    ├── 05 - Resetting and Reverting
    │   ├── 01 - Resetting and Reverting
    │   │   └── README.md
    │   ├── 02 - Stashing
    │   │   └── README.md
    │   ├── 03 - Reflog
    │   │   └── README.md
    │   └── README.md
    └── README.md
├── 06 - Cloud
    ├── 01 - AWS
    │   ├── Day 1
    │   │   └── README.md
    │   ├── Day 2
    │   │   └── README.md
    │   ├── Day 3
    │   │   └── README.md
    │   ├── Day 4
    │   │   └── README.md
    │   ├── Day 5
    │   │   └── README.md
    │   ├── Day 6
    │   │   └── README.md
    │   └── README.md
    ├── AWS S3
    │   └── README.md
    ├── Basics
    │   ├── AWS Global Infrastructure
    │   │   └── README.md
    │   ├── IAM
    │   │   └── README.md
    │   ├── README.md
    │   ├── Security Groups and Network ACLs
    │   │   └── README.md
    │   └── VPC
    │   │   └── README.md
    ├── DynamoDB
    │   └── README.md
    ├── Elastic Compute Cloud (EC2)
    │   └── README.md
    └── README.md
├── 07 - Docker 
    ├── 01 - Docker Commands
    │   └── README.md
    ├── 02 - Docker Run
    │   └── README.md
    ├── 03 - Docker Images 
    │   ├── Commands vs Entrypoint
    │   │   └── README.md
    │   ├── Environment Variables 
    │   │   └── README.md
    │   └── README.md
    ├── 04 - Docker Network 
    │   └── README.md
    ├── 05 - Docker Compose 
    │   └── README.md
    ├── 06 - Dockerfile
    │   └── README.md
    └── README.md
├── 08 - Kubernetes
    ├── README.md
    └── YAML in Kubernetes
    │   └── README.md
├── 09 - Jenkins 
    ├── 01 - What is CI & CD
    │   └── README.md
    ├── 02 - Plugins
    │   └── README.md
    └── README.md
├── 10 - Ansible
    └── README.md
├── GoLang
    ├── 01 - First Go program
    │   └── README.md
    ├── 02 - Data Types and Variables
    │   ├── 02 - Variables
    │   │   ├── 01 - Declaration
    │   │   │   └── README.md
    │   │   ├── 02 - Printing Variables
    │   │   │   └── README.md
    │   │   ├── 03 - Scope
    │   │   │   └── README.md
    │   │   └── README.md
    │   ├── 03 - Converting between Data Type
    │   │   └── README.md
    │   ├── Data Type 
    │   │   ├── 01 - String 
    │   │   │   └── README.md
    │   │   ├── 02 - Numbers
    │   │   │   └── README.md
    │   │   ├── 03 - Boolean
    │   │   │   └── README.md
    │   │   └── README.md
    │   └── README.md
    ├── 03 - User Input
    │   └── README.md
    ├── 04 - Constants
    │   └── README.md
    ├── Array
    │   └── README.md
    ├── Control Flow
    │   ├── 01 - If-else and else if statements
    │   │   └── README.md
    │   ├── 02 - Switch Statement
    │   │   └── README.md
    │   ├── 03 - Looping with for 
    │   │   └── README.md
    │   └── README.md
    ├── Functions
    │   ├── 01 - Function Syntax
    │   │   └── README.md
    │   ├── 02 - Return Types
    │   │   └── README.md
    │   ├── 03 - Recursive Functions
    │   │   └── README.md
    │   ├── 04 - Anonymous Functions
    │   │   └── README.md
    │   ├── 05 - Higher Order Functions
    │   │   └── README.md
    │   ├── 06 - Defer Statement
    │   │   └── README.md
    │   └── README.md
    ├── Maps
    │   └── README.md
    ├── Modules, Packages and Imports
    │   ├── 01 - go.mod
    │   │   └── README.md
    │   └── README.md
    ├── Operators
    │   ├── Arithmetic Operators
    │   │   └── README.md
    │   ├── Assignment Operators
    │   │   └── README.md
    │   ├── Bitwise Operators
    │   │   └── README.md
    │   ├── Comparison Operators
    │   │   └── README.md
    │   ├── Logical Operators
    │   │   └── README.md
    │   └── README.md
    ├── Pointers
    │   ├── 01 - Address and Dereference Operator
    │   │   └── README.md
    │   ├── 02 - Declaring and Initialising a Pointer
    │   │   └── README.md
    │   ├── 03 - Dereferencing a pointer
    │   │   └── README.md
    │   ├── 04 - Passing by Value in Functions  
    │   │   └── README.md
    │   └── README.md
    ├── README.md
    ├── Slices
    │   └── README.md
    ├── Struct, Methods and Interfaces
    │   ├── 01 - Declaring and Initializing a Struct
    │   │   └── README.md
    │   ├── 02 - Accessing Fields
    │   │   └── README.md
    │   ├── 03 - Passing Structs to Functions
    │   │   └── README.md
    │   ├── 04 - Comparing Structs
    │   │   └── README.md
    │   ├── 05 - Methods
    │   │   └── README.md
    │   ├── 06 - Method Sets
    │   │   └── README.md
    │   └── README.md
    └── Type of Variable
    │   └── README.md
├── LICENSE
├── Python
    ├── Accepting user input
    │   └── README.md
    ├── Conditionals and Boolean Data Type
    │   └── README.md
    ├── Countdown App
    │   └── README.md
    ├── Dictionary Data Type
    │   └── README.md
    ├── First Python Program
    │   └── README.md
    ├── Functions
    │   └── README.md
    ├── Loops
    │   └── README.md
    ├── Modules
    │   └── README.md
    ├── Object Oriented Programming
    │   └── README.md
    ├── README.md
    ├── Scope
    │   └── README.md
    ├── Sets
    │   └── README.md
    ├── Try or Except
    │   └── README.md
    └── Variables
    │   └── README.md
└── README.md


/01 - Linux/01 - Shell/01 - Introduction/README.md:
--------------------------------------------------------------------------------
 1 | * The Linux shell is a program that allows text-based interaction between the user and the operating system. This interaction is carried out by typing commands into the interface and receiving the response in the same way. 
 2 | 
 3 | * The Linux shell is a powerful tool with which you can navigate between different locations within the system. When you log into the shell, the very first directory you are taken to is your home directory. 
 4 | 
 5 | * /home is a system created directory that contains the home directories for almost all users in the Linux system. 
 6 | 
 7 | * Why do we need a home directory? The home directory allows users to store their personal data in the form of files and directories. Each user in the system gets their own unique home directory with complete access to it, to be able to save, retrieve, or delete data. 
 8 | 
 9 | * Another thing to note is the representation of the home directory. It is represented by the tilde symbol ( ~ ) in the command line. 
10 | 
11 | * To interact with the Linux system using the shell, a user has to type in commands. When a command is run, it executes a program to achieve a specific task. 
12 | 
13 | * An arguement acts as an input to a command. 
14 | 
15 | * A command can also have options that modify its behavior in some predetermined way. This option, also sometimes referred to as a switch or a flag, is usually a single letter preceded by a single hyphen.
16 | 
17 | * Commands in Linux can be generally categorized into two types, internal, or built-in, commands and external commands. 
18 | 
19 | * Internal commands are part of the shell itself and come bundled with it. 
20 | 
21 | * External commands, on the other hand, are binary programs or scripts which are usually located in distinct files in the system. They either come pre-installed with the distribution's package manager or can be created or installed by the user. 
22 | 
23 | * To determine if a command is internal or external, use the "type" command. For example,
24 | 
25 | ```
26 | type cd
27 | ```
28 | 
29 | * Output will be, 
30 | 
31 | ```
32 | cd is a shell builtin
33 | ```
34 | 
35 | * NOTE: There are three parts in a Linux sentence
36 | 
37 | ```
38 | <command> <arguement> <option>
39 | ```
40 | 
41 | * We can also give more than one arguement.
42 | 
43 | 
44 | 
45 | ## Types of Shell ## 
46 | 
47 | * There are several different shells in Linux.
48 | 
49 |    1. Bourne shell 
50 |    2. C shell 
51 |    3. Korn shell 
52 |    4. Z shell 
53 |    5. Bourne-again shell (bash)
54 |    
55 | * To check the shell being used use the command
56 | 
57 | ```
58 | echo $SHELL 
59 | ```
60 | 
61 | * Bash is perhaps the most popular shell, specifically because of its features such as Bash completions or brace expansion.
62 | 
63 | * To change the default shell, use the command 
64 | 
65 | ```
66 | chsh
67 | ```
68 | 
69 | * Let us now take a quick look at the features of the Bash shell. 
70 | 
71 |    1. Bash supports command auto-completion. Bash will attempt to auto-complete commands for you if you type a part of it and press the tab key. This feature can extend to completing a file or a directory name, commands, its arguments and options. 
72 |    2. In Bash, we can set custom aliases for the actual commands.
73 | 


--------------------------------------------------------------------------------
/01 - Linux/01 - Shell/02 - Basic Linux Commands/README.md:
--------------------------------------------------------------------------------
 1 | * pwd -> This should print the present directory you are on.
 2 | 
 3 | * ls -> to see the contents of a directory.
 4 | 
 5 | * mkdir -> to create a new directory. 
 6 | 
 7 | * cd -> It will automatically change the directory to the home directory from any location in the system. 
 8 | 
 9 | * mkdir dir1/dir2 -> to create a directory inside a directory without going inside dir1.
10 | 
11 | * An alternative to the CD or change directory is the PUSHD command. This command remembers the current working directory before changing to the directory specified in the command argument. 
12 | 
13 | * mv -> moves a directory or a file from one place to another. This command requires two arguments. The first argument is the source file or directory, and the second argument is the destination directory where we want to be moved. Example,
14 | 
15 | ```
16 | mv /home/naved/football/stumps /home/naved/cricket/
17 | ```
18 | This will move the directory from football to Cricket. Notice that we have used absolute path. We can also use the relative path to achieve this, by, 
19 | 
20 | ```
21 | mv football/stumps cricket/
22 | ```
23 | Here make sure that you are in the /home/naved directory.
24 | 
25 | * We can also use mv command to rename a file. We can do this by running the same mv command as before. Example,
26 | 
27 | ```
28 | mv Asia/India/Lucnow Asia/India/Lucknow
29 | ```
30 | The first argument is the directory, which has to be renamed, and the second argument is the relative path to the correct directory name. 
31 | 
32 | * cp -> allows you to create a copy of a file or directory and place it in a specified location. This command also expects two arguments. The first argument is the source file or directory. The second argument is the destination. Example,
33 | 
34 | ```
35 | cp Cricket/rules.txt Football
36 | ```
37 | 
38 | * rm -> used to remove or delete files and directories. 
39 | 
40 | ```
41 | rm Sports/Cricket/Extras.txt
42 | ```
43 | 
44 | * cat -> to see the contents of a file.
45 | 
46 | * We can also use cat command to add data to a file, by, 
47 | 
48 | ```
49 | cat > example.txt
50 | Hey everyone
51 | ```
52 | Use ctrl + d to save and exit.
53 | 
54 | * touch -> to create a file.
55 | 
56 | * env -> to see a list of all environment variables.
57 | 
58 | * To set an environment variable, we can use the export command. Example,
59 | 
60 | ```
61 | export OFFICE = Microsoft
62 | ```
63 | 
64 | * more -> you can view text files in a scrollable manner. It loads the entire file at once. 
65 | 
66 | * less -> allows you to view the contents of a file and navigate through the file. 
67 | 
68 | * du with the option -sk shows the size of a file or a directory in kilobytes. A better version of this command, du -sh prints the size in a human-readable format. 
69 | 
70 | * what is < > -> displays a one-line description of what a command does. 
71 | 
72 | * man -> provide information about the command in detail.
73 | 
74 | <b>NOTE :</b> --help flag provide users with the options and use cases available in a command. 
75 | 
76 | * apropos -> will search through the man page names and descriptions for instances of a keyword. This is useful if you want to look up all commands within the system that contains a specific keyword. Example,
77 | 
78 | ```
79 | [~]$ apropos modpr
80 | modprobe (8)         - Add and remove modules from the Linux Kernel
81 | modprobe.d (5)       - Configuration directory for modprobe
82 | ```
83 | 


--------------------------------------------------------------------------------
/01 - Linux/01 - Shell/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/01 - Linux/02 - Linux Core Concepts/01 - Kernel /README.md:
--------------------------------------------------------------------------------
 1 | * Kernel is the major component of an operating system and is the core interface between a computer's hardware and its processes. It communicates between the two managing resources as efficiently as possible. 
 2 | 
 3 | * The Kernel is responsible for four major tasks. 
 4 | 
 5 |    1. Memory management : keep track of how much memory is used to store what and where. 
 6 |    2. Process management : determine which processes can use the CPU when, and for how long. 
 7 |    3. Device drivers : act as a mediator or an interpreter between the hardware and processes. 
 8 |    4. System calls and security : receive requests for service from the processes. 
 9 |    
10 | * The Linux Kernel is monolithic. This means that the Kernel carries out CPU scheduling, memory management, and several other operations by itself. 
11 | 
12 | * The Kernel is also modular, which means it can extend its capabilities through the use of dynamically loaded Kernel modules. 
13 | 
14 | * Let us now look at ways to identify the Linux Kernel version and understand the naming conventions. The Kernel is an integral part of the operating system. Use the uname command to display information about the Kernel. 
15 | 
16 | ```
17 | uname
18 | ```
19 | 
20 | * Use the dash r or dash -a flag to print the Kernel version. 
21 | 
22 | ```
23 | uname -r 
24 | OR 
25 | uname -a
26 | ```
27 | 
28 | * One of the important functions of the Linux Kernel is memory management. Memory is divided into two areas known as Kernel space and userspace. These are synonymous to the terms Kernel and user mode. 
29 | 
30 | * Kernel space is the portion of memory in which the Kernel executes and provides its services. A process running in the Kernel space has unrestricted access to the hardware. As such, it is strictly reserved for running the Kernel code, Kernel extensions, and most device drivers. 
31 | 
32 | * On the other hand, all processes running outside the Kernel reside in the user space which has restricted access to CPU and memory. 
33 | 
34 | * Most Unix-like operating systems, including Linux, come prepackaged with all kinds of utilities programming languages, and graphical tools. These are called user-space applications. This is also often referred to as the Userland. 
35 | 
36 | * Let us now look at how programs running in the user space work. All user programs function by manipulating data, but where does this data live? Most commonly, it is stored in memory and on disk. User programs get access to data by making special requests to the Kernel called <b>system calls</b>. Examples include allocating memory by using variables or opening a file. For example, opening a file such as the /etc/os-release file to see the version of the operating system installed results in a system call. 
37 | 


--------------------------------------------------------------------------------
/01 - Linux/02 - Linux Core Concepts/02 - Boot Sequence/README.md:
--------------------------------------------------------------------------------
 1 | * The boot process can be broken down into four stages:
 2 | 
 3 |    1. BIOS POST
 4 |    2. boot loader or the GRUB2
 5 |    3. kernel initialization
 6 |    4. service initialization using systemd 
 7 |    
 8 | 1. The first step called BIOS POST has very little to do with Linux itself. POST stands for power-on self-test. In this stage, BIOS runs a POST test to ensure that the   hardware components attached to the device are functioning correctly. If POST fails, the computer may not be operable and the system will not proceed to the second stage of the boot process. 
 9 | 
10 | 2. The next stage after POST is the boot loader. After a successful POST test, the BIOS loads and executes the boot code from the boot device, which is located in the first sector of the hard disk. In Linux, this is located in the /Boot File System. The boot loader provides the user with the boot screen often with multiple options to boot into such as Microsoft Windows OS or an Ubuntu 18.04 OS, in an example of a dual boot system. Once the selection is made at the boot screen, the boot loader loads the kernel into memory, supplies it with some perimeters, and hands over the control to the kernel. A popular example of the boot loader is the GRUB2, which stands for Grand Unified Bootloader version 2, and it is now the primary boot loader for most current Linux distributions. After the selected kernel is loaded into the memory, it is usually decompressed. This is done as the kernels are generally in a compressed state to conserve space.  
11 | 
12 | 3. The kernel is then loaded into the memory and starts executing. During this phase, the kernel carries out tasks such as initializing hardware and memory management tasks among other things. Once it is completely operational, the kernel looks for an init process to run, which sets up the user space and the processes needed for the user environment. 
13 | 
14 | 4. In most of the current day Linux distributions, the init function then calls the systemd daemon. The systemd is responsible for bringing the Linux host to a usable state. Systemd is responsible for mounting file systems, starting and managing system services. Systemd is the universal standard these days.
15 | 


--------------------------------------------------------------------------------
/01 - Linux/02 - Linux Core Concepts/03 - File Types/README.md:
--------------------------------------------------------------------------------
 1 | * There is a common phrase associated with Linux that goes like this, “Everything is a file in Linux.” What this phrase tries to convey is every object in Linux can be considered to be a type of file. 
 2 | 
 3 | * There are three types of files, regular, directory and special files. 
 4 | 
 5 | ## Regular Files ##
 6 | 
 7 | * Regular files, these are the most common type of files that contains some text, data or images. Examples are configuration files, shell scripts or code, JPG files, etc. 
 8 | 
 9 | ## Directory ##
10 | 
11 | * Directory is a type of file as well that stores other files and directories within. The simplest example of this is your home directory. 
12 | 
13 | ## Special Files ##
14 | 
15 | * Special files can be subcategorized into five other file types. 
16 | 
17 |    1. Character files: These files represent devices under the /dev file system that allows the OS to communicate to IO devices serially. Examples include devices such as the mouse and the keyboard. 
18 |    
19 |    2. Block files: These are files representing block devices also located under /dev. Examples of a block device are hard disks and RAM. 
20 |    
21 |    3. Links: Links in Linux is a way to associate two or more file names to the same set of file data. There are two types of links. The hard link associates two or more file names that share the same block of data on the physical disk. The symbolic link or symlink can be loosely compared to a shortcut in Windows. They act as pointers to another file. Deleting a symlink does not affect the data in the actual file. 
22 |    
23 |    4. Socket: A socket is a special file that enables the communication between two processes. 
24 |    
25 |    5. Named Pipes: This is a special type of file that allows connecting one process as an input to another. The data flow in a pipe is unidirectional from the first process to the second. 
26 |  
27 | 
28 | 
29 | 
30 | 
31 | * Let us now see how to identify the different file types in Linux. 
32 | 
33 | -> One way to do this is by making use of the file command like this,
34 | 
35 | ```
36 |  $ file /home/naved-ahmad
37 | /home/naved-ahmad: directory
38 | ```
39 | 
40 | In this example, running the command file with the file or directory name displays the file type. 
41 | 
42 | 
43 | 
44 | -> Another way to do this is by running an ls or list storage command with the -l flag with the file or directory as the argument. 
45 | 
46 | ```
47 | ls -ld /home/naved-ahmad
48 | drwxr-xr-x 1 naved-ahmad naved-ahmad 4096 May  1 11:26 /home/naved-ahmad
49 | ```
50 | 
51 | From the command output, look at the first character. The letter d denotes that this is a directory. Similarly, we can identify the rest of the file types by checking the first letter in the ls -l output. Regular files can be identified by a dash, character devices by the letter c, link, by the lowercase letter l, socket file by the letters, named pipes by the letter p, and finally, block device by the letter b.
52 | 


--------------------------------------------------------------------------------
/01 - Linux/02 - Linux Core Concepts/04 - Filesystem Hierarchy/README.md:
--------------------------------------------------------------------------------
1 | * The directory /home is the location that contains the home directories for all users except for the root user. The root user's home directory is located at /root. 
2 | 
3 | * If you want to install any third-party programs, put them in the /opt file system.
4 | 


--------------------------------------------------------------------------------
/01 - Linux/02 - Linux Core Concepts/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/01 - Linux/03 - Package Management/README.md:
--------------------------------------------------------------------------------
 1 | * Let us first understand what a package is. A package, in its simplest definition, is a compressed archive that contains all the files that are required by a particular software to run. 
 2 | 
 3 | * A package manager is a software in a Linux system that provides a consistent and automated process of installing, upgrading, configuring, and removing packages from the operating system. 
 4 | 
 5 | * Some of the essential functions of a package manager are:
 6 | 
 7 |    1. Ensuring the integrity and authenticity of the package by verifying their digital certificates and checksums. This is to ensure that the package is downloaded from  a trusted source and safe to install. 
 8 |    2. Simplifying the entire package management process, most package managers provide powerful querying options, making it easier to look up packages and then downloading, installing, or updating existing software.
 9 |    3. Grouping packages by function to reduce user confusion. 
10 |    4. Managing dependencies to ensure a package is installed with all packages it requires, thus avoiding what is commonly known as dependency hell.
11 | 
12 | 
13 | 
14 | * Depending upon the distribution, a Linux system supports several different types of package managers. Some of the common ones are:
15 | 
16 |    1. dpkg, the base package manager for Debian-based distributions
17 |    2. apt, a newer front end for the dpkg system found in Debian-based distributions such as Ubuntu, Linux Mint, and Elementary OS. 
18 |    3. Apt-get is the traditional front-end for the dpkg system found in Debian-based distributions. 
19 |    4. RPM, the base package manager found in Red Hat-based distributions such as Red Hat Enterprise Linux, CentOS, and Fedora. 
20 |    5. YUM, a front-end for the RPM system found in Red Hat-based distributions. 
21 |    6. DNF, a more feature-rich front-end for the RPM system. 
22 | 
23 | 
24 | 
25 | ## RPM ##
26 | 
27 | * It stands for Red Hat Package Manager. This package manager is used in Red Hat Enterprise Linux, as well as other Linux distributions, such as CentOS and many versions of Fedora.
28 | * The file extension for packages managed by RPM is .rpm. 
29 | * Let's see how to work with RPM using the Linux command line. RPM has five basic modes of operation: 
30 | 
31 |    1. installing
32 |    2. uninstalling
33 |    3. upgrade 
34 |    4. query 
35 |    5. verifying
36 | 
37 | * Each of these modes can be run using the RPM command followed by specific command options. 
38 | 
39 | 
40 | 
41 | ## YUM ##
42 | 
43 | * YUM stands for Yellowdog Updater Modified, and it is a free and open-source package manager that works on RPM-based Linux systems. 
44 | 
45 | * YUM works with software repositories, which are essentially a collection of packages, and provides package and dependency management on RPM-based distros. 
46 | 
47 | * The repository information is stored in the /etc/yum.repos.d, and the repository files have a .repo extension. 
48 | 
49 | * YUM acts as a high-level package manager, but under the hood, it still depends on RPM to manage packages on the Linux system. 
50 | 
51 | * Unlike RPM, YUM handles package dependencies very well, it's able to install any dependent packages to get the base package installed on the Linux system. 
52 | 
53 | 
54 | 
55 | ## DPKG ##
56 | 
57 | * dpkg stands for the Debian package manager and similar to rpm, it is a low-level package manager. Similar to rpm, dpkg can be used to install, remove, upgrade, list, and verify a package. The package extension is .deb. 
58 | 
59 | * To install or update an existing package, use the dpkg-i <package_name>. 
60 | 
61 | * To uninstall, use the -r flag. 
62 | 
63 | * To list packages installed in the system along with the version number in a short description, use the -l flag. 
64 | 
65 | * Use the -s option to check the status of the package if it is installed in the system. 
66 | 
67 | * Finally, use the -p flag to display details about packages such as version number, maintainer, et cetera. 
68 | 
69 | * Similar to rpm, dpkg does not honor the dependencies when it comes to package management. An install may fail due to dependencies issues. This is the reason why we use higher-level Debian package managers such as apt and apt-get. Instead of of relying on dpkg, you can install software along with its dependencies using apt or apt-get. Although it sounds similar, apt and apt-get do not depend on each other. apt stands for advanced package managers is more user friendly and overall a better tool compared to apt-get. 
70 | 
71 | 
72 | 
73 | ## APT ##
74 | 
75 | * apt acts as a front end package manager that relies on the dpkg utility, quite similar to the relation between yum and rpm that we saw earlier. 
76 | 
77 | * Similar to yum, apt relies on a software repository that contains packages that would eventually be installed on the system. The software repository for apt is defined in the /etc/apt/sources.list file. The source can be a local one such as a directory on the file system or a CD-ROM, or it can be at a remote location that is accessed via HTTP, HTTPS, or FTP transfer protocols. 
78 | 
79 | * Let us now see some of the common apt commands. 
80 | 
81 |    1. Run the apt update command to refresh the repository. This command is used to download package information from all available sources. A good time to run this would be immediately after installing the OS or after adding new sources. 
82 |    2. The apt upgrade command can be used to install available upgrades of all packages currently installed on the system from the sources configured. 
83 |    3. You can also update the repositories using the apt edit sources command. This opens up the /etc/apt/sources.list file in the text editor of your choice such as vim or nano. Another way to add more repositories, update the sources.list file directly using a text editor such as the VI-editor. Once the repositories have been set up, you can make use of it to run apt commands. 
84 |    4. To install a package, run the apt install command. 
85 |    5. Run the apt remove command to remove the package. 
86 |    6. The apt search command can be used to look for a package in the repository. 
87 |    7. You can also list all the available packages using the apt list command. 
88 | 
89 | 
90 | 
91 | ## APT vs APT-GET ##
92 | 
93 | * APT is a more user friendly tool compared to APT-GET. In all the latest Debian-based distros, APT is already installed by default.
94 | 


--------------------------------------------------------------------------------
/01 - Linux/Archiving Files/README.md:
--------------------------------------------------------------------------------
 1 | * tar -> used to group multiple files or directories into a single file. Hence, it is especially useful for archiving data. Tar is an abbreviation for Tape Archive. 
 2 | 
 3 | * Files created with tar are often called tarballs. This command has a lot of options and features 
 4 | 
 5 | * The tar command followed by -c is used to create an archive. 
 6 | 
 7 | * The -f is used to specify the name of the tar file to be created. This is followed by the files or directories to be archived. 
 8 | 
 9 | * The -tf option followed by the tar file name, is used to see the contents of the tarball. 
10 | 
11 | * The -xf flag is used to extract the contents from the tarball. 
12 | 
13 | * Finally, we can also use the -z command to compress the tarball to reduce its size. 
14 | 
15 | 
16 | 
17 | ## Compression ##
18 | 
19 | * Compression is the technique used to reduce the size consumed by a file or a data set. For example, reducing the size of a file or directory on the Linux file system, there are commands which are specifically used for compression.
20 | 
21 | * Let us now look at three of the popular ones.
22 | 
23 |    1. bzip2
24 |    2. gzip
25 |    3. xz
26 | 
27 | * The space of the compressed file created by these three commands depends on a few factors such as the type of data being compressed. The other factors that affect the
28 | size are the compression algorithm used by these commands and the compression level used. 
29 | 
30 | * The compression command adds a file extension to the file after the operation, namely .bz2, .gz, and .xz. 
31 | 
32 | * The compressed files can be uncompressed using the commands, 
33 | 
34 |    1. bunzip2
35 |    2. gunzip
36 |    3. unxz
37 |    
38 | * Tools such as zcat, bzcat and xzcat allow the compressed file to be read without uncompressing them. 
39 | 


--------------------------------------------------------------------------------
/01 - Linux/Command Line Pipes/README.md:
--------------------------------------------------------------------------------
1 | * Command-line pipes allow the linking of multiple commands. In simple terms, pipes allow the first command standard out to be used as the standard input for the second command. 
2 | 
3 | * The pipes are defined using the vertical bar symbol. 
4 | 


--------------------------------------------------------------------------------
/01 - Linux/Environment Variables/README.md:
--------------------------------------------------------------------------------
 1 | * What is $ SHELL in echo $SHELL command ? It is a variable and to be more specific, it is an environment variable. Variables just as in any programming language are used   to store information. In this example, the word SHELL in uppercase represents an environmental variable, which stores the value of the type of shell used by the user. To print the variable value, We precede the variable name with a $ symbol.
 2 | 
 3 | * Environment variables in specific, store information about the user's login session, which is used by the shell when executing commands. To see a list of all environment variables, use
 4 | 
 5 | ```
 6 | env
 7 | ```
 8 | 
 9 | * To set an environment variable, we can use the export command. Say you want to create a new environment variable called office and set a value of caleston to it, use     the export command and in the argument, use office = caleston. This will set the variable for the current shell and any other processes or programs started by the     shell. 
10 | 
11 | ## PATH variable ## 
12 | 
13 | * Speaking about the environment variables, when a user issues an external command into the shell, the shell uses a path variable to search for these external commands. To see the directories defined in the path variable, use the command echo $PATH . If the path variable does not have the location of a command or a program defined, running a command by itself will result in a failure. 
14 |  
15 | * To check if the location of a command can be identified, use the which command. 
16 | 


--------------------------------------------------------------------------------
/01 - Linux/IO Redirection/README.md:
--------------------------------------------------------------------------------
 1 | * Let us get familiar with the concept of standard streams in Linux. There are three data streams created when you launch a Linux command. 
 2 | 
 3 |    1. Stdin is the standard input string. This accepts text as its input. 
 4 |    2. Text output from the command that you see printed on your screen is delivered via the stdout or the standard out stream. 
 5 |    3. Error messages from the command are sent through the standard error stream, with IO redirection. 
 6 |    
 7 | * The standard input-output and error can be redirected to text files. Let's see how to do that next. 
 8 | 
 9 | * To redirect standard output to a file instead of printing it on the screen, we can use the forward arrow symbol followed by the name of the file. The forward arrow symbol overwrites the contents of the file with the stdout. Example,
10 | 
11 | ```
12 | echo $SHELL > shell.txt
13 | ```
14 | 
15 | ```
16 | cat shell.txt
17 | /bin/bash
18 | ```
19 | 
20 | * If you want to append stdout to an existing file, use the double forward arrow symbol. 
21 | 
22 | ```
23 | echo "Bash shell" >> shell.txt
24 | ```
25 | 
26 | ```
27 | cat shell.txt
28 | /bin/bash
29 | Bash shell
30 | ```
31 | 
32 | * In order to redirect just the error messages, we need to use the number 2 followed by a forward arrow symbol, and then the name of the file in which the errors will be written. Example,
33 | 
34 | ```
35 | cat missing_file 2> error.txt
36 | ```
37 | 
38 | ```
39 | cat error.txt
40 | cat: missing_file: No such file or directory
41 | ```
42 | If the file doesn't exist, a new one will be created. Otherwise, the file will be overwritten. 
43 | 
44 | * To append the standard error to an existing file, use the number 2 double forward symbol. Example,
45 | 
46 | ```
47 | cat missing_file 2>> shell.txt
48 | ```
49 | 
50 | ```
51 | cat shell.txt
52 | cat: missing_file: No such file or directory
53 | ```
54 | 
55 | * If you want your command to execute and not print error messages on the screen, even if it generates a standard error, you can redirect to /dev/null, like this. 
56 | * /dev/null is referred to as the bit bucket. The place where you dump anything you don't need, in this case, the standard error, which we do not want to be printed on the screen. 
57 | 
58 | * Another useful command to work with standard input and standard output is the tee command. Instead of the redirect operator, we can use a command-line pipe followed by the tee command and the file name to redirect the output. The difference is that with tee, the standard output is still printed on the screen before overwriting the contents of the file with the same string. 
59 | 
60 | * Use tee -a option to append the file instead of overwriting it. 
61 | 
62 | 
63 | 
64 | 
65 | 
66 | 
67 | 
68 | 


--------------------------------------------------------------------------------
/01 - Linux/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/01 - Linux/Searching for Files and Patterns/README.md:
--------------------------------------------------------------------------------
 1 | ## locate ##
 2 | 
 3 | * Run the locate command with the file name you are searching as the argument.
 4 | 
 5 | ```
 6 | locate example.txt
 7 | ```
 8 | 
 9 | * This should return all paths matching the pattern. This command is useful to find files quickly in the Linux file system. It will print out all paths with the keyword in it. 
10 | 
11 | * The downside to this command is that it depends on a database called "mlocate.db" for querying the file name. If you have just installed Linux or if the file you are trying to locate was created recently, this command may not yield useful results. This is because it is possible that the DB has not been updated yet. To manually update the DB, run the command updatedb, and then run the locate command again. 
12 | 
13 | <b>NOTE</b>: Please note that the updatedb command needs to be run as a root user to work. 
14 | 
15 | ## find ##
16 | 
17 | * Another way to do this is to make use of the find command. Use the find command followed by the directory under which you want to search. To search for a file by name, use the -name option, followed by the name of the file. 
18 | 
19 | ## grep ##
20 | 
21 | * To search within files, the most popular command in Linux is grep. Grep is commonly used to print lines of a file matching a pattern, but it offers a variety of other options as well. 
22 | 
23 | * Use the grep command followed by the word you want to search for, and finally, the file name. This should print out only the line matching the search pattern. 
24 | 
25 | * The grep command is case sensitive and will only print the lines matching the case of the pattern. To search case insensitive use the -i flag. 
26 | 
27 | * grep -r can be used to search for a pattern recursively within a directory. This is especially useful when you don't know which file contains the specific pattern that you are looking for. Example,
28 | 
29 | ```
30 | grep -r "Cricket" /home/naved
31 | ```
32 |  
33 | * Use the -v option, This option lists all lines that do not contain a particular string. 
34 | 
35 | * The -A and -B command flags can be used to print a number of lines after and before matching a pattern. They can be used together and separately also.
36 | 
37 | 
38 | 
39 | 


--------------------------------------------------------------------------------
/01 - Linux/Security and File Permissions/01 - Linux Accounts/README.md:
--------------------------------------------------------------------------------
 1 | ## User Account ## 
 2 | 
 3 | A user account refers to individual people who need access to the linux system. 
 4 | 
 5 | ## Superuser Account ##
 6 | 
 7 | A super user account is the root which has the UID 0. The superuser has unrestricted access and control over the system, including other users. 
 8 | 
 9 | ## System Accounts ##
10 | 
11 | They are usually created during the OS installation. These are for use by software and services that will not run as the super user. SSHD and the mail user are examples. 
12 | 
13 | ## Service Accounts ##
14 | 
15 | They are similar to system accounts and are created when services are installed on linux. Example, an nginx server makes use of a service account called nginx. 
16 | 
17 | 
18 | 
19 | * To see details about users in the linux system, we use some basic commands.
20 | 
21 |    1. id -> gives information about the user specifically the uid, gid, and groups a user is part of. 
22 |    2. who -> to see the list of users currently logged into the system.
23 |    3. last -> displays the record of all logged-in users. It also shows the date and time when the system was rebooted.
24 |    
25 |    
26 | 
27 | ## Switching Users ##
28 | 
29 | su -> with this command. you can switch to any other user in the system, including root. 
30 | 


--------------------------------------------------------------------------------
/01 - Linux/Security and File Permissions/02 - User Management/README.md:
--------------------------------------------------------------------------------
 1 | * useradd <name_of_user> -> this command is used by the system administrators to create a new local user in the system. 
 2 | 
 3 | * passwd <name_of_user> -> To set the password for the user created above. 
 4 | 
 5 | * useradd command can be used with options. Here is how,
 6 | 
 7 | ![Screenshot (141)](https://user-images.githubusercontent.com/98219227/236740616-aeb66235-163c-45db-9ce7-664bdfd0ed03.png)
 8 | 
 9 | * userdel <name_of_user> -> to delete a user account.
10 | 
11 | * groupadd -g <GID> <name_of_group> -> to add a new linux group. 
12 |   
13 | * groupdel <group_name> -> to remove the group.
14 | 


--------------------------------------------------------------------------------
/01 - Linux/Security and File Permissions/03 - Access control files/README.md:
--------------------------------------------------------------------------------
 1 | * Most of the access control files in linux are stored under the /etc directory. This directory can be read by any user by default, but only the root user has access to write to it. 
 2 | 
 3 | * They are also designed in a way that they should never be modified using a text editor. Instead, use the built-in commands to add or modify access as needed. We will learn how to do that later.
 4 | 
 5 | * Let us look at the basic access control files in linux. 
 6 | 
 7 |    1. /etc/passwd -> commonly known as the password file. It contains basic information about the users in the system. Note that this file does not store any passwords. File structure is like,
 8 |    ```
 9 |    USERNAME:PASSWORD:UID:GID:GECOS:HOMEDIR:SHELL
10 |    ```
11 |    2. /etc/shadow -> password are stored here. Contents of this file are hashed. File structure is like,
12 |    ```
13 |    USERNAME:PASSWORD:LASTCHANGE:MINAGE:MAXAGE:WARN:INACTIVE:EXPDATE
14 |    ```
15 |    3. /etc/group -> stores information about all user groups on the system such as group name, gid and members. File structure is like,
16 |    ```
17 |    NAME:PASSWORD:GID:MEMBERS
18 |    ```
19 | 


--------------------------------------------------------------------------------
/01 - Linux/Security and File Permissions/04 - File Permissions and Ownership/README.md:
--------------------------------------------------------------------------------
 1 | * Use the below command we can determine the file type and the permissions it has,
 2 | 
 3 | ```
 4 | ls -l <name_of_file>
 5 | ```
 6 | 
 7 | ![Screenshot (144)](https://user-images.githubusercontent.com/98219227/236995064-09dd47e5-d20b-4643-9478-0ebbb9c3e6a4.png)
 8 | 
 9 | ![Screenshot (145)](https://user-images.githubusercontent.com/98219227/236995227-72bea148-1446-4abb-9f19-e7842b8cdf5d.png)
10 | 
11 | 
12 | * Now that we know hoe file permission sarte represented in Linux, let us change permisssions of some files.
13 | 
14 | * Command used to modify the permissions of a file is called chmod. Syntax,
15 | 
16 | ```
17 | chmod <permission> <file_name>
18 | ```
19 | 
20 | * Permissions can be modified in two ways, symbolic mode and numeric mode. Both lead to the same result. 
21 | 
22 |    1. In symbolic mode, the first characters following the chmod command specify whose permissions you want to change. For user use u, g for group and o for others. After these characters, we need to specify if we want to grant access using plus symbol or revoke existing access with the minus symbol. Finally, we provide the file or directory for which the permissions have to be changed. Example,
23 |   
24 |    ```
25 |    chmod ugo+r-x example.txt -> Provide read access to owners, groups, and others, Remove execute access.
26 |    ```
27 |    
28 |    2. In numeric mode, we specify the permission to be updated in terms of the three digit octal values. The first among the three digit is for the owner, second one is for group and third one is for others.
29 |   
30 |    ```
31 |    chmod 555 example.txt -> Provide read and execute access to owners, groups and others.
32 |    ```
33 | 
34 | * Let us see how to change the ownership and group. We use 'chown' command for this. Syntax,
35 | 
36 | ```
37 | chown <owner>:<group> <file_OR_directory>
38 | ```
39 | 
40 | If a group is not provided, only the ownership is changed. 
41 | 
42 | <b>NOTE:</b> Using the -R flag with chown command will change the ownership for the entire directory including all the files inside to the service account.
43 | 
44 | * Group can be changes using the command 'chgrp'. It modifies only the group of the file or directory. Example,
45 | 
46 | ```
47 | chgrp developer example.txt -> Change the group for the example.txt file to the group called developer.
48 | ```
49 | 


--------------------------------------------------------------------------------
/01 - Linux/Security and File Permissions/05 - SSH and SCP/README.md:
--------------------------------------------------------------------------------
 1 | # SSH #
 2 | 
 3 | * SSH is used for logging into and executing commands on a remote computer. Syntax.
 4 | 
 5 | ```
 6 | ssh <hostname 0R IP_Address>
 7 | ```
 8 | 
 9 | * Also, you can pass in the user you want to connect to by,
10 | 
11 | ```
12 | ssh <user>@<hostname OR IP_Address>
13 | 
14 |             OR
15 | 
16 | ssh -l <user> <hostname OR IP_Address>
17 | ```
18 | 
19 | <b>NOTE:</b> The remote server should have an SSH service running in port 22 accessible from the client for the connection to work. Another requirement is a valid username and password created on the remote system that you can use or something known as an SSH key that we can use to login to the remote machine without a password. 
20 | 
21 | * These ways discussed above ask for password every time. But, if you do not want to pass in a username and password everytime, you can implement the password-less authentication. 
22 | 
23 | ## Password-less Authentication ##
24 | 
25 | * To do this, we need to first generate a key pair on the client. A key pair, consists of two pairs of keys, a private key and a public key. 
26 | 
27 |    1. <b>Private Key:</b> This is the key only you as the client will have and is not shared with anyone else. 
28 |    2. <b>Public Key:</b> It can be shared with others, including our remote server. When it is installed on the remote server, you can unlock it by connection to it with a client that already has the private key. 
29 | 
30 | 
31 | * To setup a password-less authentication, 
32 | 
33 |    1. Create the key pair on the client, which is your laptop using this command,
34 |    ```
35 |    ssh-keygen -t rsa
36 |    ```
37 |    When you run this command, it will ask you to enter a passphrase. It is optional, but improves the security of the key. Only downside of having a passphrase is then having to type it in each time you use the key pair. 
38 |    
39 |    2. Next step is to copy the public key to the remote server. You have to go through password-based authentication atleast once. Use this command syntax,
40 |    ```
41 |    ssh-copy-id <user>@<hostname OR IP_Address>
42 |    ```
43 |    Once you enter this command, you will be asked to enter the password for your user on the remote server. After this, you will be able to access the remote server without entering a password. 
44 | 
45 | 
46 | 
47 | # SCP #
48 | 
49 | * SCP allows us to copy data over SSH. This means that you can copy files and directories between your laptop and any other server to which you have SSH access. Example,
50 | 
51 | ```
52 | scp /home/naved/example.txt prodapp01:/home/naved
53 | ```
54 | <b>NOTE:</b> You should have permission to write to the directory in the destination, else you will get a permission denied error. 
55 | 
56 | * If you want to copy directories instead of files, use -r option. 
57 | 
58 | * To preserve the ownership and permission of the source file, use -p flag. 
59 | 


--------------------------------------------------------------------------------
/01 - Linux/Security and File Permissions/06 - IPTABLES/README.md:
--------------------------------------------------------------------------------
 1 | * iptables is a command-line utility for configuring the firewall in Linux-based operating systems.
 2 | 
 3 | * It provides a powerful and flexible framework for managing network traffic by defining rules and policies.
 4 | 
 5 | * iptables allows you to set up rules to filter, modify, and route network packets, giving you control over incoming and outgoing traffic on your system. 
 6 | 
 7 | * To install iptables on Ubuntu, use the command,
 8 | 
 9 | ```
10 | sudo apt install iptables
11 | ```
12 | 
13 | * To list the default rules,
14 | 
15 | ```
16 | sudo iptables -L
17 | ```
18 | 
19 | * We will see three types of rules or chains configured by default after running above command, input, forward and output. 
20 | 
21 |    1. The input chain is applicable to network traffic coming into the system. 
22 |    2. The output chain is responsible for connections initiated he system to other systems. 
23 |    3. Forward chain is used in network routers where the data is forwarded to other devices in the network. It is not commonly used in a linux server. 
24 | 
25 | * They are called chains because each chain can have multiple rules within it. Each rule performs a check and accepts or drops the packet based on the condition.
26 | 
27 | 
28 | 
29 | ![Screenshot (148)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/39865ed9-ba8c-43fc-b84d-26657f949b43)
30 | 
31 | 
32 | 
33 | * Example of creating an input rule on a dev server,
34 | 
35 | ```
36 | sudo iptables -A INPUT -p tcp -s 172.18.216.10 --dport 22 -j ACCEPT
37 | ```
38 | 
39 | * If we use -I option instead of -A, it will insert the rule to the top of the chain instead of the bottom. 
40 | 
41 | 
42 | ![Screenshot (159)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/c8e88fea-2dfc-4442-ace3-878a7668d99c)
43 | 
44 | 
45 | <b>NOTE:</b> Sequence in which we add rules is very important. They are implemented from top to bottom. 
46 | 
47 | 
48 | 
49 | * To delete a rule, use -D option. For example, to delete a rule at posiion 3, 
50 | 
51 | ```
52 | iptables -D OUTPUT 3 
53 | ```
54 | 


--------------------------------------------------------------------------------
/01 - Linux/Security and File Permissions/07 - Cronjobs/README.md:
--------------------------------------------------------------------------------
 1 | * Cron is used to schedule jobs in Linux. 
 2 | 
 3 | * With a Cron job, a user can specify any date, time, or frequency to schedule a task. Once defined, the system will execute the task at the set time.
 4 | 
 5 | * This functionality is enabled by the crond service that runs in the background. 
 6 | 
 7 | * To schedule a task, run the command,
 8 | 
 9 | ```
10 | crontab -e 
11 | ```
12 | We will be in the VI Editor now. Navigate to the bottom of the file and add the configuration for our job to be scheduled.
13 | 
14 | * The first five fields are used to specify the exact schedule to run the task. The sixth field is the command to run. 
15 | 
16 | <b>NOTE:</b> Do not use sudo with crontab command, or you will find that the job will be scheduled for the root user. 
17 | 
18 | * Let us see how the schedule works and see the meaning of the first five columns in the crontab. Here is an example,
19 | 
20 | 
21 | ![Screenshot (150)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/00a47245-eafd-484b-82e9-dc653370110f)
22 | 
23 | 
24 | * A star in these fields indicates any value.
25 | 
26 | * If you want to run your job every 5 mins, you can configure that using step values with a slash. Here is how,
27 | 
28 | ```
29 | */2 * * * *
30 | ```
31 | Same can be used for other options as well.
32 | 
33 | * To list all the jobs scheduled in cron, 
34 | 
35 | ```
36 | crontab -l
37 | ```
38 | 
39 | * To check if the job was successfully run is to inspect the logfile /var/log/syslog. 
40 | 


--------------------------------------------------------------------------------
/01 - Linux/Security and File Permissions/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/01 - Linux/Service Management with SYSTEMD/01 - Creating a SYSTEMD Service/README.md:
--------------------------------------------------------------------------------
 1 | * To run a command( application or a script ) in the background, we have to define it as a service. For this we create a service unit file. 
 2 | 
 3 | * This unit file needs to be created under /etc/systemd/system directory.
 4 | 
 5 | * Example,
 6 | 
 7 | ![Screenshot (154)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/80fb692f-28e4-40c0-bfd7-50471be5c03a)
 8 | 
 9 | 
10 | * To run this service in the background, use, 
11 | 
12 | ```
13 | sudo systemctl start project-mercury.service
14 | ```
15 | 
16 | * To check it's status,
17 | 
18 | ```
19 | sudo systemctl status project-mercury.service
20 | ```
21 | 
22 | * To stop the service,
23 | 
24 | ```
25 | sudo systemctl stop project-mercury.service
26 | ```
27 | 
28 | * To allow the above service to be enabled during boot, add another section called install. 
29 | 
30 | * Here is a complete example,
31 | 
32 | ![Screenshot (156)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/4971eabe-f4b0-462c-ba06-39d56c936a3d)
33 | 
34 | * For the system to detect the changes, use the command,
35 | 
36 | ```
37 | sudo systemctl deamon-reload 
38 | ```
39 | 
40 | then,
41 | 
42 | ```
43 | sudo systemctl start project-mercury.service
44 | ```
45 | 


--------------------------------------------------------------------------------
/01 - Linux/Service Management with SYSTEMD/02 - SYSTEMD Tools/README.md:
--------------------------------------------------------------------------------
 1 | * Let us now look at the tools for managing services working with SYSTEMD targets, logging, and getting information about the overall state of the system. 
 2 | 
 3 | * The two major tools are: systemctl and journalctl. 
 4 | 
 5 | # systemctl #
 6 | 
 7 | * <b>sysytemctl:</b> The main command used to manage services on a SYSTEMD-managed server. It can be used to manage services such as start, restart, stop, reload, enable or disable services to start during the system boot. 
 8 | 
 9 | * Let us look at some systemctl commands.
10 | 
11 |    1. To start a service, 
12 |    ```
13 |    systemctl start docker
14 |    ```
15 |    2. To stop,
16 |    ```
17 |    systemctl stop docker
18 |    ```
19 |    3. To restart,
20 |    ```
21 |    systemctl restart docker
22 |    ```
23 |    4. To reload the service without interrupting normal functionality,
24 |    ```
25 |    systemctl reload docker 
26 |    ```
27 |    5. To enable a service and make it persistent across reboot,
28 |    ```
29 |    systemctl enable docker
30 |    ```
31 |    6. To disable the service at boot,
32 |    ```
33 |    systemctl disable docker
34 |    ```
35 |    7. To get information about the state of service,
36 |    ```
37 |    systemctl status docker
38 |    ```
39 |    8. After making changes to a service unit file, run this command,
40 |    ```
41 |    systemctl deamon-reload 
42 |    ```
43 |    9. To make changes to a service,
44 |    ```
45 |    systemctl edit <service_unit_file_> --full 
46 |    ```
47 |    A text editor will open. Units edited this way apply the changes immidiately without runnung the systemctl daemon-reload.
48 |    10. To see current run-level or the target, 
49 |    ```
50 |    systemctl get-default
51 |    ```
52 |    11. To change the target,
53 |    ```
54 |    systemctl get-default <new_target>
55 |    ```
56 |    12. To list all the units SYSTEMD has loaded or attempted to load,
57 |    ```
58 |    systemctl list-units --all 
59 |    ```
60 |    13. To see information about the active units only,
61 |    ```
62 |    systemctl list-units
63 |    ```
64 |    
65 | # journalctl #
66 |    
67 | * <b>journalctl:</b> This command can query the contents of the SYSTEMD logging system called journal and is a convenient troubleshooting tool to figure out issues such as service failures. 
68 |    
69 | * journalctl is useful when troubleshooting issues with SYSTEMD units as it checks the journal or log entries from all parts of the system. 
70 | 
71 | * 'journalctl' without any flags prints all the log entries from the oldest entry to the newest. 
72 | 
73 | * To see the logs from the current boot, 
74 | 
75 | ```
76 | journalctl -b
77 | ```
78 | 
79 | * To see the log entries for a specific unit, 
80 | 
81 | ```
82 | journalctl -u <name_of_unit>
83 | ```
84 | 


--------------------------------------------------------------------------------
/01 - Linux/Service Management with SYSTEMD/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/01 - Introduction/01 - Creating your first shell script/README.md:
--------------------------------------------------------------------------------
 1 | * Before starting to develop your script, it is important to have a clear idea on what you are developing it for. You should note down all the required tasks in a sequence.
 2 | 
 3 | * To create a shell script to perform all of these tasks, we create a file and we move all the commands to this file in the order that we want them to be executed. 
 4 | 
 5 | * Extension .sh indicates that it is a shell script. 
 6 | 
 7 | * That is the simplest form of creating a shell script. 
 8 | 
 9 | * We can now execute the shell script using the bash command. When it is executed, it runs each line in the script one after the otheruntil all lines are completed.
10 | 
11 | * There are other ways to execute a shell script. We can also configure a shell script to run like a command as an executable. Using this method, we need to configure it as a command.
12 | 
13 | * To add our script as a command, append the path to the directory containing the script to the end of the path variable. Example, 
14 | 
15 | ```
16 | echo PATH=$PATH:/home/naved
17 | ```
18 | 
19 | * For a shell script to work, we must set the correct permissions to the file, else it will show a permission denied error. The execute bit needs to be set for the file to be considered as an executable. 
20 | 
21 | * We can add that using the chmod command and make it executable. Example,
22 | 
23 | ```
24 | chmod +x /home/naved/run.sh
25 | ```
26 | 
27 | 
28 | 
29 | ## Best Practices ##
30 | 
31 | * Give your script a name that makes sense.
32 | 
33 | * If you want to make your script executable, to be run like a command, then leave out the .sh extension. 
34 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/01 - Introduction/02 - Variables/README.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | mission_name=lunar-mission
 3 | mkdir $mission_name
 4 | 
 5 | rocket-add $mission_name
 6 | 
 7 | rocket-start-power $mission_name
 8 | rocket-internal-power $mission_name
 9 | rocket-crew-ready $mission_name
10 | rocket-start-sequence $mission_name
11 | rocket-start-engine $mission_name
12 | rocket-lift-off $mission_name
13 | 
14 | rocket-status $mission_name
15 | ```
16 | 
17 | * Note, that a variable name may only contain alphanumeric or underscores. Also, it is case-sensitive. 
18 | 
19 | * We can alo use variables to store the result of another command. Example, 
20 | 
21 | ```
22 | mission_name=lunar-mission
23 | mkdir $mission_name
24 | 
25 | rocket-add $mission_name
26 | 
27 | rocket-start-power $mission_name
28 | rocket-internal-power $mission_name
29 | rocket-crew-ready $mission_name
30 | rocket-start-sequence $mission_name
31 | rocket-start-engine $mission_name
32 | rocket-lift-off $mission_name
33 | 
34 | rocket_status=$(rocket-status $mission_name)
35 | echo "Status of launch: $rocket_status"
36 | ```
37 | 
38 | 
39 | 
40 | ## Best Practices ##
41 | 
42 | * Use lower case to declare the variables. And, underscores too. 
43 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/01 - Introduction/03 - Command Line Arguments/README.md:
--------------------------------------------------------------------------------
 1 | * Suppose we want to use our script for a different mission by changing the variable in it. This is not very convenient.
 2 | 
 3 | * What if we could specify that variable in the command line itself when reusing our script. So, how do we do that?
 4 | 
 5 | * Here is an example,
 6 | 
 7 | ![Screenshot (167)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/f9d34425-4f10-42b3-94b6-ed387af49253)
 8 | 
 9 | 
10 | 
11 | ## Best Practices ##
12 | 
13 | * Design your script to be re-usable.
14 | 
15 | * Script should not require to be edited before running.
16 | 
17 | * Use command line arguments to pass inputs.
18 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/01 - Introduction/04 - Read Inputs/README.md:
--------------------------------------------------------------------------------
1 | * Earlier we learned one way of passing the input, by command line arguments. But, what if we want to prompt the user for a mission name when the script starts instead of passing in the mission name as a command line arguments. 
2 | 
3 | * For this we use the read statement. Use the read command followed by the variable name into which the value is to be stored. 
4 | 
5 | * Here is an example,
6 | 
7 | ![Screenshot (169)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/08eaea21-7035-4f0e-8888-cf4fa0d1a527)
8 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/01 - Introduction/05 - Arithmetic Operations/README.md:
--------------------------------------------------------------------------------
 1 | * There are different ways of performing arithmetic operations in shell. 
 2 | 
 3 | * One is using the expression command, run as expr. Example,
 4 | 
 5 | ```
 6 | expr 2 + 9
 7 | ```
 8 | Output,
 9 | ```
10 | 11
11 | ```
12 | <b>NOTE:</b> The operator and the values must be separated by a space. 
13 | 
14 | Similarly, we can do other mathematical operations like subtraction, multiplication and division. While doing multiplication, we must escape the star symbol with a backslash, because star is a reserved character in shell. Example,
15 | 
16 | ```
17 | expr 2 \* 9
18 | ```
19 | Output,
20 | ```
21 | 18
22 | ```
23 | 
24 | This method can also be done using varaiable substitution. Example,
25 | 
26 | ![Screenshot (170)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/cb3bbefd-631d-4c2d-929b-eddacac4df23)
27 | 
28 | 
29 | 
30 | * Another way to perform arithematic operations in bash is to use double parentheses. Example,
31 | 
32 | ![Screenshot (171)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/b202b710-ff2b-42ae-9c55-1d9ee58f72ad)
33 | 
34 | 
35 | 
36 | * Both of these above methods only return decimal output, not floating-point numbers. For this we can use the 'bc' utility. Example,
37 | 
38 | ![Screenshot (172)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/da09b562-6759-4bd5-9c36-3df5850da3b6)
39 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/01 - Introduction/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/02 - Flow Control/01 - Conditional Logic/README.md:
--------------------------------------------------------------------------------
 1 | * When we want our script to behave differently based on a condition, we use conditional logic. 
 2 | 
 3 | * For this we use 'if' statement, after that we have the 'then' statement and then the block is closed with the 'fi' statement. 
 4 | 
 5 | * The condition of an if statement is encapsulated under a pair of square brackets. 
 6 | 
 7 | * We can also add an else if statement within a block, but it is called 'elif'. Finally we can add an else block at the end that will be run if none of the above conditions are met.
 8 | 
 9 | * Example,
10 | 
11 | ![Screenshot (181)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/cb3aeec1-e9b6-41ab-a099-ca94cd08e27b)
12 | 
13 | 
14 | 
15 | ## Comparison statements ##
16 | 
17 | * They should be within square brackets, and there should be atleast one between the brackets and your statement, as well as the operator and the values on either side. 
18 | 
19 | * The equal operator is only to be used to compare strings. Here is a list of other comparison operators.
20 | 
21 | ![Screenshot (182)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/25499db4-7921-40dc-a8fb-af049876a9b8)
22 | 
23 | * There is another way of specifying a conditional operation and that's using double square brackets. These work similar to the single pair of squrae brackets, except that it is an enhanced version and support additional operations. Here is the list,
24 | 
25 | ![Screenshot (183)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/54bc2ae6-1e02-4bbb-8aa8-59e1b4d51555)
26 | 
27 | 
28 | 
29 | ## AND and OR operators ##
30 | 
31 | * Suppose you have two conditions and you want to check if both of them are correct, then use the AND(&&) operator. 
32 | 
33 | * To check if either one is true, use the OR(||) operator. 
34 | 
35 | * We can use both single square bracket format and double square bracket format. Here is how.
36 | 
37 | ![Screenshot (184)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/39a7b08d-9683-4787-999f-29268291d48b)
38 | 
39 | 
40 | 
41 | * There are some file-level operators as well. Here is the list.
42 | 
43 | ![Screenshot (185)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/cccbae00-942b-4e65-8442-cbc4787a1260)
44 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/02 - Flow Control/02 - For loop/README.md:
--------------------------------------------------------------------------------
 1 | * If you ever have to run the same command multiple times, then use for loop. 
 2 | 
 3 | * Here is an example.
 4 | 
 5 | ![Screenshot (177)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/8023a07c-2e60-40a2-bd25-1512dd6e7f75)
 6 | 
 7 | * We can store all the mission names in a file instead of hard-coding it. Here is an example.
 8 | 
 9 | ![Screenshot (178)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/023488e7-db6a-4e04-adab-39baa9cf1449)
10 | 
11 | * If you need to run your loop a 100 times,  you could specify a range using the sequence expression, using a pair of curly brackets with starting and ending points separated by 2 dots. Example,
12 | 
13 | ![Screenshot (179)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/e3ae94d5-14df-4527-afa8-589c743e3a79)
14 | 
15 | * We can also this above method like this, 
16 | 
17 | ![Screenshot (180)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/bf82947c-eb19-444b-96b5-42d2d1dccb06)
18 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/02 - Flow Control/03 - While Loop/README.md:
--------------------------------------------------------------------------------
 1 | * The while loop takes a conditional statement and the set of commands to execute are within the if block defined by do and done statements.
 2 | 
 3 | * The while loop works just like the for loop, except that it executes the loop as long as the condition is true. 
 4 | 
 5 | * Example,
 6 | 
 7 | ![Screenshot (187)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/f5490b83-9697-4283-867a-c85cbf865408)
 8 | 
 9 | * Another example,
10 | 
11 | ![Screenshot (188)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/a7a5817a-2af7-4db3-b5f2-4a1fc39ac483)
12 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/02 - Flow Control/04 - Case Statements /README.md:
--------------------------------------------------------------------------------
 1 | * Consider the very last example. The if conditional block with a lot of if and else if statements can be written in a better way using case statements. 
 2 | 
 3 | * A case block starts with the case statement and ends with the esac statement. Now on the case statement we specify the value or a variable we would like to check for. 
 4 | 
 5 | * Within the case block we add different cases and the associated code for each case. The value in the variable is compared against each value or pattern specified within the block before the right parenthesis. 
 6 | 
 7 | * If none of it is a match, then it will always match with the star at the end. It is like the else at the end.
 8 | 
 9 | * Each block within the case block, must end with the double semicolon. We can separate the semicolons to a new line. 
10 | 
11 | * Case statememts is like the switch statements in the programming languages. 
12 | 
13 | ![Screenshot (190)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/f807fa61-96da-41d4-af83-45b7236e9312)
14 | 
15 | * Another example,
16 | 
17 | ![Screenshot (191)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/1cc277ff-7f3f-4a2d-8e23-47e50343ae67)
18 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/02 - Flow Control/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/03 - Shebang/01 - Exit Codes/README.md:
--------------------------------------------------------------------------------
 1 | * When we run a command, it is either successful or failed. Apart from the message that we see on our screen, each command also returns an exit code or a return code. 
 2 | 
 3 | * A successful command returns an exit status of zero, and a failed command returns an exit status that is not zero(>1). 
 4 | 
 5 | * Where do we see these exit codes? Exit code of a command is stored in a special built-in variable called dollar question mark. To see the exit code of a command, run,
 6 | 
 7 | ```
 8 | echo $?
 9 | ```
10 | 
11 | <b>NOTE:</b> This gets updated immidiately after a command is run, so the output is only reliable once, right after the command finishes it's execution and before we run any other command, including the echo $ command itself. 
12 | 
13 | * It's a good practice to use exit codes in your script to indicate to the caller or the user of the script, the status of your script. 
14 | 
15 | * If we don't specify any exit status, then the script will always automatically set the exit code to zero. For the script to return non-zero when the script is failed, enter the statement 'exit 1' . 
16 | 
17 | * As a best practice, always make sure your script returns an appropriate exit code.
18 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/03 - Shebang/02 - Functions/README.md:
--------------------------------------------------------------------------------
 1 | * What if we want the same script to follow the same sequences without writing additional scripts? 
 2 | 
 3 | * One way to do that would be to duplicate the entire set of code. Obviously, it's not a neat approach, because our script has duplicates now, the same set of code multiple times. 
 4 | 
 5 | * Second way is to move our code within a function. A function within a shell script is a piece of code or a block of code that performs a particular function that can be reused throughout the script. 
 6 | 
 7 | * From anywhere within the script, to run this block of code, we simply need to call the function by it's name and pass in the argument. It's also called as a function parameter. We can call and pass in the arguments multiple number of times. 
 8 | 
 9 | * Our script now has two major functions. At the top, we have the function definition. And below, we have the main part of the script that calls that function. 
10 | 
11 | <b>NOTE:</b> Function must always be defined first before calling it. 
12 | 
13 | * In functions we need to take care of 'exit' statements. Because if the first script fails, the script will exit. However, we do not want that. We want the script to continue. So, instead of exit statements in functions, we use the 'return' statement. It will print the exit code iof the script as weel as it will not exit the script, it will only exit the function. 
14 | 
15 | * Return statement in shell scripts do not work like thosein programming languages. They are used to return exit status only. You cannot retrieve the return value by assigning the function call to a variable. Instead, we must retrieve the return code using the '$?' built-in variable that retrieves exit codes of previously run command.  
16 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/03 - Shebang/03 - Tips and Tricks/README.md:
--------------------------------------------------------------------------------
 1 | * Once you develop a shell script using VI Editor, you can use the shell-check utility, to analyze and identify bugs and areas of improvements in your script. Run this command to install,
 2 | 
 3 | ```
 4 | apt-get install shellcheck
 5 | ```
 6 | Run this utility with this syntax,
 7 | ```
 8 | shellcheck <name_of_script>
 9 | ```
10 | 
11 | * We can also use PyCharm IDE, VS Code and Atom.
12 | 
13 | * Google's shell scripting style guide. 
14 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/03 - Shebang/README.md:
--------------------------------------------------------------------------------
 1 | * Some expressions we learned earlier may not work in every other shell. If you share your script with others, then you must specify the shell it runs in. That is where Shebang can help.
 2 | 
 3 | * A Shebang statement is a line that you specify at the top of a shell script. It starts with a hash followed by an exclamation mark and then the path to a shell. 
 4 | 
 5 | * A Shebang is used to specify what shell a script must run in. 
 6 | 
 7 | * This way whenever the script is run, it would always run in the bash shell and the end users need not have to specify which shell to run on. 
 8 | 
 9 | * The Shebang instructs the shell to use a particular shell or interpreter for the script. 
10 | 
11 | * One of the best practice while developing a shell script is to always start with a Shebang at the top of your script. 
12 | 
13 | ![Screenshot (193)](https://github.com/NavedtheDev/DevOps-Learnings/assets/98219227/aa1d85a5-4f40-4f3e-85f0-32fd6db27243)
14 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/04 - Styling /README.md:
--------------------------------------------------------------------------------
 1 | * Use # to add a comment. 
 2 | 
 3 | * The 'echo' command has a -e option, with which we can provide a color code. Example,
 4 | 
 5 | ```
 6 | echo -e "\033[0;32mInstalling firewalld...\033[0m"
 7 | ```
 8 | 
 9 | * We can also assign color codes to a variable. Example,
10 | 
11 | ```
12 | GREEN="\033[0;32m"
13 | NC="\033[0m"
14 | 
15 | echo -e "${GREEN}Installing firewalld...${NC}"
16 | ```
17 | 
18 | * We can also create functions for using colors. Example,
19 | 
20 | ```
21 | function print_color() {
22 |     GREEN="\033[0;32m"
23 |     NC="\033[0m"
24 | 
25 | echo -e "${GREEN} $1 ${NC}"
26 | }
27 | 
28 | print_color "Installing firewalld..."
29 | ```
30 | 
31 | * Example of a function to use multiple colors, 
32 | 
33 | ```
34 | function print_color() {
35 | 
36 |     case $1 in 
37 |       "green") COLOR="\033[0;32m" ;;
38 |       "red") COLOR="\033[0;31m" ;;
39 |       "*") COLOR="\033[0m"
40 |     esac
41 | 
42 |     echo -e "${COLOR} $2 ${NC}"
43 | }
44 | 
45 | print_color "green" "Installing firewalld..."
46 | print_color "red" "Failed!"
47 | ```
48 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/05 - Sample Project/README.md:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | #
  3 | # Automate ECommerce Application Deployment
  4 | # Author: Mumshad Mannambeth
  5 | 
  6 | #######################################
  7 | # Print a message in a given color.
  8 | # Arguments:
  9 | #   Color. eg: green, red
 10 | #######################################
 11 | function print_color(){
 12 |   NC='\033[0m' # No Color
 13 | 
 14 |   case $1 in
 15 |     "green") COLOR='\033[0;32m' ;;
 16 |     "red") COLOR='\033[0;31m' ;;
 17 |     "*") COLOR='\033[0m' ;;
 18 |   esac
 19 | 
 20 |   echo -e "${COLOR} $2 ${NC}"
 21 | }
 22 | 
 23 | #######################################
 24 | # Check the status of a given service. If not active exit script
 25 | # Arguments:
 26 | #   Service Name. eg: firewalld, mariadb
 27 | #######################################
 28 | function check_service_status(){
 29 |   service_is_active=$(sudo systemctl is-active $1)
 30 | 
 31 |   if [ $service_is_active = "active" ]
 32 |   then
 33 |     echo "$1 is active and running"
 34 |   else
 35 |     echo "$1 is not active/running"
 36 |     exit 1
 37 |   fi
 38 | }
 39 | 
 40 | #######################################
 41 | # Check the status of a firewalld rule. If not configured exit.
 42 | # Arguments:
 43 | #   Port Number. eg: 3306, 80
 44 | #######################################
 45 | function is_firewalld_rule_configured(){
 46 | 
 47 |   firewalld_ports=$(sudo firewall-cmd --list-all --zone=public | grep ports)
 48 | 
 49 |   if [[ $firewalld_ports == *$1* ]]
 50 |   then
 51 |     echo "FirewallD has port $1 configured"
 52 |   else
 53 |     echo "FirewallD port $1 is not configured"
 54 |     exit 1
 55 |   fi
 56 | }
 57 | 
 58 | #######################################
 59 | # Check if a given item is present in an output
 60 | # Arguments:
 61 | #   1 - Output
 62 | #   2 - Item
 63 | #######################################
 64 | function check_item(){
 65 |   if [[ $1 = *$2* ]]
 66 |   then
 67 |     print_color "green" "Item $2 is present on the web page"
 68 |   else
 69 |     print_color "red" "Item $2 is not present on the web page"
 70 |   fi
 71 | }
 72 | 
 73 | 
 74 | 
 75 | 
 76 | 
 77 | 
 78 | echo "---------------- Setup Database Server ------------------"
 79 | 
 80 | # Install and configure firewalld
 81 | print_color "green" "Installing FirewallD.. "
 82 | sudo yum install -y firewalld
 83 | 
 84 | print_color "green" "Installing FirewallD.. "
 85 | sudo service firewalld start
 86 | sudo systemctl enable firewalld
 87 | 
 88 | # Check FirewallD Service is running
 89 | check_service_status firewalld
 90 | 
 91 | # Install and configure Maria-DB
 92 | print_color "green" "Installing MariaDB Server.."
 93 | sudo yum install -y mariadb-server
 94 | 
 95 | print_color "green" "Starting MariaDB Server.."
 96 | sudo service mariadb start
 97 | sudo systemctl enable mariadb
 98 | 
 99 | # Check FirewallD Service is running
100 | check_service_status mariadb
101 | 
102 | # Configure Firewall rules for Database
103 | print_color "green" "Configuring FirewallD rules for database.."
104 | sudo firewall-cmd --permanent --zone=public --add-port=3306/tcp
105 | sudo firewall-cmd --reload
106 | 
107 | is_firewalld_rule_configured 3306
108 | 
109 | 
110 | # Configuring Database
111 | print_color "green" "Setting up database.."
112 | cat > setup-db.sql <<-EOF
113 |   CREATE DATABASE ecomdb;
114 |   CREATE USER 'ecomuser'@'localhost' IDENTIFIED BY 'ecompassword';
115 |   GRANT ALL PRIVILEGES ON *.* TO 'ecomuser'@'localhost';
116 |   FLUSH PRIVILEGES;
117 | EOF
118 | 
119 | sudo mysql < setup-db.sql
120 | 
121 | # Loading inventory into Database
122 | print_color "green" "Loading inventory data into database"
123 | cat > db-load-script.sql <<-EOF
124 | USE ecomdb;
125 | CREATE TABLE products (id mediumint(8) unsigned NOT NULL auto_increment,Name varchar(255) default NULL,Price varchar(255) default NULL, ImageUrl varchar(255) default NULL,PRIMARY KEY (id)) AUTO_INCREMENT=1;
126 | 
127 | INSERT INTO products (Name,Price,ImageUrl) VALUES ("Laptop","100","c-1.png"),("Drone","200","c-2.png"),("VR","300","c-3.png"),("Tablet","50","c-5.png"),("Watch","90","c-6.png"),("Phone Covers","20","c-7.png"),("Phone","80","c-8.png"),("Laptop","150","c-4.png");
128 | 
129 | EOF
130 | 
131 | sudo mysql < db-load-script.sql
132 | 
133 | mysql_db_results=$(sudo mysql -e "use ecomdb; select * from products;")
134 | 
135 | if [[ $mysql_db_results == *Laptop* ]]
136 | then
137 |   print_color "green" "Inventory data loaded into MySQl"
138 | else
139 |   print_color "green" "Inventory data not loaded into MySQl"
140 |   exit 1
141 | fi
142 | 
143 | 
144 | print_color "green" "---------------- Setup Database Server - Finished ------------------"
145 | 
146 | print_color "green" "---------------- Setup Web Server ------------------"
147 | 
148 | # Install web server packages
149 | print_color "green" "Installing Web Server Packages .."
150 | sudo yum install -y httpd php php-mysql
151 | 
152 | # Configure firewalld rules
153 | print_color "green" "Configuring FirewallD rules.."
154 | sudo firewall-cmd --permanent --zone=public --add-port=80/tcp
155 | sudo firewall-cmd --reload
156 | 
157 | is_firewalld_rule_configured 80
158 | 
159 | # Update index.php
160 | sudo sed -i 's/index.html/index.php/g' /etc/httpd/conf/httpd.conf
161 | 
162 | # Start httpd service
163 | print_color "green" "Start httpd service.."
164 | sudo service httpd start
165 | sudo systemctl enable httpd
166 | 
167 | # Check FirewallD Service is running
168 | check_service_status httpd
169 | 
170 | # Download code
171 | print_color "green" "Install GIT.."
172 | sudo yum install -y git
173 | sudo git clone https://github.com/kodekloudhub/learning-app-ecommerce.git /var/www/html/
174 | 
175 | print_color "green" "Updating index.php.."
176 | sudo sed -i 's/172.20.1.101/localhost/g' /var/www/html/index.php
177 | 
178 | print_color "green" "---------------- Setup Web Server - Finished ------------------"
179 | 
180 | # Test Script
181 | web_page=$(curl http://localhost)
182 | 
183 | for item in Laptop Drone VR Watch Phone
184 | do
185 |   check_item "$web_page" $item
186 | done
187 | 


--------------------------------------------------------------------------------
/02 - Shell Scripting/README.md:
--------------------------------------------------------------------------------
1 | * Shell Scripts in Linux are an easy to use time-saving solution for automating repetitive or complex set of tasks.
2 | 


--------------------------------------------------------------------------------
/03 - Basic Networking /README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/04 - YAML/01 - What is YAML /README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/04 - YAML/02 - Data serialization and deserialization/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/04 - YAML/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/05 - GIT/01 - Introduction/01 - Local and Remote Repositories/README.md:
--------------------------------------------------------------------------------
 1 | * Git has two repository types, <b>local</b> and <b>remote</b>.
 2 | 
 3 | ## Local Repository ##
 4 | 
 5 | * It is on your own machine, so you have direct access to it. 
 6 | 
 7 | * It consists of three stages. 
 8 | 
 9 |    1. Working area: are all your active changes. Git doesn't know what to do with them yet, it just know that these files contain some updates. 
10 |    2. Staging area: contains new changes that will soon be committed.
11 |    3. Committed files.
12 | 
13 | * The files that should be included in the commit are first added to the staging area. A commit gets created when a developer actually commits those files. 
14 | 
15 | ## Remote Repository ##
16 | 
17 | * It is usually a centralized server and is entirely optional. 
18 | 
19 | * We can save the changes that we made locally on this remote server. 
20 | 
21 | * It is very useful when you want to have a backup of your data.
22 | 
23 | * Teammates can initialize their own local repository, on their own computers, and simply pull the data from the remote repository in order to start working on your project. 
24 | 
25 | * When a team member has made changes, they can push these changes to the remote repository. 
26 | 
27 | <b>NOTE: </b> In order to keep your local and remote repository in sync, you can then pull these changes from the remote repository into your local repository. 
28 | 


--------------------------------------------------------------------------------
/05 - GIT/01 - Introduction/02 - Initialize a GIT Repository/README.md:
--------------------------------------------------------------------------------
 1 | * Let's initialize a local GIT repository. We can do so with the following command,
 2 | 
 3 | ```
 4 | git init
 5 | ```
 6 | 
 7 | * To list all the contents of the folder including hidden ones, use
 8 | 
 9 | ```
10 | ls -a 
11 | ```
12 | You will see that a .git folder has been created. 
13 | 
14 | * Suppose you created a file and added some content to it. Now you want to check the status of GIT, use
15 | 
16 | ```
17 | git status
18 | ```
19 | 
20 | * Storing changes in a local GIT repository is called committing. With every commit, we save the current state of the repository.
21 | 
22 | * Till now we haven't told GIT what do we want to do with our file. So they are still untracked. 
23 | 
24 | * We need to tell GIT that we want to add it to our local repository. Before we can commit a file, we first have to put it in the staging area. We can do so with the command,
25 | 
26 | ```
27 | git add <file_name>
28 | ```
29 | 
30 | * Now it's time to commit our change. But before that we must configure the git user who will be the owner of the commit. We do so using the following commands,
31 | 
32 | ```
33 | git config user.email <your_email>
34 | 
35 | git config user.name <your_name>
36 | ```
37 | 
38 | * Now, In order to commit the files that are currently in the staging area, use, 
39 | 
40 | ```
41 | git commit -m " "
42 | ```
43 | Here, -m is a flag for a message. <br>
44 | A commit records the change of a repository compared to its previous state.
45 | 
46 | 
47 | 
48 | ## .gitignore ##
49 | 
50 | * If we want a file not to be tracked by git, then we add that file inside the .gitignore file.
51 | 


--------------------------------------------------------------------------------
/05 - GIT/01 - Introduction/03 - GIT log/README.md:
--------------------------------------------------------------------------------
 1 | * We can see the commits that were made to the project in our terminal. Use the command,
 2 | 
 3 | ```
 4 | git log
 5 | ```
 6 | 
 7 | * It shows the information that we need to know about all the commits, such as the commit hash, the author name, the date of the commit, and the commit message. 
 8 | 
 9 | * Use this command to get the output in one line,
10 | 
11 | ```
12 | git log --oneline
13 | ```
14 | 
15 | * Use this command to get the name of the file,
16 | 
17 | ```
18 | git log --name-only
19 | ```
20 | 
21 | * To get the specified number of recent outputs,
22 | 
23 | ```
24 | git log -n 1
25 | ```
26 | 


--------------------------------------------------------------------------------
/05 - GIT/01 - Introduction/README.md:
--------------------------------------------------------------------------------
 1 | * Git is an open source distributed version control system. 
 2 | 
 3 | * Git is a content tracker, it stores all our code changes.
 4 | 
 5 | * A version control system means that we can go back in time and work with a different version of our code base since Git stored it all and work with branches.
 6 | 
 7 | * Distributed means that it has a remote repository, which is stored in a server and a local repository, which is stored on the computer of every developer working on a project. Every developer has access to the full copy of the code base.
 8 | 
 9 | * With Git, we can go back in time without losing any new changes. 
10 | 
11 | * When we have made changes, we can save the current state of the website. This way we always have all our versions stored, which makes it easy to go back in time. 
12 | 
13 | * We have access to the project's full history, the changes we made, who made the changes, if we are working on a project with multiple team members, and when it was made. 
14 | 
15 | * Use this command to get basic git commands,
16 | 
17 | ```
18 | git help
19 | ```
20 | 
21 | * Use this command to get help on each command,
22 | 
23 | ```
24 | git help <command>
25 | ```
26 | 


--------------------------------------------------------------------------------
/05 - GIT/02 - Branches/01 - What is Branch?/README.md:
--------------------------------------------------------------------------------
 1 | * A branch is a pointer to the last commit. 
 2 | 
 3 | ## Some useful commands when working with branches ##
 4 | 
 5 | * To create a new branch,
 6 | 
 7 | ```
 8 | git branch <branch_name>
 9 | ```
10 | 
11 | * To switch to a branch,
12 | 
13 | ```
14 | git checkout <branch_name>
15 | ```
16 | 
17 | * To create a new branch and immidiately switch to this new branch,
18 | 
19 | ```
20 | git checkout -b <branch_name>
21 | ```
22 | 
23 | * To delete a branch,
24 | 
25 | ```
26 | git branch -d <branch_name>
27 | ```
28 | 
29 | * To list all the branches,
30 | 
31 | ```
32 | git branch
33 | ```
34 | 
35 | 
36 | 
37 | # HEAD #
38 | 
39 | * A HEAD is where we are right now in the git repository. The HEAD points to the last commit in the branch that you are currently on. 
40 | 
41 | * When you switch branches, the HEAD moves with you. 
42 | 


--------------------------------------------------------------------------------
/05 - GIT/02 - Branches/02 - Merging branches/README.md:
--------------------------------------------------------------------------------
 1 | * We can merge a branch to the main branch with the command,
 2 | 
 3 | ```
 4 | git merge <branch_name>
 5 | ```
 6 | 
 7 | * This command recieves the name of the branch that we want to merge into our current branch. 
 8 | 
 9 | * There are two types of merges that GIT can perform, a fast-forward merge and a no-fast-forward merge. 
10 | 
11 | * A fast-forward merge can happen when the current branch has no extra commits compared to the branch that we're merging. 
12 | 
13 | * We will first try to perform the easiest option, the fast-forward. This type of merge doesn't create a new commit, but rather merges the commits on the branch that we are merging right into the current branch. But its a very rare case. 
14 | 
15 | * With a no-fast-forward merge, Git creates a new merging commit on the active branch.
16 | 


--------------------------------------------------------------------------------
/05 - GIT/02 - Branches/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/05 - GIT/03 - Initialize Remote Repositories/01 - Initialize Remote Repositories/README.md:
--------------------------------------------------------------------------------
 1 | * A connection string is a URL that we can use in order to let git know where the remote repository is located. 
 2 | 
 3 | * We can add the remote repository to our local project with the git remote add command. 
 4 | 
 5 | * We want to add a remote repository and give it the alias origin to make sure that we always know which remote repository we are pushing to without having to memorize the entire connection string. In order to do so, use the command,
 6 | 
 7 | ```
 8 | git remote add origin <connection_string>
 9 | ```
10 | 
11 | * To list all the remote repositories use,
12 | 
13 | ```
14 | git remote -v
15 | ```
16 | 


--------------------------------------------------------------------------------
/05 - GIT/03 - Initialize Remote Repositories/02 - Pushing to remote repositories/README.md:
--------------------------------------------------------------------------------
1 | * In order to keep our local and remote repo in sync, we have to push the data from our local repo to the remote repo. We do so using,
2 | 
3 | ```
4 | git push <alias_of_remote_repo> <current_branch_we are_on>
5 | ```
6 | alias of remote repo is 'origin'
7 | 


--------------------------------------------------------------------------------
/05 - GIT/03 - Initialize Remote Repositories/03 - Cloning remote repositories/README.md:
--------------------------------------------------------------------------------
1 | * Use this command to get a clone of the remote repository into your own local machine,
2 | 
3 | ```
4 | git clone <ssh_link>
5 | ```
6 | 


--------------------------------------------------------------------------------
/05 - GIT/03 - Initialize Remote Repositories/04 - Fetching and Pulling/README.md:
--------------------------------------------------------------------------------
 1 | * We just updated the origin master branch by merging our branch into it. Our local repository(the cloned one) is not automatically aware of these changes. So we have to get these changes into our local repository. 
 2 | 
 3 | * We do so using,
 4 | 
 5 | ```
 6 | git fetch origin master
 7 | ```
 8 | in order to update the origin master branch in our local repo. 
 9 | 
10 | * Now that we fetched the origin master, we can update our local master branch to point to the latest changes made on origin master. 
11 | 
12 | * To do that, we can merge origin master into the local master branch. 
13 | 
14 | ```
15 | git merge origin/master
16 | ```
17 | 
18 | * We now have all the latest changes avaialble locally. 
19 | 
20 | * Instead of individually fetching and then merging, we can also pull the origin master branch with this command,
21 | 
22 | ```
23 | git pull origin master
24 | ```
25 | 
26 | * git pull is actually two commands in one; git fetch and git merge. By typing the above command, we can fetch and merge the remote changes directly into our local master branch. 
27 | 


--------------------------------------------------------------------------------
/05 - GIT/03 - Initialize Remote Repositories/05 - Pull Requests/README.md:
--------------------------------------------------------------------------------
 1 | * Till now we saw that we can merge branches directly into the main branch. But when we work in a team, we do not follow that way. 
 2 | 
 3 | * We will push our changes to a separate branch other than main branch using the git push command. 
 4 | 
 5 | * After pushing to that branch, check the GitHub repo and you will see a pop-up in which option of 'Pull request' will be present. In order to merge our branch to the main branch, we need to open a Pull request. We can do that by clicking on the Pull request button.
 6 | 
 7 | * After clickning on that button you will see the changes that were made on that branch compared to the main branch and a button to create a pull request. We can add additional information about the changes that we have made.
 8 | 
 9 | * When a pull request is opened other team members can see the chnages that you have made and comments on them. 
10 | 
11 | * To avoid that anyone can merge the changes into the main branch, you need to have the right privileges to do so. 
12 |  
13 | * If you are working in a team, then you may need to ask other team members to merge your PR.
14 | 


--------------------------------------------------------------------------------
/05 - GIT/03 - Initialize Remote Repositories/06 - Merge Conflicts/README.md:
--------------------------------------------------------------------------------
1 | * Suppose two people X and Y are trying to contribute to the same in a project.
2 | 
3 | * But X was a bit quicker and merged the changes into ther main. Now Y wants to merge his changes into the main branch. But the main branch contains changes compared to the Y branch in the file that we are currently trying to merge. Now git doesn't know which one to keep. We just ended up ina merge conflict. 
4 | 
5 | * There are several ways to resolve this conflict. 
6 | 
7 | * Main branch will then contain a combination of X's and Y's changes.  
8 | 


--------------------------------------------------------------------------------
/05 - GIT/03 - Initialize Remote Repositories/07 - Fork/README.md:
--------------------------------------------------------------------------------
1 | * So far, our example were limited to a small team of individuals. All members of the remote git repository had the right permissions to push their changes. However, this is not always the case. 
2 | 
3 | * So, how do you create a oull request if you are not part of the git project. The answer is to first fork the project. 
4 | 
5 | * After forking the project, you can add your changes to a branch on the forked copy and send a PR to the original project to merge your changes. 
6 | 
7 | * When you fork a project, you create a copy of the original project for you. You can do whatever you want with it. 
8 | 


--------------------------------------------------------------------------------
/05 - GIT/03 - Initialize Remote Repositories/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/05 - GIT/04 - Rebasing/01 - Rebasing /README.md:
--------------------------------------------------------------------------------
 1 | * Imagine you're working on a feature branch called "feature/branch" based on the "main" branch in a collaborative project. While you were developing your feature, other team members made several commits and merged them into the "main" branch. Now, you want to incorporate those changes into your feature branch before completing your work.
 2 | 
 3 | * One way to do that is to merge the main branch into your own branch. This creates a new merge commit to merge these changes into your own branch. But there is another way.
 4 | 
 5 | * Instead of merging the "main" branch into your feature branch, you can use rebasing to integrate the latest changes into your branch. When we are rebasing branches, we are  basically putting one branch on top of another branch. 
 6 | 
 7 | * Here is the command to rebase your branch on top of the main branch,
 8 | 
 9 | ```
10 | git rebase main
11 | ```
12 | 
13 | * Now your branch contains all the changes that were made to the main branch. 
14 | 
15 | * By rebasing your feature branch onto the "main" branch, you create a linear commit history without the extra merge commits that would result from a regular merge. This can provide a cleaner and more organized commit history.
16 | 
17 | * When we rebase the branches, we modify the Git history. It can be annoying when you are working with a team. It is not clear when certain branches got rebased since there is no merge commit. 
18 | 
19 | * However, it's important to note that if you have already shared your feature branch with other team members or pushed it to a remote repository, it's generally not recommended to rebase it.
20 | 


--------------------------------------------------------------------------------
/05 - GIT/04 - Rebasing/02 - Interactive Rebasing/README.md:
--------------------------------------------------------------------------------
 1 | * Interactive rebasing is a feature in Git that allows you to modify, reorder, squash, or edit commits during the rebase process. It gives you more control over the commit history by providing an interactive interface where you can selectively apply changes to individual commits.
 2 | 
 3 | * Interactive rebasing allows you to refine the commit history, combine related changes, and ensure a clean and organized history before merging into the main codebase.
 4 | 
 5 | * We can change the history of a git branch with an interactive rebase. We do so using the -i flag in the git rebase command. Also, we have to specify which commits we want to update. Suppose want to modify the first four commits. So we will use the command,
 6 | 
 7 | ```
 8 | git rebase -i HEAD~4
 9 | ```
10 | 
11 | * Through the above command we are telling git that we want to interactively rebase the last four commits. 
12 | 
13 | * Use the squash command to meld the three commits into the first commit. Change their command from pick to squash. 
14 | 
15 | * We have successfully rebased the three extra commits and created a new commit that contains the changes of all four commits combined. 
16 | 


--------------------------------------------------------------------------------
/05 - GIT/04 - Rebasing/03 - Cherry Picking/README.md:
--------------------------------------------------------------------------------
 1 | * It can happen that one branch has a commit with a certain change that you like to apply to another branch, but you don't want all the changes that were made to that branch. 
 2 | 
 3 | * In this case, we can cherry pick that certain commit in order to create a copy of that commit onto our own branch. 
 4 | 
 5 | * Use the command,
 6 | 
 7 | ```
 8 | git cherry-pick <hash_ID_of_the_commit>
 9 | ```
10 | 
11 | * We now have the copy of that commit on our branch.
12 | 


--------------------------------------------------------------------------------
/05 - GIT/04 - Rebasing/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/05 - GIT/05 - Resetting and Reverting/01 - Resetting and Reverting/README.md:
--------------------------------------------------------------------------------
 1 | * It can happen that we have committed certain changes that we actually didin't want to commit. In that case, we have several options to undo that commit.  
 2 | * First option is to revert it. The git revert command creates a new commit, which literally reverse all the changes that were made on the commit that we specified. 
 3 | 
 4 | ```
 5 | git revert <hash_ID>
 6 | ```
 7 | 
 8 | * Reveret command is useful if you want to undo changes and keep those changes in your Git history. 
 9 | 
10 | * Another way of undoing changes is with the git reset command. There are two ways to reset the commit in order to undo it, either with the --soft flag, in which case, we still want to keep all the changes that were made, or with the hard flag in order to lose all the changes that were made on that commit. 
11 | 
12 | * The reset command also recieves the amount of commits that we want to reset. 
13 | 
14 | ```
15 | git reset --soft HEAD~1
16 | ```
17 | 
18 | * Since we used the soft flag, we still have access to the changes that were made by that commit. We can see that using git status. 
19 | 
20 | * If we use the hard flag, the commit will be resetwithout saving all those changes. 
21 | 
22 | ```
23 | git reset --hard HEAD~1
24 | ```
25 | 


--------------------------------------------------------------------------------
/05 - GIT/05 - Resetting and Reverting/02 - Stashing/README.md:
--------------------------------------------------------------------------------
 1 | *  Stashing is a feature that allows you to save your local modifications in a temporary storage area, known as the "stash." It's useful when you're working on a specific branch but need to switch to a different branch or perform some other operation without committing your changes. 
 2 | 
 3 | * We can stash all changes in the working area with the command,
 4 | 
 5 | ```
 6 | git stash
 7 | ```
 8 | 
 9 | * To get the changes back to the working area,
10 | 
11 | ```
12 | git stash pop
13 | ```
14 | 
15 | * The stash can be seen as a pile of books. We can keep on pushing to the stash, and the changes will simply pile up. 
16 | 
17 | * To see all the stashes that are currently on the stash, 
18 | 
19 | ```
20 | git stash list
21 | ```
22 | 
23 | * To see the contents of a certain stash, 
24 | 
25 | ```
26 | git stash show stash@{1}
27 | ```
28 | 
29 | * To pop a specific stash,
30 | 
31 | ```
32 | git stash pop stash@{1}
33 | ```
34 | 


--------------------------------------------------------------------------------
/05 - GIT/05 - Resetting and Reverting/03 - Reflog/README.md:
--------------------------------------------------------------------------------
 1 | * Suppose you thought that the commit you just made is of no use, and you hard resetted it. But then you realized that the commit you just hard resetted was actually of importance. No need to panic.
 2 | 
 3 | * The git reflog command shows us all the actions that have been taken on our repo. 
 4 | 
 5 | ```
 6 | git reflog
 7 | ```
 8 | 
 9 | * You can easily undo your mistake by restting HEAD based on the information that reflog gives us. 
10 | 
11 | * To point HEAD back to where it was, 
12 | 
13 | ```
14 | git reset --hard HEAD_ID_obtained_from_the_reflog_command
15 | ```
16 | Example,
17 | ```
18 | git reflog --hard 8ad5
19 | ```
20 | Now our repo has been reset to its previous state. 
21 | 
22 | 
23 | 
24 | ### git log vs. gi reflog ##
25 | 
26 | * git log only shows information only about the commits and not about the state of the repository like git reflog does. 
27 | 


--------------------------------------------------------------------------------
/05 - GIT/05 - Resetting and Reverting/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/05 - GIT/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/06 - Cloud/01 - AWS/Day 1/README.md:
--------------------------------------------------------------------------------
 1 | # What is Cloud ##
 2 | 
 3 | * Cloud computing refers to the delivery of computing services, including storage, processing power, networking, databases, analytics, and more, over the internet, commonly referred to as "the cloud." <br> 
 4 | * Instead of owning and maintaining physical hardware or servers, users can access and use computing resources on a pay-as-you-go basis from a cloud service provider.
 5 | 
 6 | # Public cloud Vs. Private cloud 
 7 | 
 8 | * <b> Public Cloud: </b> A cloud computing model where resources and services are provided over the internet by third-party providers, shared among multiple users on a pay-as-you-go basis.
 9 | 
10 | * <b> Private Cloud: </b> A cloud computing model where computing resources are used exclusively by a single organization, either on-premises or provided by a dedicated third-party, offering more control and customization.
11 | 
12 | # Create an AWS account #
13 | 
14 | * Create an AWS account by watching this video.
15 | 
16 | https://youtu.be/d4aJUubHWTk?si=-cFaqGVK97UJo4KY
17 | 


--------------------------------------------------------------------------------
/06 - Cloud/01 - AWS/Day 2/README.md:
--------------------------------------------------------------------------------
 1 | # IAM #
 2 | 
 3 | * AWS Identity and Access Management (IAM) is a service that enables secure management of access to AWS resources.
 4 | 
 5 | * It allows users to define and control permissions, create and manage users, groups, and roles, enhancing security and facilitating fine-grained access control within the AWS environment.
 6 | 
 7 | It is mainly for two purposes: <b>Authentication</b> and <b>Authorization</b>.
 8 | 
 9 | 
10 | 
11 | We have 4 main terms here:
12 | 
13 | 1. <b>Users:</b> IAM users are individual entities with unique credentials within an AWS account. They are assigned policies defining their permissions, allowing them to interact with AWS resources.
14 | 
15 | 2. <b>Policies:</b> IAM policies are documents defining permissions and access control rules. They specify what actions are allowed or denied on AWS resources for users, groups, or roles. Policies are attached to these entities to regulate their access, providing a granular and secure way to manage permissions within the AWS environment. If we attach no policies, the user will not be able to do anything except logging in.
16 | 
17 | 3. <b>Groups:</b> A group is a collection of IAM users. Instead of attaching policies directly to individual users, you can create a group, attach policies to the group, and then add users to the group. This helps in managing and assigning permissions at scale, making it more efficient to handle access control.
18 | 
19 | 4. <b>Roles:</b> A role is another entity that you can create and manage. However, unlike groups or users, roles are not associated with a specific AWS identity, such as a user or a group. Instead, roles define a set of permissions for making AWS service requests and are assumed by AWS resources or users outside of your AWS account.
20 | 
21 | ## Let us create an AWS IAM user ##
22 | 
23 | Checkout my blog where I have explained it in detail.
24 | 
25 | Here is the link: https://navedwrites.hashnode.dev/aws-identity-and-access-management
26 | 


--------------------------------------------------------------------------------
/06 - Cloud/01 - AWS/Day 3/README.md:
--------------------------------------------------------------------------------
1 | Checkout this amazing blog written by me on AWS EC2: https://navedwrites.hashnode.dev/aws-elastic-cloud-compute
2 | 


--------------------------------------------------------------------------------
/06 - Cloud/01 - AWS/Day 4/README.md:
--------------------------------------------------------------------------------
1 | # VPC #
2 | 
3 | Checkout my article: https://navedwrites.hashnode.dev/aws-virtual-private-cloud-vpc
4 | 


--------------------------------------------------------------------------------
/06 - Cloud/01 - AWS/Day 5/README.md:
--------------------------------------------------------------------------------
1 | Checkout my artcile: https://navedwrites.hashnode.dev/security-groups-and-nacls
2 | 


--------------------------------------------------------------------------------
/06 - Cloud/01 - AWS/Day 6/README.md:
--------------------------------------------------------------------------------
1 | # AWS Route 53 #
2 | 
3 | Checkout my article: https://navedwrites.hashnode.dev/aws-route-53
4 | 


--------------------------------------------------------------------------------
/06 - Cloud/01 - AWS/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/06 - Cloud/AWS S3/README.md:
--------------------------------------------------------------------------------
1 | * S3 stands for Simple Storage Service. It provides an infinitely scalable storage solution from AWS. It also offers high availability of data by storing it across multiple devices and availability zones in a region. 
2 | 
3 | * It is an object based storage. 
4 | 
5 | * In S3, data is stored in the form of an S3 bucket. A bucket can be considered as a container or a directory which stores all your files. We can create as many of these buckets as we need in our AWS account. 
6 | 
7 | * Everything within a bucket is an object. 
8 | 


--------------------------------------------------------------------------------
/06 - Cloud/Basics/AWS Global Infrastructure/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/06 - Cloud/Basics/IAM/README.md:
--------------------------------------------------------------------------------
1 | * When we create an account on AWS, it uses an email, that is know as a root account. That account has complete privileges to your AWS account. So it's a very powerful user, infact it's very difficult to restrict the privileges of the root account.
2 | * Therefore, AWS recommends that you don't use this account for everyday usage. Instead you should create your own user accounts for yourself and for your employees. The service we use for that is known as the AWS Identity and Access Management service.
3 | 


--------------------------------------------------------------------------------
/06 - Cloud/Basics/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/06 - Cloud/Basics/Security Groups and Network ACLs/README.md:
--------------------------------------------------------------------------------
 1 | * Security Groups and Network Access Control Lists (NACLs) are types of firewalls that you can use to protect your resources on AWS.
 2 | 
 3 | * A Security Group is applied at the instance level. We can apply a Security Group to an instance or multiple instances to control the traffic that we allow to reach or to leave from that EC2 instance.
 4 | 
 5 | * NACLs applies at the subnet level. It only restricts traffic whenever it's coming in or out from the subnet. 
 6 | 
 7 | * For example, when you send traffic from one instance to another instance within the same subnet, the NACL won't see the traffic but the Security Group will.
 8 | 
 9 | * As we discussed that NACL can be applied at the subnet level but with the Security Group we can actually add instances from multiple subnets into the same Security Group. And that could be Public or Private Subnet as well.
10 | 
11 | * So you can basically apply your Security Group to instances in any subnet.
12 | 
13 | * A Security Group will deny all traffic by default.
14 | 
15 | * By the way, Security Groups are within a VPC. So you create your Security Groups for each VPC.
16 | 
17 | # Stateful vs. Stateless Firewalls #
18 | 
19 | * A stateful firewall is the one which don't need any outbound rules to send traffic whereas a stateless firewall is the one which requires outbound rules to send traffic.
20 | 
21 | * A Security Group is a stateful firewall and a Network ACL is a stateless firewall.
22 | 


--------------------------------------------------------------------------------
/06 - Cloud/Basics/VPC/README.md:
--------------------------------------------------------------------------------
 1 | * The Amazon Virtual Private Cloud is a virtual space into which you can launch your resources.
 2 | * So you will be creating your own VPCs within AWS. There is also a default VPC created for you.
 3 | 
 4 | 
 5 | 
 6 | ## What a VPC actually is ? ##
 7 | 
 8 | -> A VPC is a logically isolated portion of the cloud within a region. You can have multiple VPCs in a region. <br>
 9 | 
10 | -> You can then create subnets within your VPC and they are actually assigned to an availability zone. So you can create subnets that are sitting in different data centres and deploy your resources there. One subnet is created per availability zone. So you will have the number of subnets same as the number of availability zones. <br>
11 | 
12 | -> We use a VPC Router to actually send information between our resources in different subnets within our VPC. And the way that we can manipulate the router and configure it so that it sends data to the correct locations is by using <b>Route Table</b>. <br>
13 | 
14 | -> So we create route tables and assign them to our subnets. <br>
15 | 
16 | -> An Internet Gateway is used to connect to the internet. <br>
17 | 
18 | -> Here we need to understand the Public subnets and the Private subnets. <br>
19 | 
20 | <b>Public Subnet:</b> The instances here will get a public IP address and can use the Internet Gateway directly to access the internet. <br>
21 | <b>Private Subnet:</b> The instances here can't access the Internet Gateway directly.
22 | 


--------------------------------------------------------------------------------
/06 - Cloud/DynamoDB/README.md:
--------------------------------------------------------------------------------
1 | * It is a NoSQL database provided by the AWS.
2 | 


--------------------------------------------------------------------------------
/06 - Cloud/Elastic Compute Cloud (EC2)/README.md:
--------------------------------------------------------------------------------
 1 | * Amazon EC2 is a compute service that allows you to run virtualized servers on AWS. 
 2 | 
 3 | * With EC2, you are running what we call instances. So an instance is kind of like a virtual server or a virtual machine running on AWS.
 4 | 
 5 | * As we learnt that an instance is essentially like a virtual machine. So it will have a certain amount of CPU, RAM, Drive space and the network interface. Then it will have an operating system and then it can have some applications which you install.
 6 | 
 7 | * Now, an EC2 instance will need an IP Address. So, there are three different types of IP Address that your instance can obtain. 
 8 | 
 9 | 
10 | 
11 | ![IP Addresses](https://user-images.githubusercontent.com/98219227/213363724-e60236c0-08a2-4a17-a62d-7aca867cf27e.png)
12 | 


--------------------------------------------------------------------------------
/06 - Cloud/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/07 - Docker /01 - Docker Commands/README.md:
--------------------------------------------------------------------------------
 1 | *  To pull an image from docker hub,
 2 | 
 3 | ```
 4 | docker pull <image_name>
 5 | ```
 6 | 
 7 | * To start a container from an image,
 8 | 
 9 | ```
10 | docker run <image_name>
11 | ```
12 | This command is also used to pull the image from docker hub and run the the container from that image.
13 | 
14 | * To run a command in a detached mode,
15 | 
16 | ```
17 | docker run -d <image_name>
18 | ```
19 | 
20 | * To list all running containers,
21 | 
22 | ```
23 | docker ps
24 | ```
25 | 
26 | * To see all the running as well as stopped containers,
27 | 
28 | ```
29 | docker ps -a 
30 | ```
31 | 
32 | * To stop a single container,
33 | 
34 | ```
35 | docker stop <container_ID>
36 | ```
37 | 
38 | * To remove a single container,
39 | 
40 | ```
41 | docker rm <container_ID>
42 | ```
43 | 
44 | * To stop all the containers at once,
45 | 
46 | ```
47 | docker stop $(docker ps -aq)
48 | ```
49 | 
50 | * To remove all the stopped containers at once,
51 | 
52 | ```
53 | docker rm $(docker ps -aq)
54 | ```
55 | 
56 | * To delete a single image,
57 | 
58 | ```
59 | docker rmi <image_name>
60 | ```
61 | 
62 | * To delete all the images,
63 | 
64 | ```
65 | docker rmi $(docker images -aq)
66 | ```
67 | 
68 | * To restart a container afer stopping it,
69 | 
70 | ```
71 | docker start <container_ID_of_stopped_container>
72 | ```
73 | 
74 | * Suppose you want to give a name to your container instead of a random name. Use the --name flag.
75 | 
76 | ```
77 | docker run --name redis-older redis:4.0
78 | ```
79 | 
80 | * To get the logs of a container,
81 | 
82 | ```
83 | docker logs <container_ID_OR_container_Name>
84 | ```
85 | 


--------------------------------------------------------------------------------
/07 - Docker /02 - Docker Run/README.md:
--------------------------------------------------------------------------------
 1 | * By default, the docker run command pulls the latest image of the application and runs it. But what if we want to run a specific image instead of the latest one. Use the command,
 2 | 
 3 | ```
 4 | docker run <image_name>:<tag>
 5 | ```
 6 | Example,
 7 | ```
 8 | docker run redis:5.0.5
 9 | ```
10 | 
11 | * To run a container in an interactive mode witha terminal,
12 | 
13 | ```
14 | docker run -it <image_name>
15 | ```
16 | 
17 | * To do port mapping,
18 | 
19 | ```
20 | docker run -p <host's_port>:<container's_port>
21 | ```
22 | 
23 | * To make your data persistent,
24 | 
25 | ```
26 | docker run -v <external_directory>:<container's_directory> <container_name>
27 | ```
28 | Example,
29 | ```
30 | docker run -v /opt/datadir:/var/lib/mysql mysql
31 | ```
32 | 
33 | * To get information about a speciifc conatiner,
34 | 
35 | ```
36 | docker inspect <container_ID_OR_container_name>
37 | ```
38 | 
39 | * To get logs of a speciifc container,
40 | 
41 | ```
42 | docker logs <container_ID_OR_container_name>
43 | ```
44 | 


--------------------------------------------------------------------------------
/07 - Docker /03 - Docker Images /Commands vs Entrypoint/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/07 - Docker /03 - Docker Images /Environment Variables /README.md:
--------------------------------------------------------------------------------
 1 | * To find the environment variables set on a container that's already running,
 2 | 
 3 | ```
 4 | docker inspect <containerID_OR_containerName>
 5 | ```
 6 | Under the config section you will find the list of environment variables set on a container. 
 7 | 
 8 | * To know the env field from within a container, run
 9 | 
10 | ```
11 | docker exec -it <containerName> env
12 | ```
13 | 
14 | 


--------------------------------------------------------------------------------
/07 - Docker /03 - Docker Images /README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/07 - Docker /04 - Docker Network /README.md:
--------------------------------------------------------------------------------
 1 | * Docker creates it's isolated network where the containers are running in. So when two docker conatiners are deployed in this network, they get connected.
 2 | 
 3 | * By default, docker already provides some networks.
 4 | 
 5 | * To see the available docker networks,
 6 | 
 7 | ```
 8 | docker network ls 
 9 | ```
10 | 


--------------------------------------------------------------------------------
/07 - Docker /05 - Docker Compose /README.md:
--------------------------------------------------------------------------------
1 | * With Docker compose file, we can take the whole command with it's configuration and map it into a file so that we have a structured commands.  
2 | 


--------------------------------------------------------------------------------
/07 - Docker /06 - Dockerfile/README.md:
--------------------------------------------------------------------------------
 1 | * Dockerfile is a blueprint for creating docker images.
 2 | 
 3 | * To build a docker image,
 4 | ```
 5 | docker build -t <image_name>:<version> <path>
 6 | ```
 7 | Example,
 8 | ```
 9 | docker build -t my-app:1.0 .
10 | ```
11 | 
12 | 


--------------------------------------------------------------------------------
/07 - Docker /README.md:
--------------------------------------------------------------------------------
 1 | ## What is Docker ##
 2 | 
 3 | Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker’s methodologies for shipping, testing, and deploying code quickly, you can significantly reduce the delay between writing code and running it in production.
 4 | 
 5 | 
 6 | 
 7 | ## What is a Container ##
 8 | 
 9 | A container is an isolated environment for your code. This means that a container has no knowledge of your operating system, or your files. It runs on the environment provided to you by Docker Desktop. This is why a container usually has everything that your code needs in order to run, down to a base operating system.
10 | 


--------------------------------------------------------------------------------
/08 - Kubernetes/README.md:
--------------------------------------------------------------------------------
1 | * kubectl run -> It deploys a docker container by creating a pod. 
2 | 
3 | * kubectl describe pod <pod_name> -> to get the details of the pod.
4 | 


--------------------------------------------------------------------------------
/08 - Kubernetes/YAML in Kubernetes/README.md:
--------------------------------------------------------------------------------
 1 | * Kubernetes uses YAML files as inputs for the creation of the objects such as pods, deployments, replicas, etc. Kubernetes definition always contains 4 top level fields, apiversion, kind, metadata and spec.
 2 | 
 3 | * apiversion -> this is teh version of the k8s API we are using to create the object.
 4 | 
 5 | * To get a list of all the objects,
 6 | 
 7 | ```
 8 | kubectl get all 
 9 | ```
10 | 


--------------------------------------------------------------------------------
/09 - Jenkins /01 - What is CI & CD/README.md:
--------------------------------------------------------------------------------
 1 | * Continuous Integration and Continuous Deployment/Delivery is a way to take code, package it up and deploy it to a system. That system could be anything like a VM, an EC2, etc.
 2 | 
 3 | ## What is CI? ##
 4 | 
 5 | * Continuous Integration, in this you take the code and you package it up. Think of it like a gift that you are wrapping. Suppose the gify comes to you in pieces, once you recieve that you put that together. And then you wrap it in a wrapping paper. That's your CI process. You are taking the code, you are packaging it up, and then you give it to the CD process.
 6 | 
 7 | * There are a few key pieces of CI.
 8 | 
 9 |   1. The first is, you package up that code. Let us say you are in your GitHub, and you have a GitHub repository and that repo has different folders or directories with diffreent pieces of code in it. Inside of your CI process, it does a clone of that GitHub repository, and then it packages it up.
10 |   2. The next in CI process is where we test our code, like unit tests would run automatically, integration tests, etc. You want to make sure that code is ready to go. Before you even try to deploy it, you want to make sure it passes all your tests, it has all of the dependencies that are needed.
11 |   3. The last thing is you would typically run any type of security checks against the code.
12 | 
13 | 
14 | 
15 | ## What is CD? ##
16 | 
17 | * It is the process where you deploy the code to some system. Think of that gift gain that you wrapped. Once you wrapped it up it can be given to a person. That's the CD prcess. Once the code is packages and tested and all those steps in the CI process, you then deliver it whatever system you are running on.
18 | 
19 | 
20 | ## Continuous Delivery Vs. Continuous Deployment ##
21 | 
22 | * In Continuous Delivery, there is some button somewhere to deploy the code for some manual intervention. In short, there is manual interevention.
23 | 
24 | * Continuous Deployment, means the code gets automatically deployed after the CI process. Let us say that you are committing and pushing some code to GitHub. Once it gets pushed to GitHub, the CI process would automatically kick off. Then once the code builds, the CD process would automatically run, and it would be deployed to the desired system. In short, everything is automatic, no human intervention.
25 | 
26 | 
27 | 
28 | * The key pieces of CD:
29 |   1. It ensure that you are authenticated to the system or wherever you are deploying.
30 |   2. Ensure that the code that is been deployed is working as expected once deployed. 
31 | 


--------------------------------------------------------------------------------
/09 - Jenkins /02 - Plugins/README.md:
--------------------------------------------------------------------------------
1 | * Plugins are a way to connect with jenkins to other systems.
2 | 
3 | * Plugins allow you to connect to conect to other services. Think of it like that you require some email or facebook account to login to some application. 
4 | 


--------------------------------------------------------------------------------
/09 - Jenkins /README.md:
--------------------------------------------------------------------------------
1 |  
2 | 


--------------------------------------------------------------------------------
/10 - Ansible/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/GoLang/01 - First Go program/README.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | package main
 3 | 
 4 | import "fmt"
 5 | 
 6 | func main() {
 7 | 	fmt.Println("Hello World!")
 8 | }
 9 | ```
10 | 
11 | * Output is, 
12 | 
13 | ```
14 | Hello World!
15 | ```
16 | 
17 | * Packages are Go's way of organizing and reusing code. Every Go program must start with the package declaration.
18 | 
19 | 
20 | * The next line is import "fmt". We use import keyword to include code from other packages to use with our program. fmt short form of format,and it implements formatting for input and output. So, import fmt basically means that we are importing the fmt package in our code because we need the functionalities provided by this package. Also, note that in Go, package name during the import statement is surrounded by double quotes. 
21 | 
22 | 
23 | * After this, we see a function declaration. you can consider them as the building blocks of a Go program. It is the entry point of the executable programs. Whenever we run a Go program, Go will automatically call the main function. 
24 | 
25 | 
26 | * Then we have the curly braces surrounding the line fmt.println("Hello World!"). These curly braces denote the starting and the ending of the function. 
27 | 
28 | 
29 | * Coming to the last piece of the program, the statement is made of three components. First, we specify the name of the package to be used, which is fmt. Then we specify the name of the function that's present inside that package. Here the function's name is println, which means print, and then go to new line. The .operator between fmt and println is known as the <b>member access operator</b>. It is used to access members of a package. In this case, we are accessing println function, which is a member of the fmt package. The third part is the text Hello World enclosed within the quotes, anything within the quotes becomes a string. Now, we call the function println by passing it the string expression as the only argument. 
30 | 


--------------------------------------------------------------------------------
/GoLang/02 - Data Types and Variables/02 - Variables/01 - Declaration/README.md:
--------------------------------------------------------------------------------
 1 | ## Declaring Variables ##
 2 | 
 3 | * Variables in Golang can be declared using various syntax.
 4 | 
 5 | ### Method 1 ###
 6 | 
 7 | ```
 8 | var <variable_name> <data_type> = <value>
 9 | ```
10 | 
11 | * A variable is initialised by using the var keyword. Keywords are predefined reserved words used in programming that have special meaning to the compiler. 
12 | * Then we specify the variable name.
13 | * Then the data type of the variable, following it is the assignment operator, then we have the value of data that we want to store.
14 | * Example,
15 | ```
16 | var s string = "Hello World"
17 | var x int = 100
18 | var b bool = true
19 | var f float64 = 78.32
20 | ```
21 | 
22 | * Let's see a simple program.
23 | ```
24 | package main
25 | import "fmt"
26 | 
27 | func main(){
28 |      var i int = 100
29 |      fmt.Println(i)
30 | }
31 | ```
32 | Output will be,
33 | ```
34 | 100
35 | ```
36 | 
37 | ### Method 2 ###
38 | 
39 | ```
40 | x := 100
41 | ```
42 | 
43 | * In this the compiler will implicitily assign the data type to the variable.
44 | 


--------------------------------------------------------------------------------
/GoLang/02 - Data Types and Variables/02 - Variables/02 - Printing Variables/README.md:
--------------------------------------------------------------------------------
 1 | ## Printing a string ##
 2 | 
 3 | ```
 4 | package main
 5 | import "fmt"
 6 | 
 7 | func main(){
 8 |     fmt.Print("Hey Everyone")
 9 | }
10 | ```
11 | Output,
12 | ```
13 | Hey Everyone
14 | ```
15 | 
16 | ## Printing a variable ## 
17 | 
18 | ```
19 | package main
20 | import "fmt"
21 | 
22 | func main(){
23 |     var sport string = "Cricket"
24 |     fmt.Println(sport)
25 | }
26 | ```
27 | Output,
28 | ```
29 | Cricket
30 | ```
31 | 
32 | ## Printing string and variable together ##
33 | 
34 | ```
35 | package main
36 | import "fmt"
37 | 
38 | func main(){
39 |     var sport string = "Cricket"
40 |     var player string = "Alex"
41 |     fmt.Println(player, "is playing", sport)
42 | }
43 | ```
44 | Output is, 
45 | ```
46 | Alex is playing Cricket
47 | ```
48 | Note: Here, Println will print the output and cursor will move to next line. We can also use "\n".
49 | 


--------------------------------------------------------------------------------
/GoLang/02 - Data Types and Variables/02 - Variables/03 - Scope/README.md:
--------------------------------------------------------------------------------
 1 | * The scope of a variable can be defined as a part of the program where a particular variable is accessible or from where it can be referenced. 
 2 | * In Golang, scope is defined using block. A block is defined in Go as a possibly empty sequence of declarations and statements within matching brace brackets or curly brackets. 
 3 | 
 4 | ```
 5 | {
 6 | // outer block
 7 | 
 8 | {
 9 | 
10 | // inner block
11 | 
12 | }
13 | 
14 | }
15 | ```
16 | 
17 | * Inner blocks can access variables that are declared within outer blocks but outer blocks cannot access variables that are declared within inner blocks. 
18 | 
19 | 
20 | 
21 | * Now we've understood how variable scope works in terms of blocks. However, scope rules can also be determined based on where the variables are declared. We have two kinds of such variables, local and global variables. 
22 | 
23 | * Talking about local variables, there are variables that are declared inside a function or a block. These are not accessible outside the functional block and these variables can also be declared inside looping or conditional statements. 
24 | 
25 | ```
26 | package main
27 | import "fmt"
28 | 
29 | func main(){
30 |      name := "Alex"
31 |      fmt.Println(name)
32 | }
33 | ```
34 | * Here, name is a local variable.
35 | 
36 | * Global variables are variables that are declared outside of a functional block. They are available throughout the lifetime of a program. They're declared at the top of the program outside all functional blocks and well, they can be accessed from any part of the program. 
37 | 
38 | ```
39 | package main
40 | import "fmt"
41 | 
42 | var name string = "Alex"
43 | 
44 | func main(){
45 |      fmt.Println(name)
46 | }
47 | ```
48 | * Here, name is a global variable.
49 | 


--------------------------------------------------------------------------------
/GoLang/02 - Data Types and Variables/02 - Variables/README.md:
--------------------------------------------------------------------------------
1 | * Variable is a named unit of data that is assigned a value. It is simply a reference to a value.
2 | 


--------------------------------------------------------------------------------
/GoLang/02 - Data Types and Variables/03 - Converting between Data Type/README.md:
--------------------------------------------------------------------------------
 1 | * The process of converting one data type to another is known as Type Casting. 
 2 | * Let's start with converting an integer to float. We can do this by simply wrapping the integer around float 64 or float 32. 
 3 | 
 4 | ```
 5 | package main
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | )
10 | 
11 | func main() {
12 | 	var i int = 90
13 | 	var f float64 = float64(i)
14 | 
15 | 	fmt.Printf("%.2f\n", f)
16 | }
17 | ```
18 | 
19 | * Output will be, 
20 | 
21 | ```
22 | 90.00
23 | ```
24 | 
25 | 
26 | 
27 | * Let us learn about the string conversion package. This package consists of methods that we can use to convert integer to string and vice versa. 
28 | * The first method is called Itoa(). It converts integer to string and it just returns one value, which is the string formed with a given integer. Let's see an example.
29 | 
30 | ```
31 | package main
32 | 
33 | import (
34 | 	"fmt"
35 | 	"strconv"
36 | )
37 | 
38 | func main() {
39 | 	var i int = 58
40 | 	var s string = strconv.Itoa(i)
41 | 	fmt.Printf("%q", s)
42 | 
43 | }
44 | ```
45 | 
46 | * Output will be, 
47 | 
48 | ```
49 | "58"
50 | ```
51 | 
52 | * The next method is Atoi(), which converts string to integer, and it returns two values, the corresponding integer and if there's any error. 
53 | 
54 | ```
55 | package main
56 | 
57 | import (
58 | 	"fmt"
59 | 	"strconv"
60 | )
61 | 
62 | func main() {
63 | 	var s string = "200"
64 | 	i, err := strconv.Atoi(s)
65 | 
66 | 	fmt.Printf("%v, %T \n", i, i)
67 | 	fmt.Printf("%v, %T", err, err)
68 | 
69 | }
70 | ```
71 | 
72 | * Output will be,
73 | 
74 | ```
75 | 200, int 
76 | <nil>, <nil>
77 | ```
78 | 


--------------------------------------------------------------------------------
/GoLang/02 - Data Types and Variables/Data Type /01 - String /README.md:
--------------------------------------------------------------------------------
1 | * String is any sequence of characters, and the characters can be numbers, letters, and symbols. 
2 | * They are defined in Golang using the keyword string and the expression is always surrounded by quotes or inverted commas. Example, "Programming", "567", etc.
3 | * A String occupies 16 bytes of memory in Golang.
4 | 


--------------------------------------------------------------------------------
/GoLang/02 - Data Types and Variables/Data Type /02 - Numbers/README.md:
--------------------------------------------------------------------------------
 1 | # Integers #
 2 | 
 3 | * Integers can be defined in Golang using many keywords, but the most used is simply int. int over here refers to signed integers, which means both positive and negative numbers. Example could be -90, 0, 27, etc.
 4 | 
 5 | ![Screenshot (126)](https://user-images.githubusercontent.com/98219227/231078069-26f2f274-e593-4062-947d-1c94d2574775.png)
 6 | 
 7 | 
 8 | 
 9 | # Float #
10 | 
11 | * Float are also known as floating-point numbers are the numbers that contain a decimal counterpart and they are either of 32 bit or 64 bit in Golang. Examples of floats are 63.09 or 0.821, etc. 
12 | * Go has two floating-point types, float 32 and float 64. They're also referred to as single precision and double precision respectively. 
13 | 


--------------------------------------------------------------------------------
/GoLang/02 - Data Types and Variables/Data Type /03 - Boolean/README.md:
--------------------------------------------------------------------------------
1 | * Booleans are defined in Golang using the keyword bool and they consists of just two values, true and false, both in small case letters.
2 | 


--------------------------------------------------------------------------------
/GoLang/02 - Data Types and Variables/Data Type /README.md:
--------------------------------------------------------------------------------
1 | * A data type is a classification made on the kind of data. They categorize a set of related values, describe the operations that can be done on them. 
2 | 
3 | * Why do we need a datatype ? We need them for basically three reasons : <br>
4 |           
5 |           1. categorize a set of related values 
6 |           2. describe the operations that can be done on them 
7 |           3. define the way the data is stored 
8 | 


--------------------------------------------------------------------------------
/GoLang/02 - Data Types and Variables/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/GoLang/03 - User Input/README.md:
--------------------------------------------------------------------------------
  1 | * One of the most used ways of taking user input is through Scanf function, which is provided by the fmt package. Scanf function takes the format string, along with the list of variable number of arguments. 
  2 | * This string contains custom specifiers that the Scanf function uses to format the final output string. 
  3 | * Here is an example. 
  4 |  
  5 | ```
  6 | package main
  7 | import "fmt"
  8 | 
  9 | func main() {
 10 | 	var name string
 11 | 	fmt.Print("Enter your name: ")
 12 | 	fmt.Scanf("%s", &name)
 13 | 	fmt.Println("Hey, ", name)
 14 | }
 15 | ```
 16 | * Here %s is a format specifier for string. The arguments consist of the name variable which is a string variable itself. 
 17 | * Note the ampersand sign over here, we need to use it with the Scanf function. We will understand this more when we study about pointers.
 18 | * When we run the program, the program will prompt the user to enter their name. 
 19 | * Output will look like this,
 20 | 
 21 | ```
 22 | Enter your name: Naved
 23 | Hey,  Naved
 24 | ```
 25 | 
 26 | <br>
 27 | 
 28 | * Let us see how we can take multiple inputs using Scanf. Here is an example.
 29 | 
 30 | ```
 31 | package main
 32 | 
 33 | import "fmt"
 34 | 
 35 | func main() {
 36 | 	var name string
 37 | 	var is_age bool
 38 | 
 39 | 	fmt.Print("Enter your name and is your age greater than 18: ")
 40 | 	fmt.Scanf("%s %t", &name, &is_age)
 41 | 	fmt.Println("My name is ", name, "and my age is greater than 18: ", is_age)
 42 | }
 43 | ```
 44 | <br>
 45 | * Output will look like,
 46 | 
 47 | ```
 48 | Enter your name and is your age greater than 18: Naved true
 49 | My name is  Naved and my age is greater than 18: true
 50 | ```
 51 | 
 52 | * NOTE : Scanf function reads from the input source sequentially. Hence, we must give the list of arguments in the order that's specified in the format string. 
 53 | 
 54 | <br>
 55 | 
 56 | * The fmt scanner function returns two values, count, which is the number of arguments that the function writes successfully, and the error, which is any error that's thrown during the execution of the Scanf function. 
 57 | * Let us understand this with an example.
 58 | 
 59 | ```
 60 | package main
 61 | 
 62 | import "fmt"
 63 | 
 64 | func main() {
 65 | 	var a string
 66 | 	var b int
 67 | 
 68 | 	fmt.Print("Enter a string and a number: ")
 69 | 
 70 | 	count, err := fmt.Scanf("%s %d", &a, &b)
 71 | 
 72 | 	fmt.Println("count: ", count)
 73 | 	fmt.Println("error: ", err)
 74 | 	fmt.Println("a: ", a)
 75 | 	fmt.Println("b: ", b)
 76 | }
 77 | ```
 78 | <br>
 79 | 
 80 | * Output will look like this,
 81 | 
 82 | ```
 83 | Enter a string and a number: Naved 5
 84 | count:  2
 85 | error:  <nil>
 86 | a:  Naved
 87 | b:  5
 88 | ```
 89 | 
 90 | * Here we just entered a string and an integer. So the program ran successfully with no errors. But now consider this output,
 91 | 
 92 | ```
 93 | Enter a string and a number: Naved Ahmad
 94 | count:  1
 95 | error:  expected integer
 96 | a:  Naved
 97 | b:  0
 98 | ```
 99 | 
100 | * Instead of passing a string and an integer, we passed a string and then again a string. It was expecting a string and a number, but we passed two strings instead. 
101 | * So count is one because we stored input successfully in just one argument, and that is variable A. 
102 | * As you can see, error is expected integer, since we were expecting an integer, but it got a string instead so it gave us an error. 
103 | 


--------------------------------------------------------------------------------
/GoLang/04 - Constants/README.md:
--------------------------------------------------------------------------------
 1 | * Constants are those variables whose values once initialized cannot be modified.
 2 | * The syntax to declare a constant in Golang is:
 3 | 
 4 | ```
 5 | const <const_name> <data_type> = <value>
 6 | ```
 7 | 
 8 | * It's initialized by using the const keyword. Then you assign the constant with a name. Then you specify the data type of the constant. The data type in case of constants is optional to provide. If you do not provide it, it's implicitly inferred by the compiler. Then we have the assignment operator. Then the value you want to store in the constant. 
 9 | 
10 | <br>
11 | 
12 | * We have two kinds of constants, typed and untyped. 
13 | * Constants are untyped unless they're explicitly given a data type at declaration and they allow for much more flexibility. Example,
14 | 
15 | ```
16 | const age = 12
17 | const s_name, s_age = "Naved", 21
18 | ```
19 | 
20 | * Types constants, these are constants where you explicitly specify the data type in the declaration. Example,
21 | 
22 | ```
23 | const name string = "Naved Ahmad"
24 | const age = 21
25 | ```
26 | 
27 | * <b>NOTE :</b> The short hand variable declaration does not work for constants.
28 | 
29 | ```
30 | package main
31 | 
32 | import (
33 | 	"fmt"
34 | 	"strconv"
35 | )
36 | 
37 | func main() {
38 | 	const name := "Naved Ahmad"
39 | 	fmt.Printf("%v: %T", name, name)
40 | }
41 | ```
42 | 
43 | * The compiler will give you the following error,
44 | 
45 | ```
46 | syntax error: unexpected :=, expected =
47 | ```
48 | 


--------------------------------------------------------------------------------
/GoLang/Array/README.md:
--------------------------------------------------------------------------------
  1 | * An array a collection of similar data elements that are stored at contiguous memory locations. 
  2 | 
  3 | * Arrays are also known as homogenous data types since we can store elements of a single data type in one array and not different data types in one single array. 
  4 | 
  5 | ### Why do we need arrays ###
  6 | 
  7 | * In programming, most of the time we need to store large amount of data of similar type. 
  8 | 
  9 | * <b>NOTE</b>: Arrays in Golang are a fixed length. That is, once they're declared and the size is mentioned, we cannot change the length of the array. 
 10 | 
 11 | * An array in Golang, has a pointer that points to the first element in the array. Since memory is contiguous, we can even calculate the address of any element that we    want to.
 12 | 
 13 | * It also has a property called length which denotes the number of elements in the array, and a property called capacity, which denotes the number of elements that it
 14 |   can contain. In case of arrays, length and capacity is same. 
 15 | 
 16 | * Syntax,
 17 | 
 18 | ```
 19 | var <array_name> [<size>] <data_type>
 20 | ```
 21 | 
 22 | Example,
 23 | 
 24 | ```
 25 | var sports [5] string
 26 | ```
 27 | 
 28 | * Let's see how we can initialize an array now. 
 29 | 
 30 | ```
 31 | var nums [3] int = [3]int{1,2,3} 
 32 | ```
 33 |    OR 
 34 | ```
 35 | grades := [3]int{1,2,3}
 36 | ```
 37 |    OR 
 38 | ```
 39 | grades := [...]int{1,2,3}
 40 | ```
 41 | 
 42 | * A simple program,
 43 | 
 44 | ```
 45 | package main
 46 | 
 47 | import "fmt"
 48 | 
 49 | func main() {
 50 | 	var nums [3]int = [3]int{1, 2, 3}
 51 | 	fmt.Println(nums)
 52 | }
 53 | ```
 54 | Output,
 55 | ```
 56 | [1 2 3]
 57 | ```
 58 | 
 59 | * We can find the length of an array using a built in length function. The len function over here takes an array as an input and returns us the size of the array. Example,
 60 | 
 61 | ```
 62 | package main
 63 | 
 64 | import "fmt"
 65 | 
 66 | func main() {
 67 | 	var nums [3]int = [3]int{1, 2, 3}
 68 | 	fmt.Println(len(nums))
 69 | 
 70 | }
 71 | ```
 72 | Output,
 73 | ```
 74 | 3
 75 | ```
 76 | 
 77 | * An array is numbered and these numbers are called array index. The first element of an array has the index zero, while the last element here has the index length minus one. We can access array elements using these indexes as well. Example,
 78 | 
 79 | ```
 80 | package main
 81 | 
 82 | import "fmt"
 83 | 
 84 | func main() {
 85 | 	var nums [3]int = [3]int{1, 2, 3}
 86 | 	fmt.Println(nums[1])
 87 | }
 88 | ```
 89 | Output,
 90 | ```
 91 | 2
 92 | ```
 93 | 
 94 | * We can loop through an array using for loop.
 95 | 
 96 | * We can also loop through an array using the range keyword. The range keyword is mainly used in for loops, in order to iterate over all the elements of an array, slice, or map. 
 97 | 
 98 | * For arrays, range sets the scope of iteration up to the length of the array. 
 99 | 
100 | * Syntax, 
101 | 
102 | ```
103 | for index, element := range nums {
104 | 	fmt.Println(index, "=>", element)
105 | }
106 | ```
107 | 
108 | * In the case of arrays and slices, the first value returned is the index, and the second value is the element itself. Example,
109 | 
110 | ```
111 | package main
112 | 
113 | import "fmt"
114 | 
115 | func main() {
116 | 	var nums [5]int = [5]int{1, 2, 3, 4, 5}
117 | 
118 | 	for index, element := range nums {
119 | 		fmt.Println(index, "=>", element)
120 | 	}
121 | }
122 | ```
123 | Output,
124 | ```
125 | 0 => 1
126 | 1 => 2
127 | 2 => 3
128 | 3 => 4
129 | 4 => 5
130 | ```
131 | 
132 | 
133 | 
134 | ### Multidimensional array ###
135 | 
136 | * Until now, we've just talked about single-dimensional arrays, but we also have multi-dimensional array. A multi-dimensional array is an array that has more than one dimension. It's like an array of arrays or basically an array that has multiple levels. 
137 | 
138 | * The simplest multi-dimensional array is the 2-d array or two-dimensional array. Example,
139 | 
140 | ```
141 | package main
142 | 
143 | import "fmt"
144 | 
145 | func main() {
146 | 	arr := [3][2]int{{9, 2}, {4, 28}, {16, 81}}
147 | 	fmt.Println(arr[2][1])
148 | }
149 | ```
150 | Output,
151 | ```
152 | 81
153 | ```
154 | 
155 | 
156 | 
157 | 
158 | 
159 | 


--------------------------------------------------------------------------------
/GoLang/Control Flow/01 - If-else and else if statements/README.md:
--------------------------------------------------------------------------------
  1 | * The if-else clause is one of the most used structures for specifying conditions. 
  2 | 
  3 | 
  4 | 
  5 | # if-else and else if statement #
  6 | 
  7 | * How does if works? The if statement is provided with a condition. The if statement evaluates this condition, and if this condition is true, statements inside the body of if are executed. If the condition is false, the statements inside the body of if are not executed. 
  8 | 
  9 | ```
 10 | if (condition) {
 11 |     // executes when condition is true 
 12 | }
 13 | ```
 14 | 
 15 | <b>NOTE</b>: The parentheses around the condition are optional. 
 16 | 
 17 | * Example, 
 18 | 
 19 | ```
 20 | package main
 21 | 
 22 | import (
 23 | 	"fmt"
 24 | )
 25 | 
 26 | func main() {
 27 | 	var a int = 100
 28 | 	var b string = "Fine"
 29 | 	if a == 100 {
 30 | 		fmt.Println(b)
 31 | 	}
 32 | }
 33 | ```
 34 | 
 35 | * Output will be,
 36 | 
 37 | ```
 38 | Fine
 39 | ```
 40 | 
 41 | * The if statement may also have an optional else block that runs when the if condition is not met. 
 42 | 
 43 | ```
 44 | if (condition) {
 45 |     // executes when condition is true 
 46 | } else {
 47 |     // executes when condition is false 
 48 | }
 49 | ```
 50 | 
 51 | * Example,
 52 | 
 53 | ```
 54 | package main
 55 | 
 56 | import (
 57 | 	"fmt"
 58 | )
 59 | 
 60 | func main() {
 61 | 	var a int = 100
 62 | 	if a == 10 {
 63 | 		fmt.Println("Fine")
 64 | 	} else {
 65 | 		fmt.Println("Wrong")
 66 | 	}
 67 | }
 68 | ```
 69 | 
 70 | * Output,
 71 | 
 72 | ```
 73 | Wrong
 74 | ```
 75 | 
 76 | <b>NOTE</b>: for the syntax in if-else block, the else statement should start from the same line where the if ends. Else, it will throw us an error. 
 77 | 
 78 | 
 79 | 
 80 | # else if statement #
 81 | 
 82 | * Example,
 83 | 
 84 | ```
 85 | package main
 86 | 
 87 | import (
 88 | 	"fmt"
 89 | )
 90 | 
 91 | func main() {
 92 | 	var a int = 100
 93 | 	if a == 10 {
 94 | 		fmt.Println("Very far")
 95 | 	} else if a == 50 {
 96 | 		fmt.Println("Close")
 97 | 	} else {
 98 | 		fmt.Println("Wrong")
 99 | 	}
100 | }
101 | ```
102 | 


--------------------------------------------------------------------------------
/GoLang/Control Flow/02 - Switch Statement/README.md:
--------------------------------------------------------------------------------
  1 | * In switch-case control mechanism, we use the value of a variable or an expression to change the control flow of program execution, via a multi-way branch. 
  2 | 
  3 | * Let's see the syntax of switch. 
  4 | 
  5 | ```
  6 | switch expression {
  7 |     case value_1:
  8 |       // execute when expression equals to value_1
  9 |       
 10 |     case value_2:
 11 |       // execute when expression equals to value_2
 12 |       
 13 |     default: 
 14 |       // execute when no match is found 
 15 | }
 16 | ```
 17 | 
 18 | * This switch statement tests the value of an expression and compares it with multiple cases. Once the case match is found, a block of statements associated with that particular case is executed. Each case in a block of a switch has a different name, or a number, or a value, which is referred to as an identifier. 
 19 | 
 20 | * The value that's provided in the expression is compared with all the cases inside the switch block until the match is found. In case no match is found, the default statement is executed and the control goes out of the switch block. 
 21 | 
 22 | * Example, 
 23 | 
 24 | ```
 25 | package main
 26 | 
 27 | import (
 28 | 	"fmt"
 29 | )
 30 | 
 31 | func main() {
 32 | 	var i int = 100
 33 | 	switch i {
 34 | 	case 10:
 35 | 		fmt.Println("i is 10")
 36 | 	case 100:
 37 | 		fmt.Println("Exactly")
 38 | 	default:
 39 | 		fmt.Println("neither 10 nor 100")
 40 | 
 41 | 	}
 42 | }
 43 | ```
 44 | 
 45 | * Output, 
 46 | 
 47 | ```
 48 | Exactly
 49 | ```
 50 | 
 51 | * We also have a very special keyword for a switch-case statement and that is called the fall-through keyword. The fall-through keyword is used in switch-case to force the execution flow to fall through the successive case block. Example, 
 52 | 
 53 | ```
 54 | package main
 55 | 
 56 | import (
 57 | 	"fmt"
 58 | )
 59 | 
 60 | func main() {
 61 | 	var i int = 10
 62 | 	switch i {
 63 | 	case 5:
 64 | 		fmt.Println("i is 10")
 65 | 	case 10:
 66 | 		fmt.Println("Exactly")
 67 | 		fallthrough
 68 | 	case 50:
 69 | 		fmt.Println("i is 50")
 70 | 		fallthrough
 71 | 	default:
 72 | 		fmt.Println("neither 10 nor 100")
 73 | 
 74 | 	}
 75 | }
 76 | ```
 77 | 
 78 | * Output, 
 79 | 
 80 | ```
 81 | Exactly
 82 | i is 50
 83 | neither 10 nor 100
 84 | ```
 85 | 
 86 | <b>NOTE</b>: Go uses an implicit break statement for each case.
 87 | 
 88 | * Instead of using a single value, we can even use conditional statements for switch. In this case, we do not need to mention an expression after switch. We can simply write our conditions inside the case blocks itself. Example, 
 89 | 
 90 | ```
 91 | package main
 92 | 
 93 | import (
 94 | 	"fmt"
 95 | )
 96 | 
 97 | func main() {
 98 | 	var a, b int = 10, 20
 99 | 	switch {
100 | 	case a+b == 30:
101 | 		fmt.Println("equal to 30")
102 | 	case a+b <= 30:
103 | 		fmt.Println("less than or equal to 30")
104 | 	default:
105 | 		fmt.Println("greater tham 30")
106 | 	}
107 | }
108 | ```
109 | 
110 | * Output, 
111 | 
112 | ```
113 | equal to 30
114 | ```
115 | 


--------------------------------------------------------------------------------
/GoLang/Control Flow/03 - Looping with for /README.md:
--------------------------------------------------------------------------------
 1 | * A loop is a sequence of instructions that is continually repeated until a certain condition is reached. 
 2 | 
 3 | * Syntax, 
 4 | 
 5 | ```
 6 | for initialization; condition; post {
 7 |       // statements 
 8 | }
 9 | ```
10 | 
11 |    1. This initialization statement is optional and it executes before the for loop starts. It is mostly used in simple statements like variable declarations or increment or assignment statement. <br>
12 |    
13 |    2. Then we have the condition statement. The condition statement holds a Boolean expression, which is evaluated at the starting of each iteration of the loop. If the value of the conditional statement is true, then the loop will execute. <br>
14 |    3. Then we have the post statement, which is also optional and is executed after each iteration of the for loop. After the post statement, the condition statement evaluates again. If the value of the conditional statement is false, then the loop ends. It can also be written in the loop body.
15 |    
16 |    
17 |    
18 | * If we skip the condition as well, we get an infinite loop. 
19 | 
20 | * While implementing looping constructs, you would also have scenarios where you want to skip a particular iteration in the loop, or even completely break out of the loop if something happens. We have a statement called break. 
21 | 
22 | * <b>break</b>: The break statement ends the loop immediately when it is encountered. 
23 | 
24 | * <b>continue</b>: The continuous statement skips the current iteration of loop and continues with the next iteration.
25 | 


--------------------------------------------------------------------------------
/GoLang/Control Flow/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/GoLang/Functions/01 - Function Syntax/README.md:
--------------------------------------------------------------------------------
 1 | * Syntax,
 2 | 
 3 | ```
 4 | func <function_name>(<params>) <return_type> {
 5 |     // body of the function 
 6 | }
 7 | ```
 8 | 
 9 | Example,
10 | 
11 | ```
12 | func addNumbers(a int, b int) int {
13 |     // body 
14 | }
15 | ```
16 | 
17 | * <b>return</b> keyword: used to return from a method when its execution is complete. When a return statement is reached in a function, the program returns to the code that invoked or called that function. A function can return a value or not even return anything. Example,
18 | 
19 | ```
20 | func addNumbers(a int, b int) int {
21 |     sum := a + b
22 |     return sum 
23 | }
24 | ```
25 | 
26 | ## Calling a function ##
27 | 
28 | * Syntax,
29 | 
30 | ```
31 | <function_name>(<arguments>)
32 | ```
33 | Example,
34 | ```
35 | addNumbers(2, 3)
36 | ```
37 | 
38 | * To recieve the values returned by a function, we store it in variables. Example,
39 | 
40 | ```
41 | sumOfNumbers := addNumbers(2, 3)
42 | ```
43 | 
44 | ## Naming convention for functions ##
45 | 
46 |    1. must begin with a letter.
47 |    2. can have any number of additional letters and symbols.
48 |    3. cannot contain spaces.
49 |    4. case-sensitive.
50 | 
51 | 
52 | 
53 | * Example,
54 | 
55 | ```
56 | package main
57 | 
58 | import "fmt"
59 | 
60 | func printGreeting(str string) {
61 | 	fmt.Println("Hey there,", str)
62 | }
63 | 
64 | func main() {
65 | 	printGreeting("Naved")
66 | }
67 | ```
68 | Output,
69 | ```
70 | Hey there, Naved
71 | ```
72 | 
73 | 
74 | 
75 | 
76 | 
77 | 
78 | 


--------------------------------------------------------------------------------
/GoLang/Functions/02 - Return Types/README.md:
--------------------------------------------------------------------------------
  1 | ## Returning multiple values ##
  2 | 
  3 | * Go allows returning multiple values. Example,
  4 | 
  5 | ```
  6 | package main
  7 | 
  8 | import "fmt"
  9 | 
 10 | func operation(a int, b int) (int, int) {
 11 | 	sum := a + b
 12 | 	diff := a - b
 13 | 	return sum, diff
 14 | }
 15 | 
 16 | func main() {
 17 | 	sum, difference := operation(20, 10)
 18 | 	fmt.Println(sum, difference)
 19 | }
 20 | ```
 21 | Example,
 22 | ```
 23 | 30 10
 24 | ```
 25 | 
 26 | 
 27 | 
 28 | ## Returning named values ##
 29 | 
 30 | * We can give a name to our return variables in the function signature only. Example,
 31 | 
 32 | ```
 33 | package main
 34 | 
 35 | import "fmt"
 36 | 
 37 | func operation(a int, b int) (sum int, diff int) {
 38 | 	sum = a + b
 39 | 	diff = a - b
 40 | 	return
 41 | }
 42 | 
 43 | func main() {
 44 | 	sum, difference := operation(20, 10)
 45 | 	fmt.Println(sum, difference)
 46 | }
 47 | ```
 48 | Example,
 49 | ```
 50 | 30 10
 51 | ```
 52 | 
 53 | 
 54 | 
 55 | ## Variadic functions ##
 56 | 
 57 | 
 58 | * function that accepts variable number of arguments.
 59 | 
 60 | * it is possible to pass a varying number of arguments of the same type as referenced in the function signature.
 61 | 
 62 | * to declare a variadic function, the type of the final parameter is preceded by an ellipsis "..."
 63 | 
 64 | * Syntax,
 65 | 
 66 | ```
 67 | func <func_name>(param-1 type, param-2 type, param-3 ...type) <return_type>
 68 | ```
 69 | Example,
 70 | ```
 71 | func sumNumbers(numbers ...int) int
 72 | 
 73 |             AND
 74 | 	    
 75 | func sumNumbers(str string, numbers ...int)
 76 | ```
 77 | 
 78 | * Example program, 
 79 | 
 80 | ```
 81 | package main
 82 | 
 83 | import "fmt"
 84 | 
 85 | func printDetails(student string, subjects ...string) {
 86 | 	fmt.Println("hey", student, "here are your subjects:")
 87 | 	for _, sub := range subjects {
 88 | 		fmt.Printf("%s, ", sub)
 89 | 	}
 90 | 
 91 | }
 92 | 
 93 | func main() {
 94 | 	printDetails("Naved", "Computer Science", "Physics")
 95 | }
 96 | ```
 97 | Output,
 98 | ```
 99 | hey Naved here are your subjects:
100 | Computer Science, Physics,
101 | ```
102 | 
103 | 
104 | 
105 | ## Blank identifier ##
106 | 
107 | * Used to ignore a value returned by the function.
108 | * Example,
109 | 
110 | ```
111 | package main
112 | 
113 | import "fmt"
114 | 
115 | func f() (int, int) {
116 | 	return 10, 20
117 | }
118 | 
119 | func main() {
120 | 	r, _ := f()
121 | 	fmt.Println(r)
122 | }
123 | ```
124 | Output,
125 | ```
126 | 10
127 | ```
128 | 


--------------------------------------------------------------------------------
/GoLang/Functions/03 - Recursive Functions/README.md:
--------------------------------------------------------------------------------
 1 | * Recursion is a concept where a function calls itself by direct or indirect means. 
 2 | 
 3 | * The function keeps calling itself until it reaches a base case.
 4 | 
 5 | * It is used to solve a problem where the solution is dependent on the smaller instance of the same problem. 
 6 | 
 7 | * Example,
 8 | 
 9 | ```
10 | package main
11 | import "fmt"
12 | 
13 | func factorial(n int) int {
14 | 	if n == 0 {
15 | 		return 1
16 | 	}
17 | 	return n * factorial(n-1)
18 | }
19 | 
20 | func main() {
21 | 	n := 7
22 | 	result := factorial(n)
23 | 	fmt.Println("Factorial of", n, "is :", result)
24 | }
25 | ```
26 | Output,
27 | ```
28 | Factorial of 7 is : 5040
29 | ```
30 | 


--------------------------------------------------------------------------------
/GoLang/Functions/04 - Anonymous Functions/README.md:
--------------------------------------------------------------------------------
 1 | * It is a function that is declared without any named identifier to refer to it. 
 2 | 
 3 | * They can accept inputs and return outputs, just as standard functions do. 
 4 | 
 5 | * They can be used for containing functionaity that need not be named and possibly for short-term use. 
 6 | 
 7 | * Example,
 8 | 
 9 | ```
10 | package main
11 | 
12 | import "fmt"
13 | 
14 | func main() {
15 | 	x := func(l int, b int) int {
16 | 		return l * b
17 | 	}
18 | 	fmt.Printf("%T \n", x)
19 | 	fmt.Println(x(20, 30))
20 | }
21 | ```
22 | Output,
23 | ```
24 | func(int, int) int 
25 | 600
26 | ```
27 | 
28 | * Another example,
29 | 
30 | ```
31 | package main
32 | 
33 | import "fmt"
34 | 
35 | func main() {
36 | 	x := func(l int, b int) int {
37 | 		return l * b
38 | 	}(20, 30)
39 | 	fmt.Printf("%T \n", x)
40 | 	fmt.Println(x)
41 | }
42 | ```
43 | Output,
44 | ```
45 | int 
46 | 600
47 | ```
48 | 


--------------------------------------------------------------------------------
/GoLang/Functions/05 - Higher Order Functions/README.md:
--------------------------------------------------------------------------------
 1 | * These are the functions that receives a function as an argument or returns a function as output. 
 2 | 
 3 | ## Why we need high order functions ##
 4 | 
 5 | * Composition
 6 | 
 7 |    1. creating smaller functions that take care of certain piece of logic.
 8 |    2. composing complex function by using different smaller functions.
 9 | 
10 | * Reduces bugs
11 | 
12 | * Code gets easier to read and understand. 
13 | 


--------------------------------------------------------------------------------
/GoLang/Functions/06 - Defer Statement/README.md:
--------------------------------------------------------------------------------
 1 | * A defer statement delays the execution of a function until the surrounding function returns.
 2 | 
 3 | * The deferred call's arguments are evaluated immediately, but the function call is not executed until the surrounding function returns. 
 4 | 
 5 | * Example,
 6 | 
 7 | ```
 8 | package main
 9 | 
10 | import "fmt"
11 | 
12 | func printName(str string) {
13 | 	fmt.Println(str)
14 | }
15 | func printRollNo(rno int) {
16 | 	fmt.Println(rno)
17 | }
18 | func printAddress(adr string) {
19 | 	fmt.Println(adr)
20 | }
21 | func main() {
22 | 	printName("Joe")
23 | 	defer printRollNo(23)
24 | 	printAddress("street-32")
25 | }
26 | ```
27 | Output,
28 | ```
29 | Joe
30 | street-32
31 | 23
32 | ```
33 | 


--------------------------------------------------------------------------------
/GoLang/Functions/README.md:
--------------------------------------------------------------------------------
 1 | * Functions are self-contained units of code which carry out a certain job. 
 2 | 
 3 | * They help us divide a program into small manageable, repeatable and organisable chunks. 
 4 | 
 5 | * They are also known as method.
 6 | 
 7 | ## Why use functions? ##
 8 | 
 9 | * <b>Reusablility:</b> We define a function once and then can call it multiple times. 
10 | 
11 | * <b>Abstraction:</b> Functions can be used to abstract their inner implemetations. 
12 | 


--------------------------------------------------------------------------------
/GoLang/Maps/README.md:
--------------------------------------------------------------------------------
  1 | * A map is a data structure that provides you with an unordered collection of key-value pairs. 
  2 | 
  3 | * They are used to look up a value by it's associated key. You store values into the map based on a key. 
  4 | 
  5 | * The strength of a map is its ability to retrieve data quickly based on the key. 
  6 | 
  7 | * A key works like an index that points to the value you associate with that key. 
  8 | 
  9 | * Go maps are implemented using hash tables and they have efficient add, get and delete operations. 
 10 | 
 11 | * Syntax, 
 12 | 
 13 | ```
 14 | var <map_name> map[key_data_type>]<value_data_type>
 15 | ```
 16 | This syntax created an empty map. So, if we try to add values in it, it will throw us an error. 
 17 | 
 18 | * To create maps with key-value pairs, we need to initialize it as well. Syntax,
 19 | 
 20 | ```
 21 | <map_name> := map[<key_data_type>]<value_data_type>{<key_value_pairs>}
 22 | ```
 23 | 
 24 | * Example,
 25 | 
 26 | ```
 27 | codes := map[string]string{"en": "english", "fr": "french"}
 28 | ```
 29 | 
 30 | * We can also use make() to create a map. The make() takes argumented type of the map, and it returns us an initialized map. Capacity here is an optional argument. Syntax,
 31 | 
 32 | ```
 33 | <map_name> := make(map[<key_data_type>]<value_data_type>,<initial_capacity>) 
 34 | ```
 35 | 
 36 | * To determine how many items or key-value pairs a map has, we use the len() function. It will return zero for an uninitialized map.
 37 | 
 38 | * We can also access the items of a map by referring to its key name, simply by specifying the name of the map and writing its key name inside the square brackets. Syntax,
 39 | 
 40 | ```
 41 | fmt.Println(map_name["key_name"])
 42 | ```
 43 | 
 44 | * Now, when we say getting a key while talking about maps, we mean getting the value associated with the key. When you index a map in Go, you get two return values. The first is the value and second(optional) is a boolean that indicates if the key exists. If the key doesn't exist, the first value will be the default zero value. Example,
 45 | 
 46 | ```
 47 | package main
 48 | 
 49 | import "fmt"
 50 | 
 51 | func main() {
 52 | 	codes := map[string]int{"en": 1, "hh": 2}
 53 | 	value, found := codes["en"]
 54 | 	fmt.Println(found, value)
 55 | }
 56 | ```
 57 | Output,
 58 | ```
 59 | true 1
 60 | ```
 61 | 
 62 | * Now, adding an item to the map is done by using a new index key and assigning a value to it. Example,
 63 | 
 64 | ```
 65 | package main
 66 | 
 67 | import "fmt"
 68 | 
 69 | func main() {
 70 | 	codes := map[string]int{"en": 1, "hh": 2}
 71 | 
 72 | 	codes["it"] = 3
 73 | 	fmt.Println(codes)
 74 | }
 75 | ```
 76 | Output,
 77 | ```
 78 | map[en:1 hh:2 it:3]
 79 | ```
 80 | 
 81 | * We can also update the value of a specific item by referring to its key name. It will overwrite or update the value of that key with the new value. Example,
 82 | 
 83 | ```
 84 | package main
 85 | 
 86 | import "fmt"
 87 | 
 88 | func main() {
 89 | 	codes := map[string]int{"en": 1, "hh": 2}
 90 | 
 91 | 	codes["en"] = 3
 92 | 	fmt.Println(codes)
 93 | }
 94 | ```
 95 | Output,
 96 | ```
 97 | map[en:3 hh:2]
 98 | ```
 99 | 
100 | * To delete a key-value pair from a map, we have delete(). It takes the name of our map and the name of the key that we want to delete. Example,
101 | 
102 | ```
103 | package main
104 | 
105 | import "fmt"
106 | 
107 | func main() {
108 | 	codes := map[string]int{"en": 1, "hh": 2}
109 | 	fmt.Println(codes)
110 | 
111 | 	delete(codes, "en")
112 | 	fmt.Println(codes)
113 | }
114 | ```
115 | Output,
116 | ```
117 | map[en:1 hh:2]
118 | map[hh:2]
119 | ```
120 | 
121 | * Now for looping or iterating over a map, the range expression returns the key and the value. For arrays and slices, it returns as index and element, while for maps, it returns as the key and the value. Example,
122 | 
123 | ```
124 | package main
125 | 
126 | import "fmt"
127 | 
128 | func main() {
129 | 	codes := map[string]int{"en": 1, "hh": 2}
130 | 
131 | 	for key, value := range codes {
132 | 		fmt.Println(key, "=>", value)
133 | 	}
134 | }
135 | ```
136 | Output,
137 | ```
138 | en => 1
139 | hh => 2
140 | ```
141 | 
142 | * We can also truncate our map. Truncating means clearing all elements from a map. There are two methods to do that. 
143 | * First one is by iterating over the map and deleting the keys one by one. Example,
144 | ```
145 | package main
146 | 
147 | import "fmt"
148 | 
149 | func main() {
150 | 	codes := map[string]int{"en": 1, "hh": 2}
151 | 
152 | 	for key, _ := range codes {
153 | 		delete(codes, key)
154 | 	}
155 | 	fmt.Println(codes)
156 | }
157 | ```
158 | Output,
159 | ```
160 | map[]
161 | ```
162 | 
163 | * The second method is to simply re-initialize it with an empty map. Example,
164 | 
165 | ```
166 | package main
167 | 
168 | import "fmt"
169 | 
170 | func main() {
171 | 	codes := map[string]int{"en": 1, "hh": 2}
172 | 
173 | 	codes = make(map[string]int)
174 | 	fmt.Println(codes)
175 | }
176 | ```
177 | Output,
178 | ```
179 | map[]
180 | ```
181 | 


--------------------------------------------------------------------------------
/GoLang/Modules, Packages and Imports/01 - go.mod/README.md:
--------------------------------------------------------------------------------
1 | * The go mod init command creates a go.mod file to crack the dependencies in our code. 
2 | 
3 | * A collection of go source code becomes a module when there is a valid go.mod file in its root directory. 
4 | 
5 | * Inside go.mod file we have, the module word along with the module path. Also. the go.mod file specifies the minimum compatible version of go. 
6 | 
7 | * go mod tidy - this command ensures that the mod file matches the source code in the module. It will add any missing module that are required and necessary to build the current module's package and dependencies. 
8 | 


--------------------------------------------------------------------------------
/GoLang/Modules, Packages and Imports/README.md:
--------------------------------------------------------------------------------
 1 | ## Repository ##
 2 | 
 3 | * A place in the version control system, where the source code for a project is stored. 
 4 | 
 5 | ## Module ##
 6 | 
 7 | * Root of a Go library or application stored in a repository. 
 8 | 
 9 | * They consist of one or more packages, which give the module orgnization and structure. 
10 | 
11 | * We can store more than one module in a repository, it is not encouraged. 
12 | 
13 | * Everything within a module is versioned together. 
14 | 
15 | * Maintaining two modules in one repository means tracking separate versions for two different projects in a single repository. 
16 | 
17 | 
18 | 
19 | ## How to create a module ##
20 | 
21 | * Go to the directory where you will be storing your source code. 
22 | 
23 | * After that create a directory where we would be storing our project. Then, cd into that directory.
24 | 
25 | * <b>For this directory to become a Go module, we use the command 'go mod init <module_path>'.</b>
26 | 
27 | * This module path is a globally unique identifier. It could be something like github.com/username and then your repository name. Example, example.com/learn.
28 |   
29 | <b>NOTE:</b> To create a module out of a directory, use the go mod init command.
30 | 


--------------------------------------------------------------------------------
/GoLang/Operators/Arithmetic Operators/README.md:
--------------------------------------------------------------------------------
 1 | * Arithmetic operators are frequently combined with the comparison operator to create a Boolean statement. These operators are used to perform common arithmetic operations, such as addition, subtraction and multiplication. 
 2 | * We have the following arithmetic operators in Golang.
 3 |    
 4 |    1. Addition
 5 |    2. Subtraction
 6 |    3. Multiplication
 7 |    4. Division
 8 |    5. Modulus
 9 |    6. Increment 
10 |    7. Decrement
11 | 


--------------------------------------------------------------------------------
/GoLang/Operators/Assignment Operators/README.md:
--------------------------------------------------------------------------------
1 | * We have the following Assignment Operators:
2 | 
3 |    1. assign ( = )
4 |    2. add and assign ( += )
5 |    3. subtract and assign ( -= )
6 |    4. multiply and assign ( *= )
7 |    5. divide and assign quotient ( /= )
8 |    6. divide and assign modulus ( %= )
9 | 


--------------------------------------------------------------------------------
/GoLang/Operators/Bitwise Operators/README.md:
--------------------------------------------------------------------------------
 1 | * Bitwise Operators are a bit different from the other operators. Bitwise operators work at bit level or perform bit by bit operation. 
 2 | * We have the following bitwise operators in Golang:
 3 |    
 4 |    1. bitwise AND ( & )
 5 |    2. bitwise OR ( | )
 6 |    3. bitwise XOR ( ^ )
 7 |    4. right shift ( >> )
 8 |    5. left shift ( << )
 9 |    
10 |    
11 | ## bitwise AND (&) ##
12 | 
13 | * This operator takes two numbers as operands and does AND operation on every bit of two numbers. 
14 | * Let's see how bitwise AND is going to work for 12 and 25. 
15 | 
16 |  ![Screenshot (131)](https://user-images.githubusercontent.com/98219227/235496446-2dd03db0-2582-46ba-bc51-f78b2ffa1d97.png)
17 | 
18 | 
19 | 
20 | ## bitwise OR (|) ##
21 | 
22 | * Bitwise OR takes two numbers as operand and does OR on every bit of two numbers. 
23 | 
24 | 
25 | 
26 | ## bitwise XOR (^) ##
27 | 
28 | * It takes two numbers as operand and does XOR on every bit of two numbers. The result of XOR is 1 if the two bits are opposite. 
29 | 
30 | 
31 | 
32 | ## left shift (<<) ##
33 | 
34 | * It shifts all bits towards left by a certain number of specified bits. 
35 | 
36 | 
37 | 
38 | ## right shift (>>) ##
39 | 
40 | * It shifts all bits towards right by a certain number of specified bits. 
41 | 
42 | 
43 | 
44 | 
45 | 


--------------------------------------------------------------------------------
/GoLang/Operators/Comparison Operators/README.md:
--------------------------------------------------------------------------------
 1 | * Comparison Operators compare two operands and yield a Boolean value that is true or false. 
 2 | * They allow values of the same data type for comparisons and return true if it matches the comparison and false if it does not. 
 3 | * We have the following Comparison Operators in Golang,
 4 | 
 5 |     1. Equal (==)
 6 |     2. Not equal (!=)
 7 |     3. Less than (<)
 8 |     4. Less than equal to (<=)
 9 |     5. greater than (>)
10 |     6. Greater than equal to (>=)
11 | 
12 | 


--------------------------------------------------------------------------------
/GoLang/Operators/Logical Operators/README.md:
--------------------------------------------------------------------------------
1 | * Logical operators are used to determine the logic between variables or values. 
2 | * We have the following logical operators,
3 | 
4 |    1. Logical AND ( && )
5 |    2. Logical OR ( || )
6 |    3. Logical NOT ( ! )
7 | 


--------------------------------------------------------------------------------
/GoLang/Operators/README.md:
--------------------------------------------------------------------------------
 1 | * Operators are symbols that help us to perform specific mathematical and logical computations on operands. 
 2 | * For example, when we say a+b, the addition sign here is the operator, while a and b are the operands. 
 3 | * In Golang, we can define operators of five types, 
 4 |    
 5 |    1. Comparison operators
 6 |    2. Arithmetic operators 
 7 |    3. Assignment operators
 8 |    4. Bitwise operators
 9 |    5. Logical operators
10 |    
11 | 
12 | 


--------------------------------------------------------------------------------
/GoLang/Pointers/01 - Address and Dereference Operator/README.md:
--------------------------------------------------------------------------------
 1 | * <b>& operator</b> - The address of a variable can be obtained by preceding the name of a variable with an ampersand sign (&), known as address-of operator. 
 2 | 
 3 | * <b>* operator</b> - It is known as the dereference operator. When placed before an address, it returns the value at that address. 
 4 | 
 5 | * Example,
 6 | 
 7 | ```
 8 | package main
 9 | 
10 | import "fmt"
11 | 
12 | func main() {
13 | 	i := 10
14 | 	fmt.Printf("%T %v \n", &i, &i)
15 | 	fmt.Printf("%T %v \n", *(&i), *(&i))
16 | }
17 | ```
18 | Output,
19 | ```
20 | *int 0xc000018098 
21 | int 10
22 | ```
23 | 


--------------------------------------------------------------------------------
/GoLang/Pointers/02 - Declaring and Initialising a Pointer/README.md:
--------------------------------------------------------------------------------
 1 | # Declaration ##
 2 | 
 3 | * Syntax,
 4 | 
 5 | ```
 6 | var <pointer_name> *<data_type>
 7 | ```
 8 | 
 9 | * Example,
10 | 
11 | ```
12 | var ptr *string
13 | ```
14 | 
15 | 
16 | 
17 | # Initialisation #
18 | 
19 | * Syntax, 
20 | 
21 | ```
22 | var <pointer_name> *<data_type> = &<variable_name>
23 | ```
24 | 
25 | * Example,
26 | 
27 | ```
28 | i := 10
29 | var ptr *int = &i
30 | ```
31 | 
32 | * Another way of iniialising a pointer is, 
33 | 
34 | ```
35 | var <pointer_name> = &<variable_name>
36 | ```
37 | 
38 | * Example,
39 | 
40 | ```
41 | p := "Programming"
42 | var ptr = &p
43 | ```
44 | 
45 | * Another method is to use the shorthand operator. Syntax,
46 | 
47 | ```
48 | <pointer_name> := &<variable_name>
49 | ```
50 | 
51 | * Example,
52 | 
53 | ```
54 | h := "hello"
55 | ptr := &h
56 | ```
57 | 
58 | * Example Program,
59 | 
60 | ```
61 | package main
62 | 
63 | import "fmt"
64 | 
65 | func main() {
66 | 	s := "hello"
67 | 	var b *string = &s
68 | 	fmt.Println(b)
69 | 	var a = &s
70 | 	fmt.Println(a)
71 | 	c := &s
72 | 	fmt.Println(c)
73 | }
74 | ```
75 | Output,
76 | ```
77 | 0xc000054270
78 | 0xc000054270
79 | 0xc000054270
80 | ```
81 | 


--------------------------------------------------------------------------------
/GoLang/Pointers/03 - Dereferencing a pointer/README.md:
--------------------------------------------------------------------------------
 1 | * Syntax,
 2 | 
 3 | ```
 4 | *<pointer_name> 
 5 | ```
 6 | 
 7 | * We can also change the value of the variable using this syntax,
 8 | 
 9 | ```
10 | *<pointer_name> = <new_value>
11 | ```
12 | 
13 | * Example,
14 | 
15 | ```
16 | package main
17 | 
18 | import "fmt"
19 | 
20 | func main() {
21 | 	s := "hello"
22 | 	fmt.Printf("%T %v \n", s, s)
23 | 	ps := &s
24 | 	*ps = "world"
25 | 	fmt.Printf("%T %v \n", s, s)
26 | 	fmt.Printf("%T %v \n", ps, *ps)
27 | }
28 | ```
29 | Output,
30 | ```
31 | string hello 
32 | string world 
33 | *string world 
34 | ```
35 | 


--------------------------------------------------------------------------------
/GoLang/Pointers/04 - Passing by Value in Functions  /README.md:
--------------------------------------------------------------------------------
 1 | * Function is called by directly passing the value of the variable as an argument.
 2 | 
 3 | * the parameter is copied into another location of your memory.
 4 | 
 5 | * So, when accessing or modifying the variable within your function, only the copy is accessed or modified, and the original value is never modified.
 6 | 
 7 | * All basic types (int, float, bool, string, array) are passed by value.
 8 | 
 9 | * Example,
10 | 
11 | ```
12 | package main
13 | 
14 | import "fmt"
15 | 
16 | func modify(s string) {
17 | 	s = "world"
18 | }
19 | 
20 | func main() {
21 | 	a := "hello"
22 | 	fmt.Println(a)
23 | 	modify(a)
24 | 	fmt.Println(a)
25 | }
26 | ```
27 | Output,
28 | ```
29 | hello
30 | hello
31 | ```
32 | 


--------------------------------------------------------------------------------
/GoLang/Pointers/README.md:
--------------------------------------------------------------------------------
1 | * Pointer is a variable that holds the memory address of another variable. 
2 | 
3 | * They point where the memory is allocated and provide ways to find or even change the value located at the memory location.
4 | 
5 | * Zero value of a pointer is nil.
6 | 


--------------------------------------------------------------------------------
/GoLang/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/GoLang/Slices/README.md:
--------------------------------------------------------------------------------
  1 | * A slice is an abstraction of an array. 
  2 | 
  3 | * They are also index-based and have a size, but is resized when needed. 
  4 | 
  5 | * A slice has three major components:
  6 | 
  7 |    1. Pointer : used to point to the first element of the array that is accesible through that slice. It is not necessary that the pointed element is laways the first element of the array.
  8 |    
  9 |    2. Length : number of elements it contains.
 10 | 
 11 |    3. Capacity : number of elements in the underlying array counting from the first element in the slice. 
 12 |    
 13 | * Length and capacity of a slice can be obtained from functions len() and cap() respectively. 
 14 | 
 15 | * To declare a slice, we declare an array without any size. Syntax,
 16 | 
 17 | ```
 18 | <slice_name> := []<data_type>{<values>}
 19 | ```
 20 | ```
 21 | nums := []int{1,2,3}
 22 | ```
 23 | * Example,
 24 | 
 25 | ```
 26 | package main
 27 | 
 28 | import "fmt"
 29 | 
 30 | func main() {
 31 | 	slice := []int{1, 2, 3}
 32 | 	fmt.Println(slice)
 33 | }
 34 | ```
 35 | Output,
 36 | ```
 37 | [1 2 3]
 38 | ```
 39 | 
 40 | * The core concept of slice is being a reference to the array. 
 41 | 
 42 | * To create a slice from an array, we have a start index and an end index. The element on the start index is included but the element at the end index is excluded. Syntax,
 43 | 
 44 | ```
 45 | slice := array[start_index : end_index]
 46 | ```
 47 | Example,
 48 | ```
 49 | package main
 50 | 
 51 | import "fmt"
 52 | 
 53 | func main() {
 54 | 	arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 55 | 	slice := arr[1:8]
 56 | 	fmt.Println(slice)
 57 | }
 58 | ```
 59 | Output,
 60 | ```
 61 | [2 3 4 5 6 7 8]
 62 | ```
 63 | 
 64 | * We can even declare and initialize a slice using another slice. Syntax will be same as in the above case.
 65 | 
 66 | ```
 67 | slice_2 = slice_1[1:4]
 68 | ```
 69 | 
 70 | * There is one more way of declaring a slice and that is through the make function. It takes three parameters: data type, length, capacity(optional).
 71 | * Syntax,
 72 | 
 73 | ```
 74 | slice := make([]<data_type, length, capacity)
 75 | ```
 76 | Generally, make() is used to create an empty slice. So, if we print that slice, we will get zero value, since we have not initialised the slice yet. 
 77 | 
 78 | * When you change a value in the slice, it also gets changed in the underlying array, since slice is a reference to an underlying array. 
 79 | 
 80 | * append() is a built-in function which adds the elements at the end of the slice. Example,
 81 | 
 82 | ```
 83 | slice = append(slice, 7, 8, 9)
 84 | ```
 85 | 
 86 | <b>NOTE</b>: Capacity of our slice gets doubled whenever we append our slice more than it's present capacity.
 87 | 
 88 | * We can append a slice to another slice by using the three dots. Syntax,
 89 | 
 90 | ```
 91 | slice = append(slice, slice_1...)
 92 | ```
 93 | 
 94 | * We can delete elements from a slice by creating a new slice which does not contain the element that has to be deleted. Example,
 95 | 
 96 | ```
 97 | package main
 98 | 
 99 | import "fmt"
100 | 
101 | func main() {
102 | 	arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
103 | 	i := 2
104 | 	fmt.Println(arr)
105 | 
106 | 	slice_1 := arr[:i]
107 | 	slice_2 := arr[i+1:]
108 | 
109 | 	new_slice := append(slice_1, slice_2...)
110 | 	fmt.Println(new_slice)
111 | }
112 | ```
113 | Output,
114 | ```
115 | [1 2 3 4 5 6 7 8 9 10]
116 | [1 2 4 5 6 7 8 9 10]
117 | ```
118 | 
119 | * To copy elements from one slice to another we use copy() function. It also returns the number of elements that have been copied which is the minimum of the length of the destination slice or the length of the source slice. Note that the slices must be initialized with the same data type. Example,
120 | 
121 | ```
122 | package main
123 | 
124 | import "fmt"
125 | 
126 | func main() {
127 | 	src_slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
128 | 	dest_slice := make([]int, 3)
129 | 
130 | 	num := copy(dest_slice, src_slice)
131 | 
132 | 	fmt.Println(dest_slice)
133 | 	fmt.Println("Numbers of elements copied: ", num)
134 | }
135 | ```
136 | Output,
137 | ```
138 | [1 2 3]
139 | Numbers of elements copied:  3
140 | ```
141 | 
142 | * Looping through a slice is same as looping through an array.
143 | 
144 | 


--------------------------------------------------------------------------------
/GoLang/Struct, Methods and Interfaces/01 - Declaring and Initializing a Struct/README.md:
--------------------------------------------------------------------------------
 1 | # Declaration #
 2 | 
 3 | * Syntax,
 4 | 
 5 | ```
 6 | type <struct_name> struct {
 7 |     // list of fields
 8 | }
 9 | ```
10 | 
11 | * Example,
12 | 
13 | ```
14 | type square struct {
15 |     x float64
16 |     y float64
17 | }
18 | ```
19 | 
20 | * Type keyword is used to create a new user-defined type. 
21 | 
22 | 
23 | 
24 | # Initialization #
25 | 
26 | * There are many ways of doing this.
27 | 
28 | 1.
29 | ```
30 | var <variable_name> <struct_name> 
31 | ```
32 | 
33 | 2.
34 | ```
35 | <variable_name> := new(<struct_name>)
36 | ```
37 | 
38 | 3.
39 | ```
40 | <variable_name> := <struct_name> {
41 | <field_name>: <value>,
42 | <field_name>: <value>,
43 | }
44 | ```
45 | 


--------------------------------------------------------------------------------
/GoLang/Struct, Methods and Interfaces/02 - Accessing Fields/README.md:
--------------------------------------------------------------------------------
 1 | * We can access fields of a struct using the dot operator. Syntax,
 2 | 
 3 | ```
 4 | <variable_name>.<field_name>
 5 | ```
 6 | 
 7 | * Example,
 8 | 
 9 | ```
10 | package main
11 | 
12 | import "fmt"
13 | 
14 | type square struct {
15 | 	x int
16 | 	y int
17 | }
18 | 
19 | func main() {
20 | 	var c square
21 | 	c.x = 5
22 | 	c.y = 5
23 | 	fmt.Printf("%+v \n", c)
24 | }
25 | ```
26 | Output,
27 | ```
28 | {x:5 y:5}
29 | ```
30 | 


--------------------------------------------------------------------------------
/GoLang/Struct, Methods and Interfaces/03 - Passing Structs to Functions/README.md:
--------------------------------------------------------------------------------
1 | * Refer to PDF.
2 | 


--------------------------------------------------------------------------------
/GoLang/Struct, Methods and Interfaces/04 - Comparing Structs/README.md:
--------------------------------------------------------------------------------
1 | * Refer to PDF.
2 | 


--------------------------------------------------------------------------------
/GoLang/Struct, Methods and Interfaces/05 - Methods/README.md:
--------------------------------------------------------------------------------
 1 | * Method is similar to a function with one simple addition. 
 2 | 
 3 | * A method augments a function by adding an extra parameter section immediately after the func keyword that accepts a single argument. This argument is called a receiver. 
 4 | 
 5 | * Whenever there is a strong relationship between a function and a struct, we can use a method.
 6 | 
 7 | * A method is a function that has a defined receiver. 
 8 | 
 9 | * Syntax, 
10 | 
11 | ```
12 | func (<receiver>) <method_name>(<parameters>) <return_params> {
13 |     //code
14 | }
15 | ```
16 | 
17 | * Some methods can be associated with a named type, circle for instance, or a pointer to a named type. Example,
18 | 
19 | ```
20 | func (c Circle) area() float64 {
21 | //code
22 | }
23 | ```
24 | And,
25 | ```
26 | func (c *Circle) area() float64 {
27 | //code
28 | }
29 | ```
30 | 


--------------------------------------------------------------------------------
/GoLang/Struct, Methods and Interfaces/06 - Method Sets/README.md:
--------------------------------------------------------------------------------
1 | * Set of methods that are available to a data type.
2 | 
3 | * They are a useful way to encapsulate functionality. 
4 | 


--------------------------------------------------------------------------------
/GoLang/Struct, Methods and Interfaces/README.md:
--------------------------------------------------------------------------------
1 | * They are user-defined data type.
2 | 
3 | * A structure groups together data elements.
4 | 
5 | * It provides a way to reference a series of grouped values through a single variable name.
6 | 
7 | * It is used when it makes sense to group or associate two or more data variables.
8 | 


--------------------------------------------------------------------------------
/GoLang/Type of Variable/README.md:
--------------------------------------------------------------------------------
 1 | * Let us know how can you find the data type of a variable? 
 2 | * To check or find the type of variable or object in Golang, we can use the capital T format specifier or the reflect.TypeOf function from the reflect package. \
 3 | 
 4 | <br>
 5 | 
 6 | * Let's start with capital T format specifier. This is the simplest way to find the type of variable in Golang. Here is an example,
 7 | 
 8 | ```
 9 | package main
10 | 
11 | import "fmt"
12 | 
13 | func main() {
14 | 	var a string
15 | 	var b int
16 | 
17 | 	fmt.Printf("a is %T and b is %T \n", a, b)
18 | }
19 | ```
20 | 
21 | * Output will be,
22 | 
23 | ```
24 | a is string and b is int
25 | ```
26 | 
27 | <br>
28 | 
29 | * Now the TypeOf function can be used, not just for finding out the data type of the variable but also for finding the type of simply a value or literal as we say. 
30 | 
31 | ```
32 | package main
33 | 
34 | import (
35 | 	"fmt"
36 | 	"reflect"
37 | )
38 | 
39 | func main() {
40 | 	var a string = "Hey all"
41 | 	var b int = 50
42 | 
43 | 	fmt.Printf("a = %v is of type %v \n", a, reflect.TypeOf(a))
44 | 	fmt.Printf("b = %v is of type %v \n", b, reflect.TypeOf(b))
45 | }
46 | ```
47 | 
48 | * Output will be, 
49 | 
50 | ```
51 | a = Hey all is of type string 
52 | b = 50 is of type int
53 | ```
54 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Naved Ahmad
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Python/Accepting user input/README.md:
--------------------------------------------------------------------------------
 1 | * In order to make our program more convenient, our program should be able to accept any input.
 2 | * The input value that we get from input( ) function, is always treated as a string and not a number.
 3 | * Process of turning one data type to another is called casting.
 4 | * Here is an example.
 5 | 
 6 | ```
 7 | calculation_to_units = 24 * 60 * 60
 8 | name_of_unit = "seconds"
 9 | 
10 | 
11 | def days_to_units(num_of_days):
12 |     return f"{num_of_days} Days are {num_of_days * calculation_to_units} {name_of_unit}"
13 |     
14 |     
15 | user_input = input("Hey, enter a value\n")
16 | user_input_number = int(user_input)
17 | 
18 | calculated_value = days_to_units(user_input_number)
19 | print(calculated_value)
20 | ```
21 | 


--------------------------------------------------------------------------------
/Python/Conditionals and Boolean Data Type/README.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | calculation_to_units = 24 * 60 * 60
 3 | name_of_unit = "seconds"
 4 | 
 5 | 
 6 | def days_to_units(num_of_days):
 7 |     if num_of_days > 0:
 8 |         return f"{num_of_days} Days are {num_of_days * calculation_to_units} {name_of_unit}"
 9 |     else:
10 |         return "Wrong Input"
11 | 
12 | 
13 | user_input = input("Hey, enter a value\n")
14 | user_input_number = int(user_input)
15 | 
16 | calculated_value = days_to_units(user_input_number)
17 | print(calculated_value)
18 | ```
19 | 
20 | 
21 | 
22 | ## Boolean Data Type ##
23 | 
24 | * Boolean can only have two values: <b>TRUE</b> or <b>FALSE</b>
25 | 
26 | ```
27 | calculation_to_units = 24 * 60 * 60
28 | name_of_unit = "seconds"
29 | 
30 | 
31 | def days_to_units(num_of_days):
32 |     print(num_of_days > 0)       // this will print either TRUE or FALSE
33 |     if num_of_days > 0:
34 |         return f"{num_of_days} Days are {num_of_days * calculation_to_units} {name_of_unit}"
35 |     elif num_of_days == 0:      //  elif is a combination of else and if
36 |         return "0 is not an accepted input here"
37 |     else:
38 |         return "Wrong Input"
39 | 
40 | 
41 | user_input = input("Hey, enter a value\n")
42 | user_input_number = int(user_input)
43 | 
44 | calculated_value = days_to_units(user_input_number)
45 | print(calculated_value)
46 | ```
47 | 
48 | 
49 | 
50 | * You can have multiple elif between if / else statements.
51 | * type( ) prints out the data type of the variable. For example,
52 | 
53 | ```
54 | condition_check = num_of_days > 0
55 | print(type(condition_check))       // an example of nested function call
56 | ```
57 | * Another small example,
58 | ```
59 | print(type(30.99))
60 | ```
61 | 
62 | 
63 | 
64 | ```
65 | calculation_to_units = 24 * 60 * 60
66 | name_of_unit = "seconds"
67 | 
68 | 
69 | def days_to_units(num_of_days):
70 |     return f"{num_of_days} Days are {num_of_days * calculation_to_units} {name_of_unit}"
71 | 
72 | 
73 | def validate_and_execute():
74 |     if user_input.isdigit():
75 |         user_input_number = int(user_input)
76 |         if user_input_number > 0:
77 |             calculated_value = days_to_units(user_input_number)
78 |             print(calculated_value)
79 |         elif user_input_number == 0:
80 |             print("0 is not an accepted input here")
81 |     else:
82 |         print("Your input is not a number")
83 | 
84 | 
85 | user_input = input("Hey, enter a value\n")
86 | validate_and_execute()
87 | ```
88 | 


--------------------------------------------------------------------------------
/Python/Countdown App/README.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | from datetime import datetime
 3 | 
 4 | user_input = input("enter your goal and a deadline separated by colon\n")
 5 | input_list = user_input.split(":")
 6 | 
 7 | goal = input_list[0]
 8 | deadline = input_list[1]
 9 | 
10 | deadline_date = datetime.strptime(deadline, "%d.%m.%Y")
11 | today_date = datetime.today()
12 | time_till = deadline_date - today_date
13 | 
14 | time_remaining = int(time_till.total_seconds() / 60 / 60)
15 | print(f"Time remaining for your goal: {goal} is {time_remaining} hours")
16 | ```
17 | 


--------------------------------------------------------------------------------
/Python/Dictionary Data Type/README.md:
--------------------------------------------------------------------------------
 1 | * It is a data type which is used to store <b>key:value</b> pairs.
 2 | * It does not allow duplicate values.
 3 | * Example,
 4 | ```
 5 | days_and_unit_dictionary = {"days": 20, "unit": "hours"}
 6 | ```
 7 | 
 8 | 
 9 | 
10 | ### Accesing items ina dictionary ###
11 | 
12 | * Items can be accessed by its <b>key name</b>.
13 | * You can use <b>square brackets</b> or <b>get()</b> method.
14 | * Example,
15 | ```
16 | days_and_unit_dictionary["days"]
17 | 
18 |           OR
19 |                    
20 | days_and_unit_dictionary.get("days")
21 | ```
22 | 
23 | 
24 | 
25 | Now, our new program will look like this, 
26 | ```
27 | def days_to_units(num_of_days, conversion_unit):
28 |     if conversion_unit == "hours":
29 |         return f"{num_of_days} Days are {num_of_days * 24} {conversion_unit}"
30 |     elif conversion_unit == "minutes":
31 |         return f"{num_of_days} Days are {num_of_days * 24 * 60} {conversion_unit}"
32 |     else:
33 |         return "unsupported unit"
34 | 
35 | 
36 | def validate_and_execute():
37 |     try:
38 |         user_input_number = int(days_and_unit_dictionary["days"])
39 | 
40 |         if user_input_number > 0:
41 |             calculated_value = days_to_units(user_input_number, days_and_unit_dictionary["unit"])
42 |             print(calculated_value)
43 |         elif user_input_number == 0:
44 |             print("0 is not an accepted input here")
45 |         else:
46 |             print("you entered a negative number")
47 |     except ValueError:
48 |         print("Your input is not a number")
49 | 
50 | 
51 | user_input = ""
52 | while user_input != "exit":
53 |     user_input = input("Hey, enter number of days and conversion unit!\n")
54 |     days_and_unit = user_input.split(":")
55 |     print(days_and_unit)
56 |     days_and_unit_dictionary = {"days": days_and_unit[0], "unit": days_and_unit[1]}
57 |     print(days_and_unit_dictionary)
58 |     print(type(days_and_unit_dictionary))
59 |     validate_and_execute()
60 | ```
61 | 


--------------------------------------------------------------------------------
/Python/First Python Program/README.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | print(f"20 Days are {20 * 24 * 60} minutes")
 3 | ```
 4 | 
 5 | This program will simply print the number of minutes that are in 20 days.<br>
 6 | So the output will be, 
 7 | 
 8 | ```
 9 | 20 Days are 28800 minutes
10 | ```
11 | 


--------------------------------------------------------------------------------
/Python/Functions/README.md:
--------------------------------------------------------------------------------
 1 | * A function is defined using the 'def' keyword. 
 2 | * Syntax,
 3 | ```
 4 | def <name_of_function>():
 5 |     line 1 of code
 6 |     line 2 of code
 7 | ```
 8 | 
 9 | 
10 | 
11 | * Here is an example of how to use function in Python.
12 | ```
13 | calculation_to_units = 24 * 60 * 60
14 | name_of_unit = "seconds"
15 | 
16 | 
17 | def days_to_units():
18 |     print(f"20 Days are {20 * calculation_to_units} {name_of_unit}")
19 |     print("All Good!")
20 | 
21 | 
22 | days_to_units()
23 | ```
24 | Output of the above program will be,
25 | ```
26 | 20 Days are 1728000 seconds
27 | All Good!
28 | ```
29 | Note that the function will not be executed unless and until it is called.
30 | 
31 | 
32 | 
33 | # Function Parameters #
34 | * Information can be passed into functions as parameters.
35 | * Parameters are also called arguments.
36 | * Here is an example,
37 | ```
38 | calculation_to_units = 24 * 60 * 60
39 | name_of_unit = "seconds"
40 | 
41 | 
42 | def days_to_units(num_of_days, custom_message):
43 |     print(f"{num_of_days} Days are {num_of_days * calculation_to_units} {name_of_unit}")
44 |     print(custom_message)
45 | 
46 | 
47 | days_to_units(20, "Awesome!")
48 | days_to_units(35, "Looks good")
49 | days_to_units(50, "nice")
50 | days_to_units(110, "great")
51 | ```
52 | Output of the above program will be,
53 | ```
54 | 20 Days are 1728000 seconds
55 | Awesome!
56 | 35 Days are 3024000 seconds
57 | Looks good
58 | 50 Days are 4320000 seconds
59 | nice
60 | 110 Days are 9504000 seconds
61 | great
62 | ```
63 | 
64 | 
65 | 
66 | ## Function returning a value ##
67 | 
68 | * Here is an example of a function returning a value
69 | 
70 | ```
71 | calculation_to_units = 24 * 60 * 60
72 | name_of_unit = "seconds"
73 | 
74 | 
75 | def days_to_units(num_of_days):
76 |     return f"{num_of_days} Days are {num_of_days * calculation_to_units} {name_of_unit}"
77 |     
78 |     
79 | my_var = days_to_units(35)
80 | print(my_var)
81 | ```
82 | 


--------------------------------------------------------------------------------
/Python/Loops/README.md:
--------------------------------------------------------------------------------
 1 | * Loops are used to execute logic multiple times.
 2 | * Python has 2 loop commands.
 3 | 
 4 | ## While Loops ##
 5 | * It executes a set of statements as long as a condition is true.
 6 | * Here is an example.
 7 | 
 8 | 
 9 | 
10 | ```
11 | calculation_to_units = 24 * 60 * 60
12 | name_of_unit = "seconds"
13 | 
14 | 
15 | def days_to_units(num_of_days):
16 |     return f"{num_of_days} Days are {num_of_days * calculation_to_units} {name_of_unit}"
17 | 
18 | 
19 | def validate_and_execute():
20 |     try:
21 |         user_input_number = int(user_input)
22 |         if user_input_number > 0:
23 |             calculated_value = days_to_units(user_input_number)
24 |             print(calculated_value)
25 |         elif user_input_number == 0:
26 |             print("0 is not an accepted input here")
27 |         else:
28 |             print("you entered a negative number")
29 |     except ValueError:
30 |         print("Your input is not a number")
31 | 
32 | 
33 | user_input = ""
34 | while user_input != "exit":
35 |     user_input = input("Hey, enter a value\n")
36 |     validate_and_execute()
37 | ```
38 | 
39 | 
40 | ## Lists and For Loops ##
41 | 
42 | 
43 | * Lists is a datatype to store multiple items in a single variable.
44 | * split( ) is a function that returns the lists of any input value.
45 | * Here is an example.
46 | 
47 | ```
48 | calculation_to_units = 24 * 60 * 60
49 | name_of_unit = "seconds"
50 | 
51 | 
52 | def days_to_units(num_of_days):
53 |     return f"{num_of_days} Days are {num_of_days * calculation_to_units} {name_of_unit}"
54 | 
55 | 
56 | def validate_and_execute():
57 |     try:
58 |         user_input_number = int(num_of_days_element)
59 |         if user_input_number > 0:
60 |             calculated_value = days_to_units(user_input_number)
61 |             print(calculated_value)
62 |         elif user_input_number == 0:
63 |             print("0 is not an accepted input here")
64 |         else:
65 |             print("you entered a negative number")
66 |     except ValueError:
67 |         print("Your input is not a number")
68 | 
69 | 
70 | user_input = ""
71 | while user_input != "exit":
72 |     user_input = input("Hey, enter a value\n")
73 |     print(type(user_input.split(", ")))
74 |     print(user_input.split(", "))
75 |     for num_of_days_element in user_input.split(", "):
76 |         validate_and_execute()
77 | ```
78 | 
79 | 
80 | 
81 | * You must be wondering on how to create lists within our program.
82 | * Here is an example.
83 | 
84 | ```
85 | my_list = ["January", "February", "March"]
86 | print(my_list[2])
87 | my_list.append("April")         // to add an element to a list
88 | print(my_list)
89 | print(my_list[3])
90 | my_list.remove("January")      // to delete an element from a list
91 | print(my_list)
92 | ```
93 | 
94 | * append( ) is a function which is used to add a new item to a list.
95 | 


--------------------------------------------------------------------------------
/Python/Modules/README.md:
--------------------------------------------------------------------------------
1 | * Till now we have been writing all our code in just one file, which is actually not a good practice. Instead we need to structure our code and divide the logic between multiple different python files.
2 | * We do that using <b>modules</b>.
3 | 


--------------------------------------------------------------------------------
/Python/Object Oriented Programming/README.md:
--------------------------------------------------------------------------------
 1 | ## Class ##
 2 | * A class is like an object constructor.
 3 | * All classes have a __ init __() function.
 4 | * __ init __() is executed automaticaly whenever we create the objects from this class.
 5 | * This __ init() __ is constructor in python. This will help us construct objects from that user class.
 6 | 
 7 | 
 8 | 
 9 | ```
10 | class User:
11 |     def __init__(self, e, n, p, cjt):
12 |         self.email = e
13 |         self.name = n
14 |         self.password = p
15 |         self.current_job_title = cjt
16 | 
17 |     def change_password(self, new_p):
18 |         self.password = new_p
19 | 
20 |     def change_job_title(self, new_jt):
21 |         self.current_job_title = new_jt
22 | ```
23 | 
24 | * <b>self</b> parameter is a reference to the current instance of the class. It is used to access variables that belong to that class.
25 | 


--------------------------------------------------------------------------------
/Python/README.md:
--------------------------------------------------------------------------------
1 | Resource: https://youtu.be/t8pPdKYpowI
2 | 
3 | 
4 | 
5 | ## Open the respective folders to learn about those topics ##
6 | 
7 | 


--------------------------------------------------------------------------------
/Python/Scope/README.md:
--------------------------------------------------------------------------------
 1 | * Avariable is only available from inside the region it is created.
 2 | 
 3 | * <b>Global Scope</b> = variables available from within any scope
 4 | * <b>Local Scope</b> = variables created inside any function can only be used inside that function
 5 | 
 6 | 
 7 | 
 8 | ```
 9 | calculation_to_units = 24 * 60 * 60
10 | name_of_unit = "seconds"
11 | 
12 | 
13 | def days_to_units(num_of_days, custom_message):
14 |     print(f"{num_of_days} Days are {num_of_days * calculation_to_units} {name_of_unit}")
15 |     print(custom_message)
16 | 
17 | 
18 | days_to_units(20, "Awesome!")
19 | days_to_units(35, "Looks good")
20 | days_to_units(50, "nice")
21 | days_to_units(110, "great")
22 | ```
23 | 
24 | In the above example, the two variables passed in the function parameter are available only inside that function because they were created within that function.
25 | 
26 | 
27 | 
28 | * Global variables are accessible to all the functions.
29 | 


--------------------------------------------------------------------------------
/Python/Sets/README.md:
--------------------------------------------------------------------------------
 1 | * Unlike Lists datatype, Sets datatype doesn't allow storing duplicate values.
 2 | * set( ) function is used to convert an existing list into a set. The parameter of our set( ) function will be the list.
 3 | * Lists is represented using [ ] brackets whereas sets is represented using { } brackets.
 4 | <br>
 5 | 
 6 | * Here is an example on how you can create sets in your program.
 7 | 
 8 | ```
 9 | my_set = {"January", "February", "March"}
10 | for element in my_set:
11 |     print(element)
12 |     
13 | my_set.add("April")             // to add an element in a set
14 | print(my_set)
15 | my_set.remove("January")       //  to delete an element from a set
16 | print(my_set)
17 | ```
18 | * However, we cannot access elements of a set like we did on lists. Items in a set set do not have a defined order. 
19 | * Instead we can only access the elements of a set in a loop.
20 | 


--------------------------------------------------------------------------------
/Python/Try or Except/README.md:
--------------------------------------------------------------------------------
 1 | * The <b>try</b> block: let's you "test" a block of code for errors.
 2 | * The <b>except</b> block: catches the error and let's you handle it.
 3 | 
 4 | 
 5 | 
 6 | ```
 7 | calculation_to_units = 24 * 60 * 60
 8 | name_of_unit = "seconds"
 9 | 
10 | 
11 | def days_to_units(num_of_days):
12 |     return f"{num_of_days} Days are {num_of_days * calculation_to_units} {name_of_unit}"
13 | 
14 | 
15 | def validate_and_execute():
16 |     try:                                  
17 |         user_input_number = int(user_input)
18 |         if user_input_number > 0:
19 |             calculated_value = days_to_units(user_input_number)
20 |             print(calculated_value)
21 |         elif user_input_number == 0:
22 |             print("0 is not an accepted input here")
23 |         else:
24 |             print("you entered a negative number")
25 |     except ValueError:
26 |         print("Your input is not a number")
27 | 
28 | 
29 | user_input = input("Hey, enter a value\n")
30 | validate_and_execute()
31 | ```
32 | 
33 | 
34 | 
35 | * We can also leave <b>except</b> without anything after it, so it will handle any kind of error.
36 | 


--------------------------------------------------------------------------------
/Python/Variables/README.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | calculation_to_units = 24 * 60 * 60
 3 | name_of_unit = "seconds"
 4 | 
 5 | print(f"20 Days are {20 * calculation_to_units} {name_of_unit}")
 6 | print(f"35 Days are {35 * calculation_to_units} {name_of_unit}")
 7 | print(f"50 Days are {50 * calculation_to_units} {name_of_unit}")
 8 | print(f"110 Days are {110 * calculation_to_units} {name_of_unit}")
 9 | ```
10 | 
11 | 
12 | 
13 | Output of the above program will be,
14 | 
15 | ```
16 | 20 Days are 1728000 seconds
17 | 35 Days are 3024000 seconds
18 | 50 Days are 4320000 seconds
19 | 110 Days are 9504000 seconds
20 | ```
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # DevOps-Learnings
2 | 
3 | Hey folks👋, I will document my DevOps learnings here
4 | 


--------------------------------------------------------------------------------