Learn how to fully clean up Git and GitHub CLI before reinstalling. This complete guide covers credential removal, SSH key management, Git initialization, Codespaces setup, Git configuration, and advanced terminal shortcuts.

Cleaning Up Git and GitHub CLI Before Reinstallation

Before reinstalling Git or GitHub CLI (gh), it’s a good practice to ensure all previous configurations and credentials are fully removed. Here's how to do a complete cleanup:

📉 Logout from GitHub CLI

gh auth logout -h github.com

This logs you out of GitHub via GitHub CLI.

🔍 Remove Git Credentials and Configurations

rm ~/.git-credentials           # Deletes saved HTTPS credentials
rm ~/.gitconfig                # Removes global Git configuration file

🔐 Clear SSH Keys (Optional)

rm -rf ~/.ssh/                 # Removes all SSH keys and configurations

Note: Only do this if you're sure you want to delete all SSH keys.

🔢 Clear GitHub CLI Config

rm -rf ~/.config/gh            # Deletes GitHub CLI config directory

❌ Reject Any Remaining Credentials

echo "url=https://github.com" | git credential reject

If that doesn't work:

git credential reject https://github.com

1. GitHub CLI (gh) and Authentication

The gh command-line tool allows you to interact with GitHub directly from your terminal. It simplifies repo management, pull requests, issues, and CI/CD workflows.

🔐 Authenticate GitHub CLI

gh auth login

Once configured, you can see your Git global settings:

git config --list --global

2. Initializing a Git Repository

⚖️ Git Initialization (git init)

git init
ls -la            # Lists all files including hidden ones
ls -la .git        # View the .git directory

🗂️ Understanding the .git Folder

• HEAD: Points to the current branch.

• config: Stores repository settings.

• refs/: Contains references to commits (branches and tags).

• objects/: Stores commit objects.

• hooks/: Scripts that trigger on Git events.

View contents:

cat .git/HEAD
cat .git/config
ls -la .git/refs/heads/   # See available branches
ls -la .git/objects/

✅ Staging (git add <file>)

git add file.txt

Git updates:

.git/index  # The Staging Area

List staged files:

git ls-files --stage

📝 Committing (git commit -m "message")

git commit -m "Initial commit"

Git writes data into:

.git/objects/
├── info/
├── pack/
├── 9f/2345abc...  # Blob: actual file content
├── 7a/6bcd123...  # Tree: directory structure
├── fc/67de89...   # Commit object with metadata

Inspect commit object:

git cat-file -p <commit-hash>

🔗 Connecting Remote (git remote add origin <url>)

git remote add origin https://github.com/your/repo.git

This updates:

.git/config  # Stores remote origin URL

↗️ Pushing Changes (git push)

git push origin main

Push sends commits to the remote repository and updates:

.git/refs/remotes/  # Tracks state of remotes

If you're interested in understanding Git internals, refer to the Git Internals Documentation page.

⏪ Undoing Commits

Undo the last commit (keep changes unstaged):

git reset --soft HEAD~1

Undo the last commit (discard changes):

git reset --hard HEAD~1

🧩 Resolving Merge Conflicts

git status                  # Check conflicts
nano <conflicted_file>      # Edit the file to resolve conflicts
git add <conflicted_file>
git commit -m "Resolved merge conflict"

3. Git Configuration and Credential Management

🔍 Checking Git Configuration

git config --list --local     # Show local repository settings
git config --global --list    # Show global settings

🛡️ Storing Credentials

• macOS:

git config --global credential.helper osxkeychain

• Linux:

git config --global credential.helper cache

📝 Changing Default Editor

• Use Nano:

git config --global core.editor nano

• Use VS Code:

git config --global core.editor "code --wait"

4. Working in GitHub Codespaces

1. Open your repository in GitHub.

2. Click Code > Codespaces.

3. Click Continue Working in GitHub Codespace.

4. Select an instance type based on your project needs:

   • Basic: Suitable for lightweight projects.

   • Standard: Recommended for most web and mobile development.

   • Performance: For complex builds or heavy computation.

5. GitHub SSH Key Setup

🔑 Generate a New SSH Key

ssh-keygen -t ed25519 -C "your_email@example.com"

🔗 Add SSH Key to GitHub

cat ~/.ssh/id_ed25519.pub

Then add it to GitHub: Settings > SSH and GPG keys.

✅ Test SSH Connection

ssh -T git@github.com

6. Bonus: Configure Terminal for Quick Search and URL Opening

Wouldn’t it be great if you could open websites or search Google directly from the terminal using a simple command like:

oh "github.com"
# (Opens https://github.com in your browser)

oh "how to install python"
# (Searches Google for "how to install python")

📌 Step 1: Check Your Default Shell

echo $SHELL

• If it contains zsh: edit ~/.zshrc

• If it contains bash: edit ~/.bashrc

📌 Step 2: Add the Function

For macOS (uses open)

oh() {
  local input="$*"
  if [[ "$input" =~ ^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
    open "https://$input"
  else
    open "https://www.google.com/search?q=$(echo "$input" | tr ' ' '+')"
  fi
}

For Linux (uses xdg-open)

oh() {
  local input="$*"
  if [[ "$input" =~ ^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
    xdg-open "https://$input"
  else
    xdg-open "https://www.google.com/search?q=$(echo "$input" | tr ' ' '+')"
  fi
}

For Windows (uses start)

oh() {
  local input="$*"
  if [[ "$input" =~ ^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
    powershell -c "Start-Process 'https://$input'"
  else
    powershell -c "Start-Process 'https://www.google.com/search?q=$(echo \"$input\" | tr ' ' '+')'"
  fi
}

✅ Step 3: Apply the Changes

source ~/.zshrc  # Or ~/.bashrc depending on your shell

🚀 Try It Out!

oh github.com
# Opens https://github.com

oh "best terminal commands for Mac"
# Opens Google search

🌍 Resources:

• Git Documentation

• GitHub Repository

• Shared Arc Folders

📌 Full Guide & Commands Here 👉 https://bit.ly/primary-dev-setup

macOS Setup

1. Searching GitHub from Mac Spotlight

Press Cmd + Space and type github.com to quickly open GitHub in your default browser.

2. Signing Up on GitHub

1. Visit GitHub and click Sign Up.

2. Provide an email, username, and password.

3. Follow the verification steps.

Password Recommendations:

• Use at least 10 characters.

• Combine uppercase, lowercase, numbers, and special characters.

3. Creating a GitHub Repository

1. Go to GitHub New Repository.

2. Enter Repository Name: osagiebello/test.

3. Keep everything default and click Create Repository.

4. Copy the suggested Git commands for pushing to GitHub.

4. Opening the Repository in GitHub Web Editor

Change .com to .dev: github.dev/osagiebello/test to open a VS Code-like web editor.

5. Setting Up Git on Terminal

Checking Git Installation

git --version

Installing Git (Optional)

brew install git

Checking Git Configuration

git config --list
git config --global --list

Configuring Git User

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

Setting Default Branch to main

git config --global init.defaultBranch main

Setting VS Code as Default Editor

git config --global core.editor "code --wait"

6. Initializing a Git Repository & Pushing to GitHub

git init
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin https://github.com/osagiebello/test.git
git push -u origin main

Handling GitHub Account Conflicts

brew install gh
gh auth login

7. Installing Homebrew

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Verify installation:

brew help

8. Using Homebrew Commands

brew search <package>        # Search for packages
brew info <package>          # Get package info
brew install <package>       # Install a package
brew update                  # Update Homebrew
brew upgrade                 # Upgrade installed packages
brew list                    # List installed packages
brew uninstall <package>      # Uninstall a package
brew outdated                # Find outdated packages
brew uninstall --zap <package> # Remove residual files
brew install --dry-run <package> # Test install before running
brew help <command>          # Get detailed help

9. Installing and Using Arc Browser

brew search arc
brew install --cask arc

Sign up and log in to Arc.

10. Installing Amazon Q

brew install --cask amazon-q

Useful Commands:

q help
q restart
q inline enable
q inline disable
q login
q logout
q ai "Explain git merge vs rebase"
q translate "What is Homebrew?"
q chat

11. Installing and Using Warp Terminal

brew install --cask warp

Sign up/login.

Windows Setup Using Chocolatey

1. Installing Chocolatey

Run PowerShell as Administrator and execute:

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

Verify installation:

choco -?

2. Installing Git Using Chocolatey

choco install git -y

Verify installation:

git --version

3. Installing VS Code

choco install vscode -y

4. Installing Amazon Q

choco install amazon-q -y

5. Installing Warp Terminal

choco install warp -y

6. Installing Arc Browser

Search for Arc in Chocolatey:

choco search arc

If unavailable, download it from the official website.

Working in GitHub Codespaces

1. Open your repository in GitHub.

2. Click Code > Codespaces.

3. Click Continue Working in GitHub Codespace.

4. Select an instance type based on your project needs:

   • Basic: Suitable for lightweight projects.

   • Standard: Recommended for most web and mobile development.

   • Performance: For complex builds or heavy computation.

This guide ensures a smooth setup experience for GitHub, Git, Homebrew (macOS), Chocolatey (Windows), and essential development tools. 🚀

✅ Get all links 👉 https://bit.ly/primary-dev-setup

Introduction

In this blog post, we'll go through the provided code in C step by step and explain each part in detail. This will help beginners understand the code and its logic. Let's get started!

Code Snippet

Understanding Variables and Constants

const int firstNumber = 30;
const int secondNumber = 50;
const int day = 2;
const int myNumbers[] = { 4, 6, 9, 20, 5, 10 };
const char* myLanguages[] = { "C", "C++", "Java", "C#", "PHP", "Python", "Ruby", "JavaScript", "Rust", "Go", "Swift", "R", "Kotlin" };
const int numLanguages = sizeof(myLanguages) / sizeof(myLanguages[0]);
int counter = 1;
int counterIndex = 1;
int index = 0;
int i = 0;

In the above code snippet, we declare and initialize several variables and constants. Here's a breakdown:

• firstNumber and secondNumber are constants representing integer values.

• day represents the current day as an integer.

• myNumbers is an array of integers that stores a collection of numbers.

• myLanguages is an array of strings (character pointers) that stores a collection of programming language names.

• numLanguages is an integer that represents the number of languages in the myLanguages array.

• counter, counterIndex, index, and i are integer variables used for looping and counting purposes.

Comparing Numbers using Conditionals

const int firstNumber = 30;
const int secondNumber = 50;

if (firstNumber > secondNumber) {
  printf("%d is greater than secondNumber %d\n", firstNumber, secondNumber);
} else if (firstNumber < secondNumber) {
  printf("%d is less than secondNumber %d\n", firstNumber, secondNumber);
} else {
  printf("%d is equivalent to secondNumber %d\n", firstNumber, secondNumber);
}

(firstNumber > secondNumber) ? printf("%d is greater than secondNumber %d\n", firstNumber, secondNumber) : 
(firstNumber < secondNumber) ? printf("%d is less than secondNumber %d\n", firstNumber, secondNumber) :
printf("%d is equivalent to secondNumber %d\n", firstNumber, secondNumber);

/*
30 is less than secondNumber 50
30 is less than secondNumber 50
*/

These code blocks demonstrate how to compare two numbers (firstNumber and secondNumber) using conditional statements (if-else and the ternary operator ? :). The code checks if firstNumber is greater than secondNumber, less than secondNumber, or equivalent to secondNumber. The appropriate message is then printed based on the comparison.

Using a Switch Statement

const int day = 2;

switch (day){ 
  case 1:
    printf("Monday\n");
    break;
  case 2:
    printf("Tuesday\n");
    break;
  case 3:
    printf("Wednesday\n");
    break;
  default:
    printf("Sunday\n");
}

/*
Tuesday
*/

This switch statement checks the value of the day variable and executes the corresponding code block. If day is equal to 1, "Monday" is printed. If it is 2, "Tuesday" is printed. If it is 3, "Wednesday" is printed. If none of these cases match, the default case is executed, and "Sunday" is printed.

Looping with While and Do-While

while (counter < 3) {
  printf("%d\n", counter);
  counter++;
}

printf("-----\n");

do {
  printf("%d\n", counterIndex);
  counterIndex++;
} while (counterIndex < 3);

/*
1
2
-----
1
2
*/

These code blocks demonstrate the usage of while and do-while loops. In the first block, the while loop executes as long as counter is less than 3. It prints the value of counter and increments it by 1 in each iteration. In the second block, the do-while loop executes at least once and continues until counterIndex is less than 3. It prints the value of counterIndex and increments it by 1 in each iteration.

Looping with For

while (index < 5) {
  if (index == 2) {
    index++;
    continue;
  }

  printf("%d\n", index);
  index++;
}

printf("-----\n");

for (; i < 5; i++) {
  if (i == 2) {
    continue;
  }
  printf("%d\n", i);
}

/*
0
1
3
4
-----
0
1
3
4
*/

These code blocks showcase the usage of for loops. In the first block, the while loop continues until index is less than 5. It skips the iteration when index is equal to 2 using the continue statement. In the second block, the for loop initializes i to 0, execute until i is less than 5, increments i by 1 in each iteration, and skips the iteration when i is equal to 2 using the continue statement. In both loops, the current value of the loop variable is printed.

Array Manipulation

const int myNumbers[] = { 4, 6, 9, 20, 5, 10 };

printf("%d\n", myNumbers[0]);

printf("-----\n");

for (int index = 0; index < numLanguages; index++) {
  printf("Language %d is %s\n", index + 1, myLanguages[index]);
}

printf("-----\n");

int matrix[2][3] = { {1, 9, 2}, {7, 6, 8} };
printf("%d\n", matrix[0][2]);
matrix[0][2] = 5;
printf("%d\n", matrix[0][2]);

printf("-----\n");

for (int i = 0; i < 2; i++) {
  for (int j = 0; j < 3; j++) {
    printf("%d\n", matrix[i][j]);
  }
}

/*
4
-----
Language 1 is C
Language 2 is C++
Language 3 is Java
Language 4 is C#
Language 5 is PHP
Language 6 is Python
Language 7 is Ruby
Language 8 is JavaScript
Language 9 is Rust
Language 10 is Go
Language 11 is Swift
Language 12 is R
Language 13 is Kotlin
-----
2
5
*/

These code blocks demonstrate array manipulation. The first block prints the value of the first element in the myNumbers array. The second block uses a for loop to iterate over the myLanguages array and prints each language's name along with its corresponding index. The third block initializes a 2-dimensional array called matrix and prints the value at a specific index. It then modifies that value and prints it again. The final block uses nested for loops to iterate over the matrix array and print each element.

String Manipulation

int x = 0;
char* name = "Osagie";

for (; x <= strlen(name); x++) {
  printf("%c\n", name[x]);
}

/*
1
9
5
7
6
8
-----
O
s
a
g
i
e
*/

This code block demonstrates string manipulation. It declares an integer variable x and a character pointer name pointing to the " Osagie " string. A for loop is used to iterate over the characters in the name string. It prints each character using the %c format specifier.

Practice

Assuming you have an account or are already logged in on Replit.

• Try the Replit Editor online.

• Click the Fork button.

• Edit the current code.

Conclusion

In this blog post, we went through a C code snippet step by step, explaining each part and its logic for beginners. We covered variable declarations, comparisons, conditionals, loops, array manipulation, and string manipulation. Understanding these fundamental concepts will help you in your journey to becoming a proficient C programmer.

References

Here are some reference links that can provide additional information and explanations on the topics covered in the blog:

1. Variables and Constants:

   • C Variable Types: GeeksforGeeks

   • Understanding Constants in C: Programiz

2. Conditionals:

   • If-Else Statements: GeeksforGeeks

   • Ternary Operator: GeeksforGeeks

3. Switch Statements:

   • Switch Statement: GeeksforGeeks

4. Loops:

   • C Loops: GeeksforGeeks

   • While Loop: GeeksforGeeks

   • C while and do...while Loop: GeeksforGeeks

5. Array Manipulation:

   • Arrays in C: GeeksforGeeks

   • 2D Arrays in C: GeeksforGeeks

   • 2D Arrays in C: Tutorials point

6. String Manipulation:

   • Strings in C: GeeksforGeeks

   • String Functions: Programiz

These references should provide additional explanations and examples to enhance the understanding of the concepts covered in the blog post.

Happy Coding!

Introduction

In C programming, the string.h library provides several functions for manipulating strings. This blog post will explore the usage of string manipulation functions in C, along with a detailed explanation of user input using scanf and fgets. We will analyze a code snippet that showcases these concepts and discuss each aspect of the code step by step.

Code Snippet

Including string.h

The first line of the code snippet #include <string.h> is a preprocessor directive that includes the string.h header file. This file contains function declarations for string manipulation, such as strlen, strcpy, strcat, and strcmp. By including this header file, we gain access to these functions, which we will utilize in the code snippet.

Creating a Directory

To begin, let's create a file named intermediate.c using the command line. Follow the instructions below based on your operating system:

• Open the command prompt or PowerShell.

• Run the following commands:

cd basic-programming/c-programming

• Open the file in your favorite text editor.

code intermediate.c

or

vim intermediate.c # installed by default on macOS

or

emacs -Q -nw intermediate.c

or

nano intermediate.c # installed by default on Linux

Note: Make sure you save changes in the file.

String Manipulation using string.h Functions

In this section, we'll analyze the code related to string manipulation functions provided by the string.h library.

// String Manipulation
strcat(firstText, secondText);
strcpy(secondStr, thirdStr);
const int str13Cmp = strcmp(firstStr, thirdStr);
const int str3greetingCmp = strcmp(thirdStr, greeting);

In the code above, we perform various string manipulation operations:

• strcat(firstText, secondText);: This line uses thestrcatfunction to concatenate thesecondTextstring at the end of thefirstTextstring. The result is that thefirstText string becomes "Hello World!".

• strcpy(secondStr, thirdStr);: Here, we use the strcpy function to copy the contents of the thirdStr string into the secondStr array. This operation creates an independent copy of the string.

• const int str13Cmp = strcmp(firstStr, thirdStr);: The strcmp function compares the contents of the firstStr and thirdStr strings. It returns an integer value indicating the result of the comparison. If the two strings are equal, it returns 0. If firstStr is lexicographically less than thirdStr, it returns a negative value. If firstStr is lexicographically greater than thirdStr, it returns a positive value. The result is stored in the str13Cmp variable.

• const int str3greetingCmp = strcmp(thirdStr, greeting);: Similarly, this line compares the thirdStr and greeting strings using strcmp and stores the result in the str3greetingCmp variable.

User Input using scanf

Now, let's look at the code related to user input using the scanf function.

// User Input using scanf
printf("Please type your age and grade: ");
scanf("%d %c", &myAge, &myChar);
printf("Please enter your first name: ");
scanf("%19s", myFirstName);

In the code above, we use scanf to retrieve user input:

• scanf("%d %c", &myAge, &myChar);: This line prompts the user to enter their age and grade. The format string "%d %c" specifies that we expect an integer followed by a character as input. The & operator is used to pass the memory addresses of myAge and myChar variables to store the values entered by the user.

• scanf("%19s", myFirstName);: This line prompts the user to enter their first name. The format string "%19s" specifies that we expect a string input with a maximum length of 19 characters (to avoid buffer overflow). The entered string is stored in the myFirstName character array.

User Input using fgets

Here's the code that demonstrates user input using the fgets function.

// User Input using fgets
printf("Please enter your full name: ");
getchar();  // Clear the newline character from the previous input
fgets(myFullName, sizeof(myFullName), stdin);
myFullName[strcspn(myFullName, "\n")] = '\0';

In the code above, we utilize fgets to obtain user input:

• fgets(myFullName, sizeof(myFullName), stdin);: This line reads a line of input from the user, storing it in the myFullName character array. The sizeof(myFullName) argument specifies the maximum number of characters to read, preventing buffer overflow. The stdin stream indicates that the input is read from the standard input (keyboard).

• myFullName[strcspn(myFullName, "\n")] = '\0';: Since fgets captures the newline character (\n) when the user presses Enter, this line removes the newline character from the myFullName string by replacing it with a null character (\0). This step ensures that the string ends at the intended input and doesn't include the newline character.

Memory Address and Pointers

This section focuses on memory addresses and pointers used in the code.

// Memory Address and Pointers
printf("My age is: %d\n", myAge);
printf("My character is: %c\n", myChar);
printf("My first name is: %s\n", myFirstName);
printf("My full name is: %s\n", myFullName);
printf("%p\n", (void*)&myAge);
printf("%p\n", (void*)ptr);
printf("%d\n", *ptr);

In the code above, we work with memory addresses and pointers:

• printf("My age is: %d\n", myAge);: This line displays the value of the myAge variable, representing the age entered by the user.

• printf("My character is: %c\n", myChar);: Here, we print the value of the myChar variable, which corresponds to the grade entered by the user.

• printf("My first name is: %s\n", myFirstName);: This line outputs the contents of the myFirstName character array, which contains the user's first name.

• printf("My full name is: %s\n", myFullName);: Similarly, we display the content of the myFullName character array, which holds the user's full name.

• printf("%p\n", (void*)&myAge);: This line prints the memory address of the myAge variable using the %p format specifier. The & operator retrieves the address of the variable.

• printf("%p\n", (void*)ptr);: Here, we print the memory address stored in the ptr pointer variable. The (void*) cast is used to ensure proper formatting of the memory address.

• printf("%d\n", *ptr);: This line dereferences the ptr pointer and prints the value stored at the memory address it points to. Since ptr points to myAge, it effectively displays the value of myAge.

Output Finally, the code snippet includes several printf statements to display the output.

// Output
printf("%d\n", alphabetLength);
printf("%d\n", alphabetByte);
printf("%s\n", firstText);
printf("%s\n", secondStr);
printf("%d\n", str13Cmp);
printf("%d\n", str3greetingCmp);

The code above produces the following output:

• alphabetLength: This line prints the length of the alphabet string, which is determined using the strlen function.

• alphabetByte: Similarly, this line displays the size (in bytes) of the alphabet array, obtained using the sizeof operator.

• firstText: This line outputs the contents of the firstText character array, which now contains the concatenated string "Hello World!".

• secondStr: Here, we print the contents of the secondStr character array, which was assigned the value of the thirdStr string using strcpy.

• str13Cmp: This line displays the result of comparing the firstStr and thirdStr strings using strcmp. It indicates whether the two strings are equal or different.

• str3greetingCmp: Similarly, this line shows the result of comparing the thirdStr and greeting strings using strcmp.

Practice

Assuming you have an account or are already logged in on Replit.

• Try the Replit Editor online.

• Click the Fork button.

• Edit the current code.

Conclusion

In this blog post, we explored the usage of string manipulation functions provided by the string.h library in C programming. We discussed functions such as strlen, strcpy, strcat, and strcmp, along with their purpose and how they are utilized in the code snippet. Additionally, we examined user input using scanf and fgets, which allow the program to receive input from the user. Finally, we covered memory addresses and pointers, highlighting their significance and demonstrating their usage in the code snippet.

References

• String and Character Array

• Introduction to C Pointers

• Using Pointers in C

• What is return type of getchar(), fgetc() and getc()?

Introduction

Understanding the basics of C programming is essential for any aspiring programmer. In this blog post, we will explore the concept of data types and constants in C programming, taking a hands-on approach to deepen our understanding. We will compile and run the code snippets to observe the results firsthand. Let's get started!

Code Snippet

Creating a Directory

To begin, let's create a file named basics.c using the command line. Follow the instructions below based on your operating system:

• Open the command prompt or PowerShell.

• Run the following commands:

cd basic-programming/c-programming

• Open the file in your favorite text editor.

code basics.c

or

vim basics.c # installed by default on macOS

or

emacs -Q -nw basics.c

or

nano basics.c # installed by default on Linux

Note: Make sure you save changes in the file.

Entry Point of a Program

In C programming, int main() or int main(void) is the entry point of a C program. It is the function where the execution of the program starts. Here's an explanation of each:

int main(void) {
  // Code goes here    
}

• int main():

  • This declaration of main specifies that the function takes an unspecified number of arguments.

  • In C, if no arguments are specified in the parentheses, it is assumed that the function can accept any number of arguments.

  • While this declaration is allowed by the C language, it is generally considered bad practice because it can lead to potential issues related to argument handling and type-checking.

• int main(void):

  • This declaration of main specifies that the function takes no arguments.

  • By explicitly stating (void) in the parentheses, it conveys that the main function does not expect any input parameters.

  • This declaration is considered good practice and is recommended for clarity and to avoid potential issues with argument handling.

Using int main(void) is generally considered better practice because it clearly indicates that the main function does not accept any arguments. It helps in avoiding accidental mistakes related to argument passing and makes the code more readable and self-explanatory.

Exit Point of a Program

In C programming, the return 0; statement at the end of the main function is not required, but it is commonly used. Here's an explanation:

int main(void) {
  // Code goes here 

  return 0;   
}

• The return statement is used to indicate the exit status of the program to the operating system or the program's caller.

• By convention, a return value of 0 typically indicates successful execution or termination of the program.

• If the return statement is omitted in the main function, the C language automatically inserts an implicit return 0; at the end of the function.

• Including an explicit return 0; at the end of the main function is considered good practice for the following reasons:

  • It makes the code more readable and explicit, clearly indicating the intended termination of the program.

  • It allows for consistency with other functions that may have non-zero return values to indicate specific error conditions.

  • It ensures compatibility with some programming environments that may expect a return value from the main function.

While return 0; is not strictly required, it is widely used and considered a best practice. It helps in writing clear and maintainable code, especially when working on larger projects or collaborating with other developers.

Data Types: Defining the Nature of Data

Data types are used to define the type of data that a variable can hold. C provides several built-in data types, including integers, characters, booleans, and arrays. Let's explore these data types by examining the code snippet provided.

/* Data Types */

const int numb = 89;
const char *str = "Bello Osagie";
const bool isTrue = 5 > 3;

In the above code, we can identify three different data types being used:

• int is used to store integer values. Here, numb represents the number 89.

• char* (character pointer) is used to store strings. In this case, str points to the string Bello Osagie.

• bool represents boolean values (true or false). The variable isTrue is assigned the value true because the expression 5 > 3 evaluates to true.

By utilizing different data types, we can handle various kinds of information in our programs.

Note: These are not all the data types we have in C. We will explore others later.

Array: List of Characters as a String

The code char text[] = "This is a text"; represents a character array, which is commonly used to store strings in C. In this case, the array text is initialized with the string "This is a text".

char text[] = "This is a text";

Although it is common to use character arrays to store strings in C, it's important to note that there is no separate data type specifically for strings. Instead, strings are represented as arrays of characters terminated by a null character ('\0'), indicating the end of the string.

Modification of a Character at a specific index

Let's visually represent the interpretation of the given code below and explain the zero-indexed string, modification of the character at index 8, and the memory addresses before and after the modification:

char text[] = "This is a text";
text[8] = '1';

1. Declaration and Initialization of the Character Array (String):

char text[] = "This is a text";

This code declares and initializes a character array text with the string "This is a text". The characters of the string are stored in sequential memory locations.

Visual representation:

Memory:
-----------------------------------------------------
| Address |   Value   |          Variable           |
-----------------------------------------------------
|  1000   |    'T'    |    text[0] (char, 'T')      |
|  1001   |    'h'    |    text[1] (char, 'h')      |
|  1002   |    'i'    |    text[2] (char, 'i')      |
|  1003   |    's'    |    text[3] (char, 's')      |
|  1004   |    ' '    |    text[4] (char, ' ')      |
|  1005   |    'i'    |    text[5] (char, 'i')      |
|  1006   |    's'    |    text[6] (char, 's')      |
|  1007   |    ' '    |    text[7] (char, ' ')      |
|  1008   |    'a'    |    text[8] (char, 'a')      |
|  1009   |    ' '    |    text[9] (char, ' ')      |
|  1010   |    't'    |    text[10] (char, 't')     |
|  1011   |    'e'    |    text[11] (char, 'e')     |
|  1012   |    'x'    |    text[12] (char, 'x')     |
|  1013   |    't'    |    text[13] (char, 't')     |
|  1014   |   '\0'    |    text[14] (char, '\0')    |
-----------------------------------------------------

1. Modification of Character at Index 8:

text[8] = '1';

This code replaces the character at index 8 (zero-indexed) of text with the character '1'.

Visual representation (after modification):

Memory:
-----------------------------------------------------
| Address |   Value   |          Variable           |
-----------------------------------------------------
|  1000   |    'T'    |    text[0] (char, 'T')      |
|  1001   |    'h'    |    text[1] (char, 'h')      |
|  1002   |    'i'    |    text[2] (char, 'i')      |
|  1003   |    's'    |    text[3] (char, 's')      |
|  1004   |    ' '    |    text[4] (char, ' ')      |
|  1005   |    'i'    |    text[5] (char, 'i')      |
|  1006   |   's'     |    text[6] (char, 's')      |
|  1007   |    ' '    |    text[7] (char, ' ')      |
|  1008   |    '1'    |    text[8] (char, '1')      |
|  1009   |    ' '    |    text[9] (char, ' ')      |
|  1010   |    't'    |    text[10] (char, 't')     |
|  1011   |    'e'    |    text[11] (char, 'e')     |
|  1012   |    'x'    |    text[12] (char, 'x')     |
|  1013   |    't'    |    text[13] (char, 't')     |
|  1014   |   '\0'    |    text[14] (char, '\0')    |
-----------------------------------------------------

In a zero-indexed string or array, the first element is accessed using index 0. So, in the given code, text[8] represents the character at the ninth position in the string. By assigning '1' to text[8], the original character 'a' at index 8 is replaced with '1'.

The memory addresses before and after the modification remain the same, only the values stored at those addresses are changed. This is because the array text is mutable, allowing us to modify its elements even if it is declared as a character array (string) or a constant.

Arrays: Storing Multiple Values

Arrays allow for the storage of multiple values of the same data type. They provide a convenient way to group related data together. Let's analyze the usage of arrays in the code snippet.

const int myNumbers[] = { 4, 8, 1, 9, 7 }; // array
const char *myString[] = { "money", "people", "love" }; // array

The code snippet demonstrates the declaration and initialization of two arrays, myNumbers and myString. myNumbers is an array of integers, while myString is an array of character pointers (strings).

Visual Representation of Array

Let's visually represent the given code and explain the concept of zero-based indexing in arrays and strings:

1. Declaration and Initialization of Integer Array:

const int myNumbers[] = { 4, 8, 1, 9, 7 };

This code declares and initializes an integer array myNumbers with 5 elements. The elements are initialized with the provided values.

Visual representation:

myNumbers:
| int | index
--------------
|  4  | 0
--------------
|  8  | 1
--------------
|  1  | 2
--------------
|  9  | 3
--------------
|  7  | 4
--------------

In C and many programming languages, arrays are zero-based indexed. It means that the index of the first element in the array is 0, the second element is 1, and so on. In the myNumbers array, the values are accessed as follows:

myNumbers[0] = 4
myNumbers[1] = 8
myNumbers[2] = 1
myNumbers[3] = 9
myNumbers[4] = 7

1. Declaration and Initialization of String Array:

const char *myString[] = { "money", "people", "love" };

This code declares and initializes a string array myString with 3 elements. Each element is a pointer to a string literal.

Visual representation:

myString:
| str      | index
--------------
| "money"  | 0
--------------
| "people" | 1
--------------
|  "love"  | 2
--------------

Similarly, in C, strings are also represented as arrays of characters. Each character in a string has its index starting from 0. In the myString array, the values are accessed as follows:

myString[0] = "money"
myString[1] = "people"
myString[2] = "love"

Remember that the index represents the position of an element in the array or a character in a string, starting from 0.

Zero-based indexing is a convention used in programming languages, and it provides a consistent and efficient way to access elements in arrays and strings. Starting the index at 0 aligns with the underlying memory representation and allows for simple arithmetic operations when working with array elements.

Constants: Immutable Values

In C programming, constants are fixed values that cannot be modified during the execution of a program. They are declared using the const keyword. Let's examine the usage of constants in our code.

/* Constants */

const int numb = 89;
const char *str = "Bello Osagie";
const bool isTrue = 5 > 3;
char text[] = "This is a text";
text[8] = '1';
const char greetings[] = { 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '\0' };
const int myNumbers[] = { 4, 8, 1, 9, 7 }; // array
const char *myString[] = { "money", "people", "love" }; // array
const int indexNumb = myNumbers[2];
const char *indexStr = myString[1];
const int myNumbers2D[2][3] = { {3, 5, 8 }, {3, 0, 1} };
const int indexMyNumber2D = myNumbers2D[1][0];
int replaceIndexMyNumber2D = myNumbers2D[1][0];
replaceIndexMyNumber2D = 10;

The constant numb is declared as an integer with the value 89. Since it is defined as a constant, its value cannot be changed later in the program. Similarly, str is declared as a constant character pointer pointing to the string Bello Osagie.

The boolean constant isTrue is assigned the result of the expression 5 > 3, which evaluates to true. Again, as a constant, its value remains unchanged.

The array greetings is initialized with the characters 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', and '\0', representing a null-terminated string constant.

myNumbers and myString are arrays of integers and character pointers, respectively. These arrays are initialized with fixed values and cannot be modified later.

Next, we have the 2D array myNumbers2D, which is initialized with two rows and three columns of integers.

We have variables such as indexNumb and indexStr, which store specific elements from the constant arrays.

Finally, we have the variable replaceIndexMyNumber2D which initially holds the value of myNumbers2D[1][0] and later gets reassigned to the value 10.

Constants in Array

Let's visually represent the interpretation of the given code and the output after the modification. Then, I will explain why the changes in the array elements are possible despite using const.

const int indexMyNumber2D = myNumbers2D[1][0];
int replaceIndexMyNumber2D = indexMyNumber2D;
replaceIndexMyNumber2D = 10;

1. Declaration and Initialization of 2D Array:

const int myNumbers2D[2][3] = { 
    {3, 5, 8},
    {3, 0, 1}
};

This code declares and initializes a 2D array myNumbers2D with 2 rows and 3 columns. The array elements are initialized with the provided values.

Visual representation:

myNumbers2D:
--------------
| 3 | 5 | 8 |
--------------
| 3 | 0 | 1 |
--------------

1. Accessing Element of the 2D Array:

const int indexMyNumber2D = myNumbers2D[1][0];

This code assigns the value at the index [1][0] of myNumbers2D to the constant variable indexMyNumber2D.

Visual representation (after this step):

myNumbers2D:
--------------
| 3 | 5 | 8 |
--------------
| 3 | 0 | 1 |
--------------
indexMyNumber2D: 3

1. Assignment of Element to a Non-constant Variable:

int replaceIndexMyNumber2D = myNumbers2D[1][0];
replaceIndexMyNumber2D = 10;

This code assigns the value at the index [1][0] of myNumbers2D to the variable replaceIndexMyNumber2D. Then, it reassigns the value of replaceIndexMyNumber2D to 10.

Visual representation (after this step):

myNumbers2D:
--------------
| 3 | 5 | 8 |
--------------
| 3 | 0 | 1 |
--------------
indexMyNumber2D: 3
replaceIndexMyNumber2D: 10

Even though the array myNumbers2D is declared as const, the changes in the array elements are possible because the const qualifier applies to the elements themselves, not to the variables that hold them. The const keyword ensures that the elements cannot be modified through the array variable myNumbers2D.

In memory, the array myNumbers2D is stored as a contiguous block. Each element in the array has its address. When you assign an element to a non-constant variable, like replaceIndexMyNumber2D, the value of that element is copied to the variable, including its address. The variable replaceIndexMyNumber2D now holds the value and the address of the element.

When you modify the value of replaceIndexMyNumber2D, you are changing the value stored at the address held by the variable. However, the original array elements in myNumbers2D remains unchanged. The modification only affects the variable replaceIndexMyNumber2D and its associated memory location.

const int indexMyNumber2D = myNumbers2D[1][0];
int replaceIndexMyNumber2D = indexMyNumber2D; // myNumbers2D[1][0];
replaceIndexMyNumber2D = 10;

Visual representation (address illustration):

Memory:
---------------------------------------------------
| Address |  Value  |           Variable          |
---------------------------------------------------
|  1000   |    3    | myNumbers2D[0][0] (const)   |
|  1004   |    5    | myNumbers2D[0][1] (const)   |
|  1008   |    8    | myNumbers2D[0][2] (const)   |
|  1012   |    3    | myNumbers2D[1][0] (const)   |
|  1016   |    0    | myNumbers2D[1][1] (const)   |
|  1020   |    1    | myNumbers2D[1][2] (const)   |
|  1024   |    3    | indexMyNumber2D (const)     |
|  1028   |   10    | replaceIndexMyNumber2D      |
---------------------------------------------------

In this illustration, the addresses and values of the variables are shown in memory. The const variables (myNumbers2D, indexMyNumber2D) hold the original values without any modifications. The non-constant variable replaceIndexMyNumber2D holds the modified value.

const int indexMyNumber2D = myNumbers2D[1][0];
int replaceIndexMyNumber2D = indexMyNumber2D; // myNumbers2D[1][0];
replaceIndexMyNumber2D = 10;

Printing the Values: Printing Formatted Output

To observe the values of the variables and constants in our code, we use the printf function to print them to the console (terminal). Here's how the values are printed:

/* Printing Values */

printf("%d\n", numb); // Print the value of numb
printf("%s\n", text); // Print the value of text
printf("%s\n", str); // Print the value of str
printf("%s\n", text); // Print the value of text
printf("%d\n", isTrue); // Print the value of isTrue
printf("%d\n", indexNumb); // Print the value of indexNumb
printf("%s\n", greetings); // Print the value of greetings
printf("%s\n", indexStr); // Print the value of indexStr
printf("%d\n", indexMyNumber2D); // Print the value of indexMyNumber2D
printf("%d\n", replaceIndexMyNumber2D); // Print the value of replaceIndexMyNumber2D

Each printf statement specifies a format specifier to indicate the data type of the variable or constant being printed. For example, %d is used to print integers, %s is used to print strings, and %d is also used for booleans (where true is printed as 1 and false is printed as 0).

Note

• %d is the same as %i.

• The format specifier %c is used to print a single character in C. However, the value representing the character must be enclosed in single quotes (' '), not backticks. Below is an example:

printf("%c\n", 'J'); // A char

This will print the character 'J' to the console followed by a newline character ('\n').

Comments: Documenting Your Code

Comments are essential for code documentation. They provide information about the code's functionality, purpose, and any other relevant details. In the given code snippet, we can see the usage of comments to document the code. Let's take a look:

// This is a single-line comment
/* 
   This is a multi-line comment
   It can span multiple lines
*/

// Code snippet starts here

const int numb = 89; // Variable to store a number
const char *str = "Bello Osagie"; // Variable to store a string
const bool isTrue = 5 > 3; // Variable to store a boolean value

char text[] = "This is a text"; // Variable to store a character array

// Code snippet ends here

In the code snippet, we can see the use of single-line comments and multi-line comments. Single-line comments start with // and continue until the end of the line. They are used to provide brief explanations or comments on a specific line of code.

Multi-line comments start with /* and end with */. They can span multiple lines and are useful for providing detailed explanations or commenting out a block of code.

Comments are not executed as part of the program and do not affect the program's functionality. They are solely meant for human readability and understanding.

Variables: Storing Data

Variables are used to store and manipulate data in C programming. They act as containers that hold values of different types. In the given code snippet, we can see the usage of variables like numb, str, isTrue, text, and more. Let's explore their significance and how they are utilized.

/* variables */

const int numb = 89;
const char *str = "Bello Osagie";
const bool isTrue = 5 > 3;
char text[] = "This is a text";
}

In this code, numb is an integer variable assigned a constant value of 89. We use the const keyword to indicate that the value is constant and cannot be modified.

Similarly, str is a character pointer variable storing the address of the string Bello Osagie. The const keyword ensures that the pointer itself is constant and cannot be used to modify the string.

isTrue is a boolean variable assigned the result of the expression 5 > 3. It will hold the value true since the expression is true.

text is a character array initialized with the string "This is a text." It allows for the manipulation of individual characters within the array.

Modifying Variables: Adding and Replacing Values

Variables can be modified by assigning new values to them. In the code snippet, we can see examples of modifying variables:

text[8] = '1';
replaceIndexMyNumber2D = 10;

The statement text[8] = '1' replaces the character at index 8 in the text array with the character '1'. Similarly, replaceIndexMyNumber2D = 10 assigns the value 10 to the variable replaceIndexMyNumber2D.

Compiling and Running the Code

When compiling a C program using the GCC compiler, you can pass various options and flags to modify the behavior of the compilation process. Let's break down the options used in the commands you mentioned:

/*
 * Run:
 * gcc -Wall -pedantic -Werror -Wextra -std=c99 basics.c -o basics
 * gcc basics.c -o basics
 * ./basics
 */

Let's discuss each option:

• -Wall: Enables compiler warnings for potential issues in the code. It stands for all warnings. When this option is used, the compiler will display a comprehensive set of warning messages to help identify possible problems in the code.

• -pedantic: Enforces strict adherence to the C language standards. It instructs the compiler to be pedantic and only allows code that strictly follows the C standard. It disables certain language extensions and non-standard features.

• -Werror: Treats all warnings as errors. When this option is enabled, any warning generated by the compiler will be treated as an error, causing the compilation to fail. This ensures that the code is warning-free and encourages developers to write clean and error-free code.

• -Wextra: Enables additional warning messages beyond those enabled by -Wall. It provides extra warnings for potentially suspicious code constructs or common programming mistakes.

• -std=c99: Specifies the C language standard to be used. In this case, it specifies the C99 standard. C99 is an ANSI/ISO standard for the C programming language, introduced in 1999. It adds several new features and improvements to the language.

The first command (gcc -Wall -pedantic -Werror -Wextra -std=c99 basics.c -o basics) enables strict warnings, treats warnings as errors, and enforces adherence to the C99 standard. It is advisable to use this command during development or when aiming for strict code quality and adherence to standards. It helps catch potential issues and encourages cleaner code.

The second command (gcc basics.c -o basics) is a simpler command that compiles the basics.c file without any specific warning options or standard enforcement. It can be used for quick compilation without strict warning checks. However, it's generally recommended to use the first command during development or in projects where code quality and adherence to standards are crucial.

By using the first command, you can catch and address potential issues early in the development process, leading to more robust and maintainable code.

Preprocessor Directives

In the code below, #include <stdio.h> and #include <stdbool.h> are preprocessor directives that include the standard C library headers stdio.h and stdbool.h, respectively. Here's an explanation of each:

#include <stdio.h>
#include <stdbool.h>

• #include <stdio.h>:

  • This directive includes the standard input/output library header. It provides functions for input and output operations, such as reading from or writing to the console or files.

  • It allows you to use functions like printf() and scanf() for formatted output and input operations, respectively.

  • In the given code, printf() function is used to print values to the console.

• #include <stdbool.h>:

  • This directive includes the header for the C99 standard's Boolean type support.

  • It defines the bool type, which represents boolean values (true and false).

  • In the given code, bool is used to declare the variable isTrue and store a boolean value (true or false).

Including these headers is necessary to access the functions and definitions provided by the respective libraries. Without including stdio.h, you wouldn't be able to use functions like printf(), and without including stdbool.h, you wouldn't be able to use the bool data type.

Practice

Assuming you have an account or are already logged in on Replit.

• Try the Replit Editor online.

• Click the Fork button.

• Edit the current code.

Conclusion

In this blog post, we explored the basics of C programming by examining data types and constants. We learned how to declare and initialize variables and constants of various data types, including integers, characters, booleans, and arrays. We also observed the results by printing the values using printf. Understanding these fundamental concepts is crucial for building more complex C programs. Stay tuned for future blog posts where we will delve deeper into C programming.

References

• C Data Types

• C Constants

• C Arrays

• C Boolean Data Type

• C printf Function

Happy Coding!!!

Introduction

C programming is a versatile language that allows you to build a wide range of applications. Whether you're a beginner or an experienced programmer, you must know how to set up your development environment and start with basic programming tasks. In this guide, we'll walk you through the process of creating directories and checking for the installation of C on different operating systems. We'll also cover the steps to install C if it's not already available. Finally, we'll demonstrate how to write and compile a simple Hello, World! program in C. Let's get started!

Code Snippet

Installing Choco

If this is not your first time using Chocolatey or Chocolatey is already installed on your Windows Operating System skip this section.

To install Chocolatey, follow these steps:

1. Search for PowerShell and run it as an administrator on Windows.

2. Go to the Chocolatey installation page.

3. If this is your first time installing Chocolatey on your operating system, execute the following command in your terminal, based on the instructions provided on the installation page:

Get-ExecutionPolicy

• If the output is "Restricted", enter one of the commands below:

Set-ExecutionPolicy AllSigned

or

Set-ExecutionPolicy Bypass -Scope Process

• Regardless of whether "Restricted" was the previous output or not, run the following command (copy and paste it into your terminal):

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

• If there are no errors, check if Chocolatey was successfully installed by running the following command:

choco

If the output displays the version of Chocolatey you are using, it means the installation was successful.

Creating a Directory

To begin, let's create a directory named c-programming using the command line. Follow the instructions below based on your operating system:

• Open the command prompt or PowerShell.

• Run the following commands:

mkdir basic-programming

mkdir basic-programming/c-programming

• change directory to c-programming

cd basic-programming/c-programming

Checking if C is Installed

Before you start writing C programs, it's important to check if C is installed on your system. You can verify this by using the gcc or cc command, a popular C compiler. Follow the steps below:

• Open the terminal.

• Run the following command:

gcc --version

Note: You may also include the extension to gcc. That is gcc is the same as gcc.exe.

gcc.exe --version
gcc.exe input.c -o output.exe # optionally omit the .exe

If C is installed, the version information will be displayed. Otherwise, you may be prompted to install the necessary tools or package. For example, for Linux, if gcc is not installed, running gcc --version in the terminal typically results in an error message like this:

The program 'gcc' is currently not installed. You can install it by typing:
sudo apt install gcc

For Windows, the error may look like this shown below:

'gcc' is not recognized as an internal or external command, operable program or batch file.

For macOS, the error may look like this shown below:

-bash: gcc: command not found

gcc or cc

• In the article, the gcc command will be primarily used for checking the version of the C compiler and compiling C programs. However, it is worth noting that cc can be used as an alternative to gcc for the same purposes.

• While gcc is commonly used as the command-line interface to the GNU Compiler Collection, including the C compiler, cc is often set as a symbolic link or alias to gcc. Therefore, both commands essentially serve the same purpose and can be used interchangeably in most cases.

The choice between using gcc or cc may depend on personal preference or specific system configurations. However, in the context of the article, it is safe to assume that the gcc command will be predominantly used while acknowledging that the cc command could be used as an alternative.

Installing C

If C is not installed on your system, follow the appropriate instructions based on your operating system:

General Installation (VSCode)

• If you prefer to use VSCode, you can install it by using a package manager specific to your operating system. For Windows, you can use Chocolatey by running the command choco install vscode. macOS users can use brew with the command brew install --cask visual-studio-code. Ubuntu users can use sudo with the command sudo apt install code.

• After installing VSCode, you should install the following extensions: C/C++ Extension Pack and Code Runner.

• After the installation is complete, you can launch Visual Studio Code by searching for it in the applications menu or by running the code command in the terminal (code and click Enter or Return). Once Code Runner is installed, you will see a play icon beside which is a dropdown.

• Click on the play dropdown icon. See the image below:

• Open the terminal by pressing Ctrl + J.

• Click the option that says Run C/C++.

• From the debug configuration options, select the option to build and debug an active file.

You will see the result Hello, World! In your terminal. Notice the new executable file created during execution - hello.exe

Note: that the Keyboard shortcut is Ctrl + Shift + B.

Now that you have done the configuration, the next time you want to run a C program just click on the play button or use the keyboard shortcut Ctrl + Alt + N.

Issue

• If the installation doesn't work for you, go to the VS Code download page and click the download button based on your operating system - macOS, Linux, Windows and install (click on the executable file after download - accept all default settings).

• If the problem persists, download and install Codeblocks. You may navigate to the Binary releases page and download based on your operating system.

• Alternatively, use the online Replit text editor.

Note**:** You can also try VSCode in the browser and still follow along the course.

macOS

On macOS, Homebrew can be used to install C-related tools and libraries. However, Homebrew itself is not specifically used to install the C language since macOS already includes the Clang compiler, which supports C. Here's how you can install Homebrew and verify the availability of Clang:

• Open the terminal.

• Install Homebrew by running the following command.

On macOS, brew might be pre-installed on your system, verify by running the command below:

brew -v

If it is not installed or it shows an error, run the command below:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

• After Homebrew is installed, you can install additional C-related tools and libraries if needed by using Homebrew commands. For example, to install the GNU Compiler Collection (GCC), you can run the following command:

brew install gcc

• To verify the availability of Clang, which comes preinstalled on macOS, run the following command:

clang --version

Remember, on macOS, the default compiler is Clang, which supports C and other programming languages. If you install GCC using Homebrew, you can use it as an alternative to Clang.

Alternative installation on macOS

• Install Xcode from the App Store.

• Open Xcode and navigate to Preferences.

• In the Downloads tab, install the Command Line Tools.

Ubuntu

• Open the terminal.

• Run the following commands

sudo apt-get update
sudo apt-get install build-essential

Note: The sudo command is used to run the subsequent commands with administrative privileges, which may require you to enter your password.

Windows

To install C on Windows, we'll use the MinGW-w64 development environment, which provides a Windows port of GCC. Follow these steps:

On Windows, you can use Chocolatey to install the MinGW-w64 development environment, which provides a Windows port of GCC. Here's how you can do it:

• Open the command prompt or PowerShell with administrative privileges.

• Install Chocolatey by following the instructions on the official Chocolatey website.

• Once Chocolatey is installed, run the following command to install MinGW-w64:

choco install mingw

• During the installation, make sure to select the appropriate options as prompted.

For example, if asked to run the script, type a or all. It means you want to run all scripts.

Do you want to run the script?([Y]es/[A]ll - yes to all/[N]o/[P]rint): a

• After the installation is complete, you should have the GCC compiler available on your system. You can verify the installation by running the command gcc --version in the command prompt or PowerShell.

Alternative installation on Windows OS

• Visit the MinGW-w64 website and download the installer for your system architecture (32-bit or 64-bit).

• Run the installer and ensure you select the Add to PATH option during installation.

• After installation, open the command prompt or PowerShell.

• Run the following command to verify the installation:

gcc --version

Note: printf is used to output (print) the result in the terminal.

Writing and Compiling a C Program

Now that you have C installed, let's write a simple Hello, World! program and compile it. Follow the steps below:

• Create a file named hello.c and paste (right click) the following code into it and save (based on the editor):

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

vim hello.c

Save file:

• :wq

• Enter or Return

or

nano hello.c

Save file:

• Ctrl + O Ctrl + C Ctrl + X

• Y

• Enter or Return

or

emacs -Q -nw hello.c

It is the same as emacs hello.c except that it might open the GNU graphical interface:

emacs hello.c

Save file:

• Ctrl + X Ctrl + S

• Ctrl + X Ctrl + C

• Open the terminal or command prompt and navigate to the directory where the hello.c file is located.

• Use the gcc command to compile the program and generate an executable file:

gcc hello.c -o hello

or

gcc hello.c -o hello.exe

The -o option specifies the output file name (in this case, hello).

• Run the program by executing the generated executable file:

./hello

or

./hello.exe

You should see the output Hello, World! displayed in the terminal or command prompt.

Practice

Assuming you have an account or are already logged in on Replit.

• Try the Replit Editor online.

• Click the Fork button.

• Edit the current code.

Conclusion

Congratulations! You've learned how to create directories, check if C is installed, install C if needed, and write a simple C program. This knowledge forms the foundation for your C programming journey. As you progress, you can explore more complex programs and dive deeper into the language's capabilities. Have fun coding and building amazing software with C! If you have any further questions, feel free to ask.

References

• Learn C - Free Interactive C Tutorial

• Learn C Programming - Tutorialspoint

• C Programming - GeeksforGeeks

• C Programming - Codecademy

Happy Coding!!!

Vagrant and Virtual Installation

To practice and execute these common commands, you can set up a virtual machine using Vagrant and VirtualBox. Here's a step-by-step guide on how to proceed:

1. Install Vagrant and VirtualBox on your machine. You can find the installation instructions for your operating system on the respective websites:

   • Vagrant: vagrantup.com

   • VirtualBox: virtualbox.org

2. Open a terminal or command prompt on your machine.

3. Create a new directory where you want to set up the Vagrant project, e.g., /home/user/vagrant-project.

4. Change to the newly created directory:

    cd /home/user/vagrant-project
   

5. Initialize the Vagrant project by creating a Vagrantfile

    vagrant init ubuntu/focal64
   

6. Edit the Vagrantfile using a text editor of your choice and configure the virtual machine settings. For example, you can specify the base box, CPU and memory allocation, network settings, etc.

7. Save the changes to the Vagrantfile and exit the text editor.

8. Start the virtual machine:

    vagrant up
   

9. Once the virtual machine is up and running, you can connect to it using SSH:

    vagrant ssh
   

10. You are now inside the virtual machine, and you can run the Linux commands mentioned below:

    Note: If you want more help or information about a command use the man or --help command:

    man [command]
    

    [command] --help
    

Navigation:

• Change directory:

  • cd /home/user/Documents

• List files and directories:

  • ls or ls -l

• Print working directory:

  • pwd

• Make directory:

  • mkdir mydir

• Remove files and directories:

  • rm myfile.txt or rm -r mydir

• Copy files and directories:

  • cp file1.txt file2.txt or cp -r dir1 dir2

• Move or rename files and directories:

  • mv file1.txt file2.txt or mv myfile.txt newdir/myfile.txt

• Search for files and directories:

  • find /home/user -name myfile.txt

• Search for patterns in files:

  • grep "keyword" myfile.txt

• Concatenate and display file content:

  • cat myfile.txt

• View file content with pagination:

  • less myfile.txt

• Output the beginning of a file:

  • head myfile.txt

• Output the end of a file:

  • tail myfile.txt

• Create links between files:

  • ln -s myfile.txt mylink

• Change file permissions:

  • chmod 644 myfile.txt

File Manipulation:

• Create an empty file:

  • touch myfile.txt

• Text editor (nano):

  • nano myfile.txt

• Text editor (vi/vim):

  • vim myfile.txt

• Determine file type:

  • file myfile.txt

• Word, line, character, and byte count:

  • wc myfile.txt

• Archive files:

  • tar -cvf archive.tar file1.txt file2.txt

• Compress files:

  • gzip myfile.txt

• Decompress files:

  • gunzip myfile.txt.gz

• Package and compress files:

  • zip archive.zip file1.txt file2.txt

• Extract files from a zip archive:

  • unzip archive.zip

Process Management:

• Display running processes:

  • ps aux

• Monitor system activity and processes:

  • top

• Terminate processes:

  • kill PID

• Run a process in the background:

  • command &

• Bring a background process to the foreground:

  • fg

• Display current jobs:

  • jobs

System Information:

• Print system information:

  • uname -a

• Print the current user:

  • whoami

• Print the hostname:

  • hostname

• Disk space usage:

  • df -h

• Estimate file and directory space usage:

  • du -sh /path/to/directory

• Display memory usage:

  • free -m

• System uptime:

  • uptime

• Network configuration:

  • ifconfig or ip addr show

Package Management:

• Package handling utility (Debian-based systems):

  • sudo apt-get install package_name

• Package manager (RHEL-based systems):

  • sudo yum install package_name

• Package manager (Arch Linux):

  • sudo pacman -S package_name

Networking:

• Send ICMP echo requests to a network host:

  • ping www.example.com

• Download files from the web:

  • wget https://example.com/file.txt

• Transfer data using various protocols:

  • curl https://example.com

• Secure shell client:

  • ssh user@hostname

• Securely copy files between hosts:

  • scp myfile.txt user@hostname:/path/to/destination

• File Transfer Protocol (FTP) client:

  • ftp hostname

• Secure FTP client:

  • sftp user@hostname

• Network configuration:

  • ifconfig or ip addr show

• Network statistics:

  • netstat

User Management:

• Create a new user:

  • sudo adduser newuser

• Delete a user:

  • sudo deluser username

• Change user password:

  • sudo passwd username

• Switch to another user:

  • su username

• Grant administrative privileges:

  • sudo usermod -aG sudo username

System Maintenance:

• Update package lists and upgrade installed packages:

  • sudo apt-get update && sudo apt-get upgrade

• Restart the system:

  • sudo reboot

• Shutdown the system:

  • sudo shutdown now

• View system logs:

  • tail /var/log/syslog

• Check system disk usage:

  • df -h

• Check system memory usage:

  • free -m

• Monitor system resources and processes:

  • top

These are just a few examples of commonly used Linux commands. There are many more commands available with various options and functionalities. It's always a good idea to refer to the documentation or online resources for more detailed information about specific commands.

References

The 50 Most Popular Linux & Terminal Commands

Introduction

To use cloud-based providers like AWS and Azure with Vagrant and VirtualBox, you need to configure Vagrant to work with the chosen cloud provider. Here are step-by-step instructions for using AWS and Azure with Vagrant and VirtualBox:

Using AWS with Vagrant and VirtualBox:

1. Install the necessary dependencies:

   • Install VirtualBox: Download and install VirtualBox from the official website (choco - Windows or brew - macOS).

   • Install Vagrant: Download and install Vagrant from the official website (choco - Windows or brew - macOS).

2. Install the AWS plugin for Vagrant:

   • Open a command prompt or terminal.

   • Run the following command to install the AWS plugin: vagrant plugin install vagrant-aws.

3. Set up AWS credentials:

   • Create an AWS account if you don't have one already.

   • Generate an access key and secret key from the AWS Management Console.

   • Configure your AWS credentials locally by running the following command: aws configure. Enter your access key, secret key, default region, and output format.

4. Create a Vagrantfile:

   • Create a new directory for your Vagrant project.

   • Navigate to the project directory using the command prompt or terminal.

   • Run the following command to initialize a new Vagrantfile: vagrant init.

   • Open the generated Vagrantfile in a text editor and configure it according to your requirements. Refer to the Vagrant AWS plugin documentation for specific configuration options.

5. Specify the AWS provider in the Vagrantfile:

   • Add the following lines to your Vagrantfile to configure the AWS provider:

       Vagrant.configure("2") do |config|
         config.vm.provider :aws do |aws, override|
           aws.access_key_id = "YOUR_ACCESS_KEY"
           aws.secret_access_key = "YOUR_SECRET_KEY"
           aws.region = "YOUR_REGION"
           aws.instance_type = "INSTANCE_TYPE"
           aws.ami = "AMI_ID"
         end
       end
     

6. Launch the AWS instance:

   • In the command prompt or terminal, navigate to the project directory.

   • Run the command vagrant up --provider=aws to launch the AWS instance.

Using Azure with Vagrant and VirtualBox:

1. Install the necessary dependencies:

   • Install VirtualBox: Download and install VirtualBox from the official website (choco - Windows or brew - macOS).

   • Install Vagrant: Download and install Vagrant from the official website (choco - Windows or brew - macOS).

2. Install the Azure plugin for Vagrant:

   • Open a command prompt or terminal.

   • Run the following command to install the Azure plugin: vagrant plugin install vagrant-azure.

3. Set up Azure credentials:

   • Create an Azure account if you don't have one already.

   • Generate a service principal and obtain the client ID, client secret, tenant ID, and subscription ID.

   • Configure your Azure credentials locally by running the following command: az login.

4. Create a Vagrantfile:

   • Create a new directory for your Vagrant project.

   • Navigate to the project directory using the command prompt or terminal.

   • Run the following command to initialize a new Vagrantfile: vagrant init.

   • Open the generated Vagrantfile in a text editor and configure it according to your requirements. Refer to the Vagrant Azure plugin documentation for specific configuration options.

Specify the Azure provider in the Vagrantfile

• Add the following lines to your Vagrantfile to configure the Azure provider:

    Vagrant.configure("2") do |config|
      config.vm.provider :azure do |azure, override|
        azure.tenant_id = "YOUR_TENANT_ID"
        azure.client_id = "YOUR_CLIENT_ID"
        azure.client_secret = "YOUR_CLIENT_SECRET"
        azure.subscription_id = "YOUR_SUBSCRIPTION_ID"
        azure.location = "YOUR_LOCATION"
        azure.vm_image_urn = "PUBLISHER:OFFER:SKU:VERSION"
      end
    end
  

Launch the Azure instance

• In the command prompt or terminal, navigate to the project directory.

• Run the command vagrant up --provider=azure to launch the Azure instance.

Please note that the specific configuration options and commands may vary based on the versions of Vagrant, VirtualBox, and the respective cloud provider plugins you are using. Refer to the documentation and resources provided by the cloud provider and the Vagrant plugins for detailed instructions and up-to-date information.

Remember to consider any costs associated with using cloud-based instances, as you may be billed based on the usage and resources consumed.

References

• Vagrant AWS plugin

• Vagrant Azure plugin

• AWS Documentation

• Azure Documentation

Remember to explore these resources to ensure accurate and up-to-date information.

Introduction

Developers often face challenges when setting up and managing development environments across different machines. However, tools like Vagrant and VirtualBox offer a seamless solution by providing a way to create and manage virtual environments effortlessly. In this blog post, we will walk you through the installation process of Vagrant and VirtualBox on Windows and macOS using two popular package managers: Choco and Brew. We'll also highlight commands that work specifically with Vagrant and VirtualBox, showcasing their unique benefits and demonstrating how they outperform commands on Git Bash for Windows users.

Installations

Installing Choco (Windows) and Brew (macOS)

If this is not your first time using Chocolatey or Chocolatey is already installed on your Windows Operating System skip this section.

Choco is a powerful package manager for Windows that simplifies software installation.

To install Chocolatey, follow these steps:

1. Search for PowerShell and run it as an administrator on Windows.

2. Go to the Chocolatey installation page.

3. If this is your first time installing Chocolatey on your operating system, execute the following command in your terminal, based on the instructions provided on the installation page:

Get-ExecutionPolicy

• If the output is "Restricted", enter one of the commands below:

Set-ExecutionPolicy AllSigned

or

Set-ExecutionPolicy Bypass -Scope Process

• Regardless of whether "Restricted" was the previous output or not, run the following command (copy and paste it into your terminal):

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

• If there are no errors, check if Chocolatey was successfully installed by running the following command:

choco

If the output displays the version of Chocolatey you are using, it means the installation was successful.

Now you can install any package you want or upgrade an already existing package:

choco install <package>

choco upgrade <package>

For example:

choco install git

choco upgrade chocolatey

Note: Anytime asked Do you want to run the script?, type a (or all) more often rather than y (or yes) and click enter.

Do you want to run the script?([Y]es/[A]ll - yes to all/[N]o/[P]rint): a

Installing Vagrant and VirtualBox with Choco

With Choco installed, let's proceed to install Vagrant and VirtualBox on Windows using Choco.

1. Installing Vagrant:

   • Open PowerShell or Command Prompt.

   • Execute the following command to install Vagrant using Choco:

       choco install vagrant
     

2. Installing VirtualBox:

   • Open PowerShell or Command Prompt.

   • Run the following command to install VirtualBox using Choco:

       choco install virtualbox
     

Installing Vagrant and VirtualBox with Brew

Before we proceed, Check if Homebrew is already installed.

brew -v

If you don't get the version, run the command below:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Normally Homebrew will provide further installation commands on the terminal to execute, make sure you execute them. For example, you might be requested to run the commands below. Run the following two commands in your terminal to add Homebrew to your PATH:

(echo; echo 'eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"') >> /home/vagrant/.profile
   eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"

These commands will add the necessary configuration to your profile so that Homebrew can be accessed from your terminal.

Now check again if it is installed successfully:

brew -v

1. Installing Vagrant:

   • Open Terminal.

   • Execute the following command to install Vagrant using brew:

       brew install vagrant
     

2. Installing VirtualBox:

   • Open Terminal.

   • Execute the following command to install VirtualBox (VM) using brew:

       brew install --cask virtualbox
     

Using Vagrant and VirtualBox

Now that we have Vagrant and VirtualBox installed, let's explore their functionalities and see how they simplify development workflows.

Box Names

When using the vagrant init command, the box name represents the base image or template from which Vagrant will create your virtual machine. The box name determines the operating system, pre-installed software, and configurations available for your development environment. Here are a few commonly used box names and their uses:

1. hashicorp/bionic64:

   • Ubuntu 18.04 LTS (Bionic Beaver) 64-bit base box provided by HashiCorp.

   • Suitable for general-purpose development and testing on Ubuntu.

2. ubuntu/focal64:

   • Ubuntu 20.04 LTS (Focal Fossa) 64-bit base box provided by Ubuntu.

   • Similar to hashicorp/bionic64, but with the newer Ubuntu 20.04 LTS release.

3. centos/8:

   • CentOS 8 64-bit base box provided by CentOS.

   • Ideal for working with CentOS-specific software and configurations.

4. debian/buster64:

   • Debian 10 (Buster) 64-bit base box provided by the Debian project.

   • Useful for Debian-based development and testing.

5. fedora/33-cloud-base:

   • Fedora 33 Cloud Base 64-bit base box provided by the Fedora project.

   • Suitable for Fedora-specific development and testing.

6. windows-server-2019:

   • Windows Server 2019 base box provided by Microsoft.

   • Enables Windows-based development and testing environments.

7. Custom Boxes:

   • Apart from the official boxes, you can also use custom boxes created by the community or yourself.

   • Custom boxes allow you to tailor the virtual machine to your specific requirements, including pre-installed software, configurations, and provisioning scripts.

It's important to choose a box that aligns with your development needs and matches the desired operating system and software stack. Official boxes are typically reliable and regularly updated, but custom boxes can provide more flexibility if you have specific requirements.

When selecting a box, consider factors such as the operating system version, software compatibility, available support, and the community around the box. Reading the documentation and reviews for each box can help you make an informed decision based on your specific use case.

1. Creating and Starting a Vagrant Virtual Machine:

   • Open PowerShell or Command Prompt.

   • Navigate to your project directory.

   • Execute the following commands to initialize and start a Vagrant virtual machine:

       vagrant init <box-name>
       vagrant up
     

2. Accessing the Vagrant Virtual Machine:

   • To SSH into the virtual machine, use the following command:

       vagrant ssh
     

3. Managing Vagrant Virtual Machines:

   Run outside of the virtual machine environment (e.g., default OS terminal).

   • To stop a running virtual machine, use:

       vagrant halt
     

   • To destroy a virtual machine, use:

       vagrant destroy
     

4. Creating and Managing VirtualBox Virtual Machines:

   • Open VirtualBox Manager to create and manage virtual machines using a graphical interface.

• Alternatively, you can utilize the VBoxManage command-line tool for advanced management and automation.

Harnessing the Power of Vagrant and VirtualBox: Vagrant and VirtualBox provide a streamlined approach to managing development environments, allowing developers to work in isolated, reproducible setups. These tools offer the following benefits:

1. Consistency: Vagrant and VirtualBox ensure that every team member has an identical development environment, reducing compatibility issues.

2. Reproducibility: By defining project dependencies and configurations within Vagrant, developers can recreate the same environment across different machines.

3. Collaboration: With Vagrant, teams can easily share development environments, making it effortless to collaborate on projects.

4. Scalability: Vagrant simplifies the process of scaling environments by allowing the provisioning of multiple virtual machines.

Conclusion

In this blog post, we explored the installation and utilization of Vagrant and VirtualBox on Windows using Choco and Brew. We highlighted the advantages of these tools and provided commands that enhance the development experience for Windows users. With Vagrant and VirtualBox, you can effortlessly create and manage consistent and reproducible virtual environments, simplifying the development process and boosting collaboration within teams. Embrace the power of Vagrant and VirtualBox to enhance your development workflow and take your projects to new heights.

References

• Vagrant Documentation

• VirtualBox Documentation

• Choco Documentation

• Brew Documentation

• HashiCorp Vagrant GitHub Repository

• Vagrant Cloud

Remember to explore these resources and refer to the official website of Vagrant and Virtual Box or head over to their documentation to ensure accurate and up-to-date information.

Introduction

In the Linux ecosystem, familiarity with essential commands and an understanding of file permissions are fundamental for efficient system administration and file management. In this blog post, we will explore a set of essential commands, including cd, ls, pwd, less, file, ln, cp, mv, rm, mkdir, type, which, help, and man. Additionally, we will delve into the concept of file permissions and cover related commands such as chmod, sudo, su, chown, chgrp, id, groups, whoami, adduser, useradd, and addgroup. By the end of this article, you will have a comprehensive understanding of these commands and their practical applications.

Basic Linux Commands

Linux provides a wide range of commands that are essential for efficient system administration and file management. Let's explore some of the basic Linux commands:

cd - Change Directory

The cd command allows you to navigate between directories. Use it followed by the directory name to switch to a different directory. For example, to change to the /home/user/documents directory:

cd /home/user/documents

ls - List Files and Directories

The ls command lists the contents of a directory. Use it to view files and directories within the current directory. For example, to list the files and directories in the current directory:

ls

pwd - Print Working Directory

The pwd command displays the current working directory's absolute path. Use it to identify your current location within the file system. For example, to print the current working directory:

pwd

less - View File Content

The less command allows you to view the contents of a file. It provides a pager interface for easy navigation within large files. For example, to view the content of a file named example.txt:

less example.txt

file - Determine File Type

The file command determines the file type of a given file. It examines the file's contents and provides information about its format. For example, to determine the file type of a file named script.sh:

file script.sh

ln - Create Links

The ln command is used to create links between files. It can create hard links and symbolic (soft) links. For example, to create a symbolic link named link pointing to a file named target:

ln -s target link

cp - Copy Files and Directories

The cp command copies files and directories. It allows you to duplicate files and directories with different names or in different locations. For example, to copy a file named source.txt to a new file named destination.txt:

cp source.txt destination.txt

mv - Move/Rename Files and Directories

The mv command moves or renames files and directories. It can be used to change the name of a file or move it to a different location. For example, to move a file named file.txt to a different directory:

mv file.txt /path/to/directory/

rm - Remove Files and Directories

The rm command removes files and directories. Use it with caution, as it permanently deletes files from the file system. For example, to remove a file named unwanted.txt:

rm unwanted.txt

mkdir - Create Directories

The mkdir command creates directories (folders) in the file system. Use it to create new directories. For example, to create a directory named docs:

mkdir docs

type

• Display Command Type:

The type command displays the type of a command. It indicates whether a command is a shell built-in, an alias, a function, or an executable file. For example, to display the type of the ls command:

type ls

which - Locate Command

The which command locates the executable file associated with a given command. It displays the absolute path to the command's binary file. For example, to locate the executable for the python command:

which python

help - Get Help for Shell Built-in Commands

The help command provides help and documentation for shell built-in commands. It displays information about the usage and options of a specific command. For example, to get help for the cd command:

help cd

man - Manual Pages

The man command displays the manual pages for a given command. It provides detailed information about command usage, options, and examples. For example, to view the manual page for the ls command:

man ls

File Permissions and Related Commands

File permissions play a crucial role in controlling access to files and directories. Let's explore some commands related to file permissions:

chmod - Change File Permissions

The chmod command is used to change the permissions of a file or directory. It allows you to grant or revoke read, write, and execute permissions for users, groups, and others. For example, to add execute permission for the owner of a file named script.sh:

chmod +x script.sh

sudo - Execute a Command with Superuser Privileges

The sudo command allows you to execute a command with superuser (root) privileges. It provides temporary administrative access for authorized users. For example, to install a package using sudo:

sudo apt-get install package_name

su - Switch User

The su command is used to switch to another user account. It enables you to execute commands with the privileges of the specified user. For example, to switch to the root user:

su -

chown - Change File Owner

The chown command changes the owner of a file or directory. It allows you to transfer ownership to another user. For example, to change the owner of a file named file.txt to the user newowner:

chown newowner file.txt

chgrp - Change Group Ownership

The chgrp command changes the group ownership of a file or directory. It allows you to assign a different group to the file. For example, to change the group ownership of a file named file.txt to the group newgroup:

chgrp newgroup file.txt

id - Display User and Group Information

The id command displays information about the current user and associated groups. It provides the user's UID (user ID) and GID (group ID). For example, to display user and group information:

id

groups - Display Group Membership

The groups command shows the groups to which a user belongs. It lists the group names associated with the current user. For example, to display group membership:

groups

whoami - Display Current User

The whoami command displays the username of the current user. It provides a quick way to identify the currently logged-in user. For example, to display the current user:

whoami

adduser - Add a User

The adduser command is used to add a new user to the system. It creates a user account with the specified username and assigns a home directory. For example, to add a user named newuser:

adduser newuser

useradd - Create a User Account

The useradd command creates a new user account. It allows you to specify various options, such as user ID, home directory, and login shell. For example, to create a user account named newuser with a home directory and the /bin/bash login shell:

useradd -m -s /bin/bash newuser

addgroup - Add a Group

The addgroup command adds a new group to the system. It creates a group with the specified group name and assigns a GID (group ID). For example, to add a group named newgroup:

addgroup newgroup

Conclusion

In this blog post, we have explored essential Linux commands for file management and system administration. We covered commands such as cd, ls, pwd, less, file, ln, cp, mv, rm, mkdir, type, which, help, and man. Additionally, we discussed the concept of file permissions and related commands such as chmod, sudo, su, chown, chgrp, id, groups, whoami, adduser, useradd, and addgroup. Mastering these commands and understanding file permissions will give you a solid foundation for effective Linux system management.

References

Here are some references you can explore to learn more about Linux commands and file permissions:

1. Linux Documentation Project (TLDP): https://tldp.org/

   • The TLDP provides a comprehensive collection of Linux documentation, including guides, how-tos, and tutorials on various topics.

2. GNU Core Utilities Manual: https://www.gnu.org/software/coreutils/manual/

   • The GNU Core Utilities manual provides detailed documentation on essential Linux commands, including cd, ls, pwd, less, file, ln, cp, mv, rm, mkdir, type, which, help, and man.

3. Linux man pages: https://man7.org/linux/man-pages/

   • The Linux man pages offer in-depth documentation for Linux commands. You can search for specific commands and explore their options, usage examples, and related information.

4. Linux File Permission Tutorial: https://www.guru99.com/file-permissions.html

   • This tutorial from Guru99 provides an overview of Linux file permissions, explaining the concepts of read, write, and execute permissions. It covers chmod, chown, and chgrp commands in detail.

5. Linux File System/Structure Explained: https://linuxhandbook.com/linux-file-system-structure/

   • This article on Linux Handbook explains the Linux file system structure, including directories, files, and their relationships. Understanding the file system structure is essential for effective file management.

6. Linux User and Group Management: https://www.tecmint.com/manage-users-and-groups-in-linux/

   • Tecmint provides a tutorial on managing users and groups in Linux. It covers commands like adduser, useradd, addgroup, and explains user and group administration concepts.

Remember to explore these resources and refer to the official documentation for your specific Linux distribution to ensure accurate and up-to-date information.

Introduction

Vim is a powerful and efficient text editor that has gained popularity among programmers and developers due to its speed and versatility. With its extensive collection of commands and customizable features, Vim provides a seamless editing experience. In this blog post, we will explore some essential Vim commands and shortcuts that will enhance your productivity and help you streamline your workflow. From basic navigation to advanced functionalities, we will cover a range of commands to help you master Vim and become a more proficient software engineer.

Installation

To install Vim on your system, follow the steps below:

Windows

1. Visit the Vim for Windows website and download the latest version of the installer.

2. Run the installer and follow the on-screen instructions to complete the installation process.

3. Once the installation is complete, you can open Vim by searching for "Vim" in the Start menu or by running it from the command prompt.

I prefer using Chocolatey (choco) to install packages, so check out the installation steps below:

Steps

To install Chocolatey and use it to install Vim, follow these steps:

1. Search for PowerShell and run it as an administrator on Windows.

2. Go to the Chocolatey installation page.

3. If this is your first time installing Chocolatey on your operating system, execute the following command in your terminal, based on the instructions provided on the installation page:

Get-ExecutionPolicy

• If the output is "Restricted", enter one of the commands below:

Set-ExecutionPolicy AllSigned

or

Set-ExecutionPolicy Bypass -Scope Process

• Regardless of whether "Restricted" was the previous output or not, run the following command (copy and paste it into your terminal):

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

• If there are no errors, check if Chocolatey was successfully installed by running the following command:

choco

If the output displays the version of Chocolatey you are using, it means the installation was successful.

• Now, search for the package you need (in this case, Vim) by visiting the package search page. Once you find the Vim package, execute the following command:

choco install vim

• Open any terminal of your choice and type vim to start using Vim:

vim

Opening files and directories in Vim is a straightforward process. To open a specific file, you can use the following command:

vim <filename>

For example, if you want to open the file named "README.md," you would use the command:

vim README.md

On the other hand, if you wish to open a directory, use the following command:

vim <directory>

For instance, let's say you have a directory called "myProject," and you want to open it in Vim. You would execute the command:

vim myProject

By following these steps, you will be able to install Vim on your Windows system and begin using it for your text editing needs.

macOS

1. Open the Terminal application.

2. Install Vim using Homebrew by executing the following command:

brew install vim

Linux (Ubuntu)

1. Open the Terminal application.

2. Install Vim using the package manager by executing the following command:

sudo apt-get update
sudo apt-get install vim

Now that you have Vim installed on your system, let's dive into the basic commands and shortcuts that will help you get started.

Getting Started with Vim

To open a file in Vim, use the following command:

vim <filename>

For example, to open a file named "example.txt," you would use the command:

vim example.txt

Once you have a file open in Vim, you'll be in normal mode, where you can navigate, edit, and execute commands.

Navigating and Editing

In the commands below make sure you press the ESC key before typing or pressing any of the commands.

Moving within the Document

• h moves the cursor one character to the left.

• j moves the cursor one line down.

• k moves the cursor one line up.

• l moves the cursor one character to the right.

• w moves the cursor to the beginning of the next word.

• b moves the cursor to the beginning of the previous word.

• 0 (zero) moves the cursor to the beginning of the current line.

• $ moves the cursor to the end of the current line.

• gg moves the cursor to the first line of the document.

• G moves the cursor to the last line of the document.

• <line-number>G moves the cursor to a specific line number.

Copying, Cutting, and Pasting

• v enters visual mode, allowing you to select text.

• y copies the selected text (yank).

• d cuts the selected text (delete).

• p pastes the copied or cut text after the cursor.

• P pastes the copied or cut text before the cursor.

Undoing Changes and Quitting

• u undoes the last change.

• Ctrl + r redo the last undone change.

• :q quits Vim (closes the current file).

• :q! quits Vim without saving changes.

• :w saves the changes to the current file.

• :wq saves the changes and quits Vim.

Searching and Replacing

• / enters search mode.

• Type the search term and press Enter to search forward

• ? enters backward search mode.

• Type the search term and press Enter to search backward.

• n jumps to the next occurrence of the search term.

• N jumps to the previous occurrence of the search term.

• :s/search-term/replacement replaces the first occurrence of "search-term" with "replacement" in the current line.

• :s/search-term/replacement/g replaces all occurrences of "search-term" with "replacement" in the current line.

• :%s/search-term/replacement/g replaces all occurrences of "search-term" with "replacement" in the entire file.

Buffers and Windows

Vim allows you to work with multiple files simultaneously using buffers and windows.

Buffers

• :e <filename> opens a file in a new buffer.

• :ls lists all open buffers.

• :b <buffer-number> switches to a specific buffer.

• :bd closes the current buffer.

• :q quits Vim if no other buffers are open.

Windows

• :sp <filename> splits the current window horizontally and opens the file in the new window.

• :vsp <filename> splits the current window vertically and opens the file in the new window.

• Ctrl + w + w switches between open windows.

• Ctrl + w + h/j/k/l moves the cursor to the window in the corresponding direction.

• Ctrl + w + c closes the current window.

Advanced Features

Macros

Macros allow you to record a sequence of commands and replay them.

• q<register> starts recording a macro in the specified register (e.g., qa starts recording in register a).

• Perform the desired commands.

• q stops recording the macro.

• @<register> replays the macro stored in the specified register (e.g., @a replays the macro stored in register a).

Marks

Marks allow you to quickly navigate to specific locations within a file.

• m<letter> sets a mark at the current cursor position (e.g., ma sets a mark named a).

• ' followed by the mark letter jumps to the line where the mark is set (e.g., 'a jumps to the line of mark a).

• followed by the mark letter jumps to the exact cursor position where the mark is set (e.g.,a jumps to the cursor position of mark a).

Plugins

Vim supports a vast ecosystem of plugins that extend its functionality. Here are a few popular plugins:

• Vundle: A plugin manager for Vim.

• NERDTree: A file explorer plugin for Vim.

• CtrlP: A fuzzy file finder plugin for Vim.

• YouCompleteMe: A code completion plugin for Vim.

These plugins can be installed and managed using plugin managers such as Vundle or Vim-Plug.

Conclusion

Vim is a powerful text editor with a steep learning curve, but mastering its commands and shortcuts can greatly enhance your productivity as a software engineer. We have covered some essential commands and functionalities in this blog post, including navigation, editing, searching, and advanced features like macros and marks. By exploring and practicing these commands, you'll become more proficient in Vim and be able to edit text efficiently and effectively.

Happy Vim editing!

References

• Vim Official Website

• Vim Documentation

• Vim Cheat Sheet

• Vim GitHub Repository

Introduction

Emacs is a versatile and highly customizable text editor that has been a favorite among programmers and writers for decades. With its extensive collection of commands and shortcuts, Emacs provides an efficient and powerful editing experience. This blog post will explore some essential Emacs commands and shortcuts that can significantly enhance your productivity. From basic navigation to advanced features, we will cover a range of commands to help you master Emacs and streamline your workflow.

Installation

For detailed instructions on installing Emacs, please refer to the official Emacs website. However, if you're a Windows user, I'll provide you with a few commands to help you install Emacs.

Steps

To install Chocolatey and use it to install Emacs, follow these steps:

1. Search for PowerShell and run it as an administrator on Windows.

2. Go to the Chocolatey installation page.

3. If this is your first time installing Chocolatey on your operating system, execute the following command in your terminal, based on the instructions provided on the installation page:

Get-ExecutionPolicy

• If the output is "Restricted", enter one of the commands below:

Set-ExecutionPolicy AllSigned

or

Set-ExecutionPolicy Bypass -Scope Process

• Regardless of whether "Restricted" was the previous output or not, run the following command (copy and paste it into your terminal):

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

• If there are no errors, check if Chocolatey was successfully installed by running the following command:

choco

If the output displays the version of Chocolatey you are using, it means the installation was successful.

• Now, search for the package you need (in this case, Emacs) by visiting the package search page. Once you find the Emacs package, execute the following command:

choco install emacs

• Open any terminal of your choice and type emacs to start using Emacs:

emacs

Opening files and directories in Emacs is a straightforward process. To open a specific file, you can use the following command:

emacs <filename>

For example, if you want to open the file named "README.md," you would use the command:

emacs README.md

On the other hand, if you wish to open a directory, use the following command:

emacs <directory>

For instance, let's say you have a directory called "myProject," and you want to open it in Emacs. You would execute the command:

emacs myProject

By following these steps, you will be able to install Emacs on your Windows system and begin using it for your text editing needs.

Getting Started with Emacs

To open Emacs in the terminal, use the emacs -Q -nw command, and then use Ctrl + x Ctrl + f to open a file by typing the file name at the bottom of the terminal. The command emacs -Q -nw starts Emacs in the terminal without loading any configuration files, ensuring a clean environment. Once Emacs is running, you can access the drop-down menu by pressing F10.

Note: To save changes on Emacs use Ctrl + x Ctrl + s.

Navigating and Editing

Moving within the Document

• Ctrl + f moves the cursor forward one character.

• Ctrl + p moves the cursor backward one line.

• Alt + f moves the cursor forward one word.

• Alt + b moves the cursor backward one word.

• Ctrl + a moves the cursor to the beginning of the line.

• Ctrl + e moves the cursor to the end of the line.

• Alt + a moves the cursor to the beginning of the sentence.

• Alt + e moves the cursor to the end of the sentence.

• Alt + Shift + } moves the cursor to the previous paragraph.

• Alt + Shift + { moves the cursor to the next paragraph.

• Alt + Shift + < moves the cursor to the beginning of the document.

• Alt + Shift + > moves the cursor to the end of the document.

• Alt + g g prompts for a line number and jumps to that line.

Copying, Cutting, and Pasting

• Ctrl + space + arrow or Ctrl + n/p/f/b selects text.

• Alt + w copies the selected text to the kill-ring.

• Ctrl + y pastes the text from the kill-ring.

• Ctrl + w cuts the selected text and adds it to the kill-ring.

• Ctrl + k cuts text from the cursor position to the end of the line.

• Ctrl + x backspace cuts text from the cursor position to the beginning of the line.

• Alt + Z . cuts until the first occurrence of a specified character (e.g., .).

• Esc + 2 Esc + d deletes the next two words.

Undoing changes and Quitting

• To undo your last action, press Ctrl + x u.

• To quit Emacs, press Ctrl + x Ctrl + c.

Searching and Replacing

• Ctrl + s initiates a search. Type the desired search term and press Ctrl + s to find the next occurrence.

• Ctrl + r searches for the previous occurrence.

• Alt + Shift + % activates the search-and-replace functionality.

Buffers and Frames

• Ctrl + x Ctrl + f opens Dired (Directory Editor) file manager to open a document named text.txt.

• Ctrl + x 0 removes or closes the current buffer frame.

• Ctrl + x b selects a different buffer.

• Ctrl + x k kills (closes) the current buffer.

• Ctrl + h v followed by a specific buffer name (e.g., kill-ring) opens the buffer frame.

Advanced Features

Zooming

• Ctrl + x Ctrl + + zooms in.

• Ctrl + x Ctrl + - zooms out.

Splitting Windows

• Ctrl + x 2 splits the window horizontally.

• Ctrl + x 3 splits the window vertically.

• Ctrl + x 0 closes the split window.

• Ctrl + x 4 f opens a new frame on the right side in a vertical split.

• Ctrl + x o tabs over to the other frame.

• Ctrl + x Ctrl + c closes the current window.

Customizing Emacs Appearance with Plugins

Emacs is known for its highly customizable nature, allowing users to tailor the editor to their preferences. There are several plugins available that can enhance the appearance of Emacs and make it look better. Here are some popular plugins you can use to customize the appearance of Emacs:

doom-themes

• GitHub: https://github.com/hlissner/emacs-doom-themes

Doom-themes is a collection of customizable themes for Emacs that provide a sleek and modern look. It offers a variety of dark and light themes with different color schemes. To install doom-themes, you can use the package manager built into Emacs, such as package.el or use-package.

spacemacs-theme

• GitHub: https://github.com/nashamri/spacemacs-theme

Spacemacs-theme is another popular theme for Emacs inspired by the Spacemacs editor. It offers a visually appealing and well-balanced color scheme. Similar to doom-themes, you can install spacemacs-theme using Emacs' package manager.

all-the-icons

• GitHub: https://github.com/domtronn/all-the-icons.el

all-the-icons is a package that provides a set of scalable icons for Emacs. It enhances the visual appearance of various Emacs packages by adding icons next to file names, buffer names, and more. This package is commonly used in conjunction with other themes to provide a more visually appealing experience.

powerline

• GitHub: https://github.com/milkypostman/powerline

Powerline is a plugin that creates a status bar with informative and customizable segments. It displays various information such as the current mode, line number, git branch, and more. Powerline enhances the overall look of Emacs by adding a stylish and informative status bar.

rainbow-delimiters

• GitHub: https://github.com/Fanael/rainbow-delimiters

Rainbow-delimiters is a simple but effective plugin that highlights parentheses, brackets, and braces with different colors. This plugin makes it easier to identify matching pairs and improves the readability of Lisp-like languages. It can be especially useful when working with complex nested structures.

which-key

• GitHub: https://github.com/justbur/emacs-which-key

Which-key is a helpful plugin that displays key bindings and their associated commands in a popup window. It helps you discover and remember Emacs commands by showing the available options whenever you press a prefix key. Which-key improves the usability of Emacs by providing visual guidance and reducing the need to remember complex key sequences.

beacon

• GitHub: https://github.com/Malabarba/beacon

Beacon is a small but useful plugin that highlights the cursor position whenever it jumps to a new location. It provides a visual indicator, such as a flashing beacon or a temporary background color change, to draw attention to the cursor. This can be particularly helpful when working with large documents or unfamiliar codebases.

These are just a few examples of the many plugins available for customizing the appearance of Emacs. To install these plugins, you can follow the installation instructions provided in their respective GitHub repositories. Remember to

consult the documentation and readme files of each plugin for configuration options and additional features.

By leveraging these plugins, you can transform the appearance of Emacs to suit your preferences and create a visually appealing and personalized editing environment.

Conclusion

Emacs provides extensive commands and shortcuts to enhance your editing experience. By mastering these commands, you can navigate through documents, edit text efficiently, search and replace, manage buffers and frames, and take advantage of advanced features such as zooming and window splitting. With time and practice, Emacs can become a powerful tool in your arsenal, enabling you to become a more productive and efficient software engineer.

Happy Emacs editing!

References

• GitHub Repository

• GNU RefCard

• YouTube

Introduction

Flowcharts are powerful tools that provide a visual representation of processes, allowing individuals to understand and analyze complex workflows. They are widely used in various industries, from software development to business management, to document and communicate processes effectively. In this article, we will explore the concept of flowcharts, their benefits, and how to create them.

What is a Flowchart?

A flowchart is a diagrammatic representation of a process or workflow. It uses different shapes and symbols to illustrate the sequence of steps, decision points, and flow of information or materials. Flowcharts provide a clear and concise overview of a process, making it easier to identify bottlenecks, inefficiencies, or opportunities for improvement.

Benefits of Flowcharts

• Visual Clarity: Flowcharts present complex processes in a visually appealing and easy-to-understand manner, allowing stakeholders to grasp the overall process flow quickly.

• Process Analysis: By examining a flowchart, individuals can identify potential issues, redundancies, or areas of improvement within a process.

• Communication and Collaboration: Flowcharts serve as a common visual language, facilitating communication and collaboration among team members, stakeholders, and departments.

• Standardization: Flowcharts help establish standardized procedures and guidelines by providing a visual representation of the preferred process flow.

• Training and Onboarding: Flowcharts are valuable tools for training new employees, as they provide a step-by-step representation of processes and procedures.

Common Flowchart Symbols

Flowcharts use various symbols to represent different elements of a process. Here are some commonly used symbols:

• Oval: Represents the start or end point of a process.

• Rectangle: Depicts a specific step or activity within the process.

• Diamond: Signifies decision points or branching paths based on a condition or criteria.

• Arrow: Indicates the flow or direction of the process.

• Parallelogram: Represents input or output of data.

• Circle: Denotes connectors or join points for different parts of the flowchart.

Types of Flowcharts

• Process Flowchart: Illustrates the sequential steps of a process from start to finish.

• Swimlane Flowchart: Organizes the process steps into lanes or columns, representing different departments, individuals, or responsibilities.

• Data Flow Diagram: Focuses on the flow of data or information within a system or process.

• Workflow Diagram: Demonstrates the movement of tasks or activities within a workflow, including dependencies and decision points.

Creating a Flowchart

To create an effective flowchart, follow these steps:

• Identify the process: Clearly define the process or workflow you want to represent in the flowchart.

• Determine the symbols: Select the appropriate flowchart symbols to represent each step, decision point, or data input/output.

• Define the flow: Connect the symbols using arrows to indicate the sequence and direction of the process flow.

• Validate and refine: Review the flowchart for accuracy, clarity, and completeness. Make adjustments as necessary.

• Share and collaborate: Share the flowchart with relevant stakeholders to gather feedback and ensure understanding.

An example of a Flowchart with Pseudocode is shown below

Pseudocode:

1. Start
2. Input the temperature in Celsius
3. Calculate the temperature in Fahrenheit using the formula: Fahrenheit = (Celsius * 9/5) + 32
4. Display the temperature in Fahrenheit
5. End

Check out the article on Pseudocode to learn more.

Flowchart:

Start
↓
Input Celsius temperature
↓
Fahrenheit = (Celsius * 9/5) + 32
↓
Display Fahrenheit temperature
↓
End

Remember, a well-designed flowchart is not only visually appealing but also an accurate reflection of the underlying process. So, leverage the power of flowcharts to map, analyze, and improve your processes, and unlock new opportunities for efficiency and growth.

References

GitHub Repository

Introduction

Git has revolutionized the way developers collaborate and manage their code. Whether you're a beginner or an experienced developer, understanding the basic concepts and essential commands of Git is crucial for efficient version control. In this blog post, we'll explore the fundamental concepts of Git, including push, merge, branches, and more. We'll also provide code snippets to illustrate how these commands are used in practice. Let's dive in!

Installation

For detailed instructions on installing Git, please refer to the official Git website. However, if you're a Windows user, I'll provide you with a few commands to help you install Git.

Steps

To install Chocolatey and use it to install Git, follow these steps:

1. Search for PowerShell and run it as an administrator on Windows.

2. Go to the Chocolatey installation page.

3. If this is your first time installing Chocolatey on your operating system, execute the following command in your terminal, based on the instructions provided on the installation page:

Get-ExecutionPolicy

• If the output is "Restricted", enter one of the commands below:

Set-ExecutionPolicy AllSigned

or

Set-ExecutionPolicy Bypass -Scope Process

• Regardless of whether "Restricted" was the previous output or not, run the following command (copy and paste it into your terminal):

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

• If there are no errors, check if Chocolatey was successfully installed by running the following command:

choco

If the output displays the version of Chocolatey you are using, it means the installation was successful.

• Now, search for the package you need (in this case, Git) by visiting the package search page. Once you find the Git package, execute the following command:

choco install git

Basic Concepts

Before we delve into the commands, let's quickly review some basic concepts of Git:

ls -la

The ls -la command (or ls on Windows) lists all files and directories, including hidden ones, in the current directory. It helps you get a comprehensive view of the files present.

git commit -m "commit msg" -m "desc. msg"

The git commit command records change to the repository. By specifying a commit message (-m flag), you provide a concise description of the changes made. It's good practice to include both a short commit message and a more detailed description.

Generating SSH Keys

You can generate SSH keys to securely connect with remote repositories, such as GitHub. Here's a step-by-step guide:

Generate the SSH key

Use the ssh-keygen command to generate a new SSH key. For example:

ssh-keygen -t rsa -b 4096 -C "email@gmail.com"

Its output will look like below:

Generating public/private rsa key pair.
Enter file in which to save the key (/c/Users/TechstackMedia - Osagie/.ssh/id_rsa):

Where it asks you to enter a file name, you can enter any file name of your choice but for the case of this tutorial enter testkey and press Enter or Return.

Now you will probably get another question as shown below:

Enter passphrase (empty for no passphrase):

It is asking you to provide a passphrase for encryption or decryption purposes. It is used to protect sensitive data, such as private keys or encrypted files.

You may click enter meaning empty for no passphase but it is generally recommended to set a strong passphrase to enhance the security of your sensitive data.

Locate the key file

After generating the key, you can find it using the ls command combined with grep. For instance:

ls | grep testkey

Here, testkey is the file name containing the SSH key.

Note: the testkey without the .pub, its content should not be shared with anyone because it is the key you use to interact with GitHub.

Copy the public key

The public key (with a .pub extension) is the key you'll upload to your GitHub interface. Use the following command to copy it to your clipboard:

Now in the terminal run:

type testkey.pub | clip

Or

cat testkey.pub # copy the entire public key

Alternatively, you can simply run the command below:

pbcopy < testkey.pub

You might get the error shown below:

'pbcopy' is not recognized as an internal or external command,
operable program or batch file

If this is the case for you it means you are not using Linux or macOS to run the command. You must likely be on a Windows Operating System or any other Operating System not supporting the command. In such cases use the first method, cat testkey.pub and copy whatever is the output or run type testkey.pub | clip.

Add the SSH key on GitHub

Navigate to your GitHub account's settings, select "SSH and GPG keys", and add a new SSH key. Paste the copied key into the designated field. Don't forget to fill in the "Title" field.

Configure the local Git command interface

To ensure ssh-agent is running run the command:

eval "$(ssh-agent -s)"

Update the SSH agent

Now add your SSH private key to the ssh-agent as show below:

ssh-add testkey

The command above ensures that the local Git command interface recognizes the new key, run the following command.

Pushing Changes to a Remote Repository

To push your local repository to a remote repository (e.g., GitHub), follow these steps:

Identify the remote repository

Use the git remote -v command to view the remote repositories connected to your local repository.

Set the upstream repository

When pushing for the first time, set the upstream repository with the -u or --set-upstream flag:

git push -u origin master

This tells Git to push to the specified repository by default.

Subsequent pushes

For subsequent pushes, you can use the simpler command git push, as Git remembers the upstream repository.

Branches

Branches allow for parallel development and isolating specific features or fixes. Let's explore some common branch-related commands:

Creating a new branch

To create a new branch, use the git checkout -b command followed by the branch name. For example:

git checkout -b feature-readme-instructions

The command above does two actions, it creates a new branch called feature-readme-instructions and then checks out to that branch.

Below is the command breakdown:

git branch feature-readme-instructions

git checkout feature-readme-instructions

Switching between branches

To switch to a different branch, use the git checkout command followed by the branch name. For instance:

git checkout master

Viewing changes between branches

To see the code differences between the two branches, use the git diff command followed by the branch names:

git diff branchname

The git diff command shows the differences between the current branch and the specified branch.

Merging branches

To merge changes from one branch into another, use the git merge command followed by the branch name. For example:

git merge branchname

Deleting a branch

To delete a branch, use the git branch -d command followed by the branch name. For instance:

git branch -d branchname

Resolving Merge Conflicts

Sometimes, when merging branches, conflicts may arise when Git cannot automatically merge the changes.

Here's how to handle merge conflicts:

• Identify the conflicts: After attempting to merge branches, Git will notify you of any conflicts that occurred. You can use commands like git status or git diff to identify the conflicted files.

• Open the conflicted files: Open the conflicted files in a text editor or an integrated development environment (IDE). Inside the files, you'll see the conflicting sections marked with special characters like <<<<<<<, =======, and >>>>>>>.

  

• Resolve the conflicts: Manually edit the conflicted sections in the files to keep the desired changes and remove the conflicting content. Modify the files according to your intended final result.

• Alternatively, when resolving conflict in Git, there are options to either accept current changes or accept incoming changes or accept both changes. Accepting current changes means accepting the changes that exist in your local repository before pulling from the remote repository. If you choose this option, you are discarding the incoming changes from the remote branch and keeping your local changes. Accept Incoming Changes means accepting the changes that exist in the remote repository. If you choose this option, you are discarding your local changes and taking the changes from the remote branch. Accept Both Changes In some cases, you may want to combine both sets of changes from your local and remote repositories. You can manually edit the conflicted sections to incorporate both sets of changes, keeping the parts you want from each version.

• Once you have resolved the conflicts and made the necessary edits, you can save the changes, stage the resolved files, and commit them to complete the merge process.

• Add the resolved files: Use the git add command to stage the resolved files for the commit. For example, you can use git add file1.txt file2.txt to stage-specific files, or git add . to stage all modified files in the current directory.

• Commit the changes: Finally, use the git commit command to create a new commit with the resolved merge conflicts. You can provide a commit message using the -m flag, like git commit -m "Resolve merge conflicts".

Committing all modified files

Use the git commit -am "commit message" command to commit all modified files, including those added to the repository.

Note that git commit -am "commit message" is the same as combining the two commands below:

git add -A

git commit -m "commit message"

git add -A is the same as git add --all. Most developers prefer using period in place of --all or -A.

git add .

Unstaging and removing specific files

To unstage and remove specific files, use the git reset <filename> command. If no filename is specified, git reset will show the files to be reset.

Undoing a commit

If you need to undo a commit, use the git reset HEAD~1 command to move the pointer (HEAD) to the previous commit.

Resetting to a specific commit

To reset to a specific commit, use the git reset <commit hash> command, replacing <commit hash> with the hash of the desired commit.

Removing all commits and untracked files

In some cases, you may want to completely remove all commits and untracked files. Use git reset --hard <commit hash> to accomplish this.

Collaboration with Forks and Pull Requests

When collaborating on open-source projects, forks and pull requests facilitate contribution. Here's an overview:

Forking a repository

To contribute to a repository, you can create a fork of the original repository. This creates a copy of the repository under your account.

Making changes and creating a pull request

After forking the repository, make your desired changes in the forked repository. Then, create a pull request to propose your changes to the original repository.

Additional Useful Commands

git clone

When cloning a repository in Git, there are a few different ways to specify the source repository. Here are the common methods to clone a repository using the git clone command:

Cloning via HTTPS

git clone https://github.com/user/repo.git

This method uses the HTTPS protocol to clone the repository. You need to replace user with the username and repo with the name of the repository you want to clone.

Cloning via SSH

git clone git@github.com:user/repo.git

This method uses the SSH protocol to clone the repository. Again, replace user with the username and repo with the repository name.

Cloning via Git Protocol

git clone git://github.com/user/repo.git

The Git protocol is a lightweight protocol specifically for Git. This method clones the repository using the Git protocol.

Cloning via Subversion (SVN) Bridge

git svn clone svn://svn.example.com/repo

If the repository is a Subversion (SVN) repository, you can use the git svn clone command to clone it. Replace svn://svn.example.com/repo with the URL of the SVN repository.

Cloning a Local Repository

git clone /path/to/repository

If the repository is already on your local machine, you can specify the local path to clone it.

Cloning a Bare Repository

git clone --bare https://github.com/user/repo.git

The --bare option is used to clone a repository as a bare repository, which means it will not have a working directory. This is useful when you only need the repository's history and don't plan on making changes directly in the cloned repository.

These are the main methods to clone a repository using the git clone command. Choose the appropriate method based on the type and location of the repository you want to clone.

Cloning Private Repository

When cloning a private repository on GitHub, you can use a personal access token (PAT) to authenticate and include it in the URL when using the git clone command. This allows you to securely clone the repository without having to enter your GitHub username and password.

The syntax for cloning a repository using a personal access token is as follows:

git clone https://<token>@github.com/<username>/repo.git

Here's how to use it:

1. Generate a Personal Access Token (PAT) on GitHub:

   • Go to your GitHub account settings.

   • Navigate to "Developer settings" and click on "Personal access tokens".

   • Click on "Generate new token" and provide a meaningful description for the token.

   • Select the desired scopes/permissions for the token. For cloning a private repository, make sure to include the repo scope.

   • Click on "Generate token" and make a note of the generated token.

2. Clone the repository using the PAT:

   • In the git clone command, replace <token> with the personal access token you generated.

   • Replace <username> with your GitHub username.

   • Replace repo.git with the name of the repository you want to clone.

For example:

git clone https://your-token@github.com/your-username/repo.git

By including your personal access token in the URL, Git will use it to authenticate and allow you to clone the private repository without any manual authentication steps.

Remember to keep your personal access token secure and avoid sharing it with others, as it provides access to your GitHub account.

If at any point you have generated a new token, you can run the command (in the repo directory) in the format shown below:

git remote set-url origin https://your-new-token@github.com/your-username/repo.git

By running the command above, you will update the remote URL of the repository to use the new token, allowing you to authenticate and interact with the repository using the updated token.

git add

The git add command is used to stage changes for the next commit. You can use it to specify individual files or directories to add. For example:

git add file1.txt
git add directory/

git log

The git log command displays a history of commits in reverse chronological order. It shows the commit hash, author, date, and commit message. You can use flags like --oneline for a more concise output or --graph for a graphical representation of branch history. For example:

git log --oneline
git log --graph

git diff

The git diff command shows the differences between the working directory and the staging area (changes not yet staged) or between the staging area and the repository (changes staged but not yet committed). It helps you review changes before committing. For example:

git diff              # Show unstaged changes
git diff --staged     # Show staged changes

git pull

The git pull command is used to fetch and integrate changes from a remote repository into the current branch. It combines the git fetch and git merge commands. For example:

git pull origin master

This command fetches changes from the origin remote repository and merges them into the current branch.

Note: The code snippets provided assume a Unix-based operating system. Windows users may need to adjust certain commands or use alternative commands specific to their environment. For Windows users try installing a good terminal emulator like Git Bash.

References

• GitHub Repository

• YouTube

Pseudocode is a valuable tool for expressing algorithms in a high-level and abstract manner. It serves as a bridge between human understanding and actual programming languages. In this blog post, we will explore what pseudocode is, and its purpose, and provide examples of its usage in real-life scenarios.

What is Pseudocode?

Pseudocode is not an actual programming language but a representation of code that resembles a programming language without adhering to its strict syntax rules. The term pseudo refers to something false or fake, indicating that pseudocode is a simulated version of code. It allows programmers to focus on the logic and functionality of an algorithm rather than the specific language syntax.

The Purpose of Pseudocode

The primary purpose of pseudocode is to provide a high-level and abstract representation of an algorithm, independent of any particular programming language. By using pseudocode, programmers can simplify complex problems, avoid language-specific limitations, and facilitate understanding and implementation across different languages.

Pseudocode acts as a communication tool between programmers, enabling them to discuss and share algorithms without being constrained by specific programming languages. It allows for flexibility, as the same algorithm can be implemented in different languages based on the pseudocode's logic and structure.

Exam Board Pseudocode

In academic settings, exam boards often use standardized pseudocode in their questions and marking schemes. While these standardized versions of pseudocode may differ slightly between exam boards, they serve the purpose of ensuring consistency and ease of evaluation. However, it's important to note that these specific syntax rules are often only applicable within the context of exams and may not reflect real-world pseudocode usage.

Real-Life Examples

To understand how pseudocode is used in practice, let's examine some real-life examples. One such example can be found in university textbooks, where complex algorithms are explained using pseudocode. These textbooks often present machine learning algorithms, such as decision trees, and provide pseudocode representations to illustrate their functionality.

While the pseudocode in textbooks may appear different from what you encounter in exams, the core concepts remain the same. Pseudocode still utilizes familiar programming constructs like functions, parameters, conditionals (if-else statements), loops, and variables. The notation used in these examples simplifies the algorithm's implementation while excluding language-specific details.

Using pseudocode instead of actual programming languages has several advantages. Pseudocode condenses complex algorithms into concise representations, making them easier to understand. It also allows for algorithm portability, enabling programmers to implement the same logic across different programming languages. Additionally, pseudocode serves as a future-proof solution since it remains relevant even as programming languages evolve.

Understanding Pseudocode

Pseudocode is a simulated version of code that resembles a programming language but does not adhere to its strict syntax rules. It aims to focus on the logic and functionality of an algorithm, making it independent of any specific programming language. Pseudocode facilitates communication among programmers and enables the implementation of algorithms across different languages.

Writing Pseudocode

When writing pseudocode, remember that there is no one correct syntax. It's more important to focus on the algorithm's logic and functionality rather than adhering to specific formatting rules. Pseudocode should be clear and easily understandable by competent programmers familiar with the problem domain.

To illustrate the process of writing pseudocode, let's consider an example.

Example pseudocode for finding the average of two numbers.

Main program
input1 = get user input for number1
input2 = get user input for number2
result = calculateAverage(input1, input2)
display result

If I was to implement the logic in code using JavaScript, it would look like the example below:

function calculateAverage(number1, number2) {
    sum = number1 + number2
    average = sum / 2
    return average
}

calculateAverage(2, 8)

In this example, we define a function calculateAverage that takes two numbers as input, calculates their sum, computes the average, and returns it. The main program obtains user inputs, calls the calculateAverage function, and displays the result.

Here is another example:

The Problem:
Write a program that prints the number from 1 to 20:

For multiples of three print `"FIZZ"` instead of the number
For the multiple of five print `"Buzz"` instead of the number
For numbers which are multiples of both three and five print `"FizzBuzz"`
For numbers not divisible by 3, 5, or both print the number as it is.

The pseudocode would look like this:

FOR LOOP:
SET counter to 1
Break when counter reaches 20
Increment counter by 1
    IF number MOD 15 === 0
        print 'FizzBuzz'
    ELSE IF number MOD 3 === 0
        print 'Fizz'
    ELSE iF number MOD 5 === 0
        print 'Buzz'
    ELSE
        print number

Someone else could write the code as shown below and they will mean the same:

FOR i = 1 to 20 DO
    IF i is divisible by 3 and 5 THEN
        PRINT "FizzBuzz"
    ELSE IF i is divisible by 3 THEN
        PRINT "Fizz"
    ELSE IF i is divisible by 5 THEN
        PRINT "Buzz"
    ELSE
        PRINT i
    END IF
END FOR

The code snippets show that writing pseudocode is based on your pattern.

Note: Using this keyword like FOR, IF, ELSE IF ELSE, END, etc. are not mandatory because Pseudocode is flexible and allows for the use of alternative keywords or descriptive phrases as long as they effectively convey the intended logic and structure of the algorithm.

For example, instead of using FOR, you could use REPEAT or LOOP. Similarly, instead of END, you could use STOP or FINISH. The key is to maintain consistency within your pseudocode and ensure that the chosen keywords or phrases accurately represent the intended flow of the algorithm. The example below is the same as the pseudocode above but with a different approach.

Set i as 1
Repeat until i reaches 20:
    If i is divisible by both 3 and 5:
        Output "FizzBuzz"
    Otherwise, if i is divisible by 3:
        Output "Fizz"
    Otherwise, if i is divisible by 5:
        Output "Buzz"
    Otherwise:
        Output i
    Increment i by 1
End repeat

The code in JavaScript would look like this:

for (let i = 1; i <= 20; i++) {
    if (i % 15 === 0) {
        console.log('FizzBuzz')
    } else if (i % 3 === 0) {
        console.log('Fizz')
    } else if (i % 5 === 0) {
        console.log('Buzz')
    } else {
        console.log(i)
    }
}

As you can see, the pseudocode resembles a programming language but avoids specific syntax requirements.

Tips for Writing Pseudocode

Familiarize Yourself with Real Code

To effectively write and understand pseudocode, it is crucial to have a foundation in a real programming language. Learning a programming language such as Python or Java will provide you with the necessary knowledge and concepts to express algorithms in pseudocode.

Simplify and Generalize

When writing pseudocode, aim to simplify the code by excluding language-specific details and unnecessary complexities. Make it as general as possible while retaining clarity and readability. Remember, pseudocode is a high-level representation, so focus on expressing the algorithm's logic rather than the specific syntax.

Be Consistent

Maintain consistency in your pseudocode by using a uniform style and notation throughout. Choose a convention for variable assignment, function calls, and control structures (such as braces or indentation) and stick to it. Inconsistencies can lead to confusion and may result in lower marks in examinations.

Practice Problem Solving

To improve your pseudocode writing skills, engage in problem-solving exercises that require expressing solutions using pseudocode. Work through algorithmic questions and practice implementing the logic in pseudocode. This practice will enhance your ability to translate real-world problems into pseudocode representations.

Learn from Examples and Resources

Study examples of pseudocode from textbooks, online resources, and tutorial videos. Analyze how experts express complex algorithms in pseudocode and learn from their approach. Additionally, seek out resources specific to your academic curriculum or exam board for standardized pseudocode guidelines.

Remember, Pseudocode Is Not Executable Code

Always keep in mind that pseudocode is a simplified representation and is not meant to be executed as actual code. It is a tool for communicating algorithmic ideas, not a programming language itself. Therefore, don't stress over small syntax details or worry about the code's executability.

References

GitHub Repository

In Linux, there are several commands you can use to examine the contents of text files. Let's take a closer look at these commands, their functionalities, and how they can be used effectively.

You can use the following commands to look at the contents of text files:

• head

• tail

• cat

• less

• echo

• wc

• grep

head

The head command displays the first part of a file. By default, it shows the first 10 lines, but you can specify a different number using the -n flag.

head <filename>

head README.md

If you want to specify a different number -n of lines to show, run the code in the format

head -n <number of lines> <filename>

head -n 6 README.md

tail

The tail command prints the last 10 lines of a file. You can also customize the number of lines to be displayed by using the -n flag. Additionally, the -f flag allows you to continuously monitor changes made to a file, which is useful for log files.

tail <filename>

tail README.md

If you want to specify a different number -n of lines to show, run the code in the format

head -n <number of lines> <filename>

tail -n 5 README.md

cat

The cat command is versatile and can be used for multiple purposes. Primarily, it prints the content of a file to the standard output. It can also be used to concatenate files or create new ones.

Printing the content of a file:

cat <filename>

cat README.md

Concatenating multiple files into a new file:

cat doc.txt contribute.txt > combine.txt

Creating a new file:

cat > newfile.txt

less

The less command provides an interactive and user-friendly way to view file content. It displays file contents in a paginated manner, allowing you to scroll, search, and navigate easily.

less README.md

Useful commands within less:

• b: Scroll up one page

• G: Go to the end of the file

• g: Go to the beginning of the file

• q: Quit the command

echo

The echo command prints the argument passed to it to the output.

echo 'Hello world'

wc

The wc command, short for word count, provides information about a given input, such as the number of lines, words, and bytes in the content.

Options for wc:

-l: Prints the newline count -m: Prints the character count -c: Prints the byte count -w: Prints the word count

For example:

wc -l README.md

grep

The grep command is a powerful text manipulation tool that allows you to filter the content of a file based on a specific pattern. It displays only the lines that match the given pattern.

For instance, if you want to see all lines in a file that include the word "command," you can use grep in combination with cat:

cat README.md | grep command

In this command, the output of cat README.md is piped (|) to grep command for further filtering.

These commands provide a solid foundation for examining and manipulating file content in Linux. With their flexibility and varied functionalities, you can efficiently navigate and process text files according to your needs.

Note: The examples provided here are simplified, and there are many more options and use cases for each command. Further exploration and practice will enhance your understanding and proficiency in working with these commands.

Let me know if you have any questions or need further assistance!

References

• GitHub Repository

• Linux Command Line Cheat Sheet

The Linux command line is a powerful tool for executing tasks and managing your system efficiently. However, to navigate the command line with confidence, it's essential to identify the type of command you're working with. Linux offers several methods to determine the nature of a command, such as the type, which, help, and man commands.

In this comprehensive guide, we'll explore these command identification techniques and delve into the documentation available for each command type. By understanding how to identify commands accurately and access their documentation, you'll gain a deeper understanding of the command line ecosystem and unleash the full potential of Linux command line tools.

Let's dive in and discover how these methods can enhance your command line proficiency.

• type

• which

• help

• man

Command Identification

The type Command

The type command serves as a shell built-in and reveals the nature of a given command to be executed by the shell. Its usage is as follows:

type [command]

The "type" command serves as a shell built-in and reveals the nature of a given command to be executed by the shell. Its usage is as follows:

type [command]

By replacing [command] with the name of the command in question, we can unveil its classification. Let's explore a few examples:

type ls

The output is shown below

ls is aliased to `ls -F --color=auto --show-control-chars'

In the above case, we discover that the "ls" command is an alias with the additional option "--color=auto". This knowledge explains why the output of "ls" is displayed in color.

type cp

The output is shown below

cp is hashed (/usr/bin/cp)

For the cp command, the output reveals that it is an executable program located at usr/bin/cp. Such insights allow us to better understand the behavior and functionality of various commands.

The which Command: In scenarios where multiple versions of an executable program exist on a system, the which command proves invaluable. Its purpose is to determine the precise location of a given executable. Usage is as follows:

which [command]

By replacing [command] with the desired command name, we can ascertain its exact location.

Note: which exclusively works for executable programs and cannot identify built-ins or aliases acting as substitutes.

By utilizing the type and which commands, we can effectively identify the type of command in question and gain insights into its execution within the Linux environment. This knowledge equips us with a deeper understanding of the command line ecosystem.

The help Command

The bash shell incorporates a built-in help facility that provides documentation for each shell built-in. To access it, simply type "help" followed by the name of the shell built-in. Optionally, the "-m" option can be added to modify the output format. Let's consider an example:

help -m cd

Upon executing the above command, the following information about the "cd" command will be displayed:

NAME
    cd - Change the shell working directory.

SYNOPSIS
    cd [-L|[-P [-e]] [-@]] [dir]

DESCRIPTION
    Change the shell working directory.

    Change the current directory to DIR.  The default DIR is the value of the
    HOME shell variable.

    The variable CDPATH defines the search path for the directory containing
    DIR.  Alternative directory names in CDPATH are separated by a colon (:).
    A null directory name is the same as the current directory.  If DIR begins
    with a slash (/), then CDPATH is not used.

    If the directory is not found, and the shell option `cdable_vars' is set,
    the word is assumed to be  a variable name.  If that variable has a value,
    its value is used for DIR.

    Options:
      -L        force symbolic links to be followed: resolve symbolic
                links in DIR after processing instances of `..'
      -P        use the physical directory structure without following
                symbolic links: resolve symbolic links in DIR before
                processing instances of `..'
      -e        if the -P option is supplied, and the current working
                directory cannot be determined successfully, exit with
                a non-zero status
      -@        on systems that support it, present a file with extended
                attributes as a directory containing the file attributes

    The default is to follow symbolic links, as if `-L' were specified.
    `..' is processed by removing the immediately previous pathname component
    back to a slash or the beginning of DIR.

    Exit Status:
    Returns 0 if the directory is changed, and if $PWD is set successfully when
    -P is used; non-zero otherwise.

SEE ALSO
    bash(1)

IMPLEMENTATION
    GNU bash, version 5.1.16(1)-release (x86_64-pc-msys)
    Copyright (C) 2020 Free Software Foundation, Inc.
    License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>

Note: In command syntax descriptions, square brackets denote optional items, while a vertical bar indicates mutually exclusive choices. For instance, the notation for the "cd" command:

cd [-L|-P] [dir]

This indicates that the cd command can be optionally followed by either -L or -P and further optionally by the argument dir.

Command Documentation

The "--help" Option

Many executable programs support a --help option, which provides a detailed description of the command's syntax and supported options. For instance:

mkdir --help

Executing the command above will display the following information about the mkdir command:

Usage: mkdir [OPTION]... DIRECTORY...
Create the DIRECTORY(ies), if they do not already exist.

Mandatory arguments to long options are mandatory for short options too.
  -m, --mode=MODE   set file mode (as in chmod), not a=rwx - umask
  -p, --parents     no error if existing, make parent directories as needed
  -v, --verbose     print a message for each created directory
  -Z                   set SELinux security context of each created directory
                         to the default type
      --context[=CTX]  like -Z, or if CTX is specified then set the SELinux
                         or SMACK security context to CTX
      --help     display this help and exit
      --version  output version information and exit

GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
Full documentation <https://www.gnu.org/software/coreutils/mkdir>
or available locally via: info '(coreutils) mkdir invocation'

Although not all programs support the "--help" option, it is worth attempting as it often provides similar usage information, even if it results in an error message.

The man Command

Most command-line executable programs offer comprehensive documentation known as a manual or man page.

Note that the command from man is by default only available on Unix OS

The "man" command enables us to view these pages conveniently. Usage of the "man" command is as follows:

man program

Replace program with the name of the command to access its manual page. Man pages typically include a title, a synopsis of the command's syntax, a description of its purpose, and a list and explanation of each option. However, they are primarily designed as references rather than tutorials. Let's view the man page for the ls command:

man ls

On most Linux systems, the man command employs the less program to display the manual page, allowing the use of familiar less commands for navigation.

By utilizing the help, --help, and man commands, we can access comprehensive documentation for each command type, enabling us to leverage the full potential of Linux command line tools. These resources facilitate efficient command usage, ensuring optimal productivity within the Linux environment.

Note

On your system, various software packages are installed, each accompanied by documentation files located in the /usr/share/doc directory. These files primarily exist in plain text format, which can be easily accessed and viewed using the less command. However, there are instances where certain files are in HTML format, enabling them to be conveniently viewed using a web browser. It is worth noting that some files in this directory may be compressed with the gzip compression program, denoted by the .gz extension. To handle such compressed text files, the gzip package provides a specialized version of less called zless, which allows the contents of gzip-compressed files to be displayed seamlessly.

View on GitHub

When working with files and directories, there are basic commands that can be used for manipulation. These commands include:

• cp (copy)

• mv (move)

• rm (remove)

• mkdir (make directory)

• rmdir (remove directory)

Before we delve into these commands, let's create a new file. Name it filename.txt and add some random text to it. Make sure you navigate to its directory using your terminal.

cp - Copy

The cp command is used to copy files or directories from one location to another. It creates a duplicate of the specified file or directory, which can be placed in the same directory or a different one. The common format for the cp command is:

cp <file_name> <new_file_name>

For example, in the code below, README.md already exists. We will create contribute.md and copy all the contents from README.md into contribute.md:

cp README.md contribute.md

The cp command can also be used to copy multiple files. Make sure file_name1, file_name2, etc., exist:

cp  <file_name1> <file_name2> ...<new_file_name2>

In the code below, README.md and contribute.md already exist:

cp  README.md contribute.md support.md

If you want to copy all the contents from all the .md files in a directory to a destination file, you can use the wildcard *:

cp *.md <destination_file_name>

For example:

cp *md teams.md

To copy a file to a specific directory, create a new directory or folder in your root directory and run the command in the following format:

cp <file_name> <directory/new_file_name>

For example:

cp README.md folder/contribute.md

Just like the commands above, you can add the -i flag to the cp command. When used, it prompts for confirmation before overwriting an existing file.

To create a new file and put content in it, which is different from an already existing file:

cp -i <file_name1> <file_name2>

For example:

cp -i README.md contribute.md

When you run the above code in your terminal, you will be prompted if you want to overwrite the file (if <file_name2>already exists). You can enter y (or yes) to override the content of <file_name2\> with the content of <file_name1\>. Enter n (or no) or just click the enter button if you do not want to overwrite it.

cp: overwrite 'contribute.md'?

When you need to copy the contents of an existing directory <dir1> to a new directory <dir2>, including all subdirectories and files, you can utilize the cp command with the -R flag. This flag enables recursive copying, ensuring that the entire directory structure is preserved.

Here's how you can accomplish this:

cp -R <dir1> <dir2>

In this command, <dir1> represents the source directory whose contents you want to copy, and <dir2> is the destination directory where you want to create the copied contents.

The -R flag tells the cp command to perform a recursive copy, ensuring that all subdirectories and files within <dir1> are copied to <dir2>. If <dir2> does not exist, it will be created during the copying process.

Note: that the -R flag is crucial when you want to copy directories, as it allows for the copying of both the directory's contents and its subdirectories.

By utilizing the cp command with the -R flag, you can efficiently copy the entire contents of one directory to another, preserving the structure and ensuring that all files and subdirectories are successfully copied.

Suppose you have an existing directory named documentation, and you want to move all of its files and subdirectories to a new directory called reserve. You can achieve this by using the cp command with the -R flag for recursive copying.

cp -R documentation reserve

mv - Move

The mv command not only allows you to move individual files but also provides the flexibility to move multiple files into another directory (folder) simultaneously.

To move multiple files to a destination directory, you can use the following syntax:

mv <file1> <file2> <destination_directory>

In this example, both <file1> and <file2> will be moved to <destination_directory>. The files will no longer exist in their original location and will be consolidated in the specified <destination_directory>.

For instance, consider the command:

mv file1 file2 destination_folder

After executing this command, both file1 and file2 will be moved to the destination_folder. These files will no longer be present in their original location, ensuring a streamlined organization of your files.

The mv command's ability to move multiple files simultaneously simplifies the process of managing and rearranging files within your system.

Note: You can use the wildcard pattern * and the i flag if you wish to:

mv -i *.txt backup

Using the wildcard pattern * in combination with the mv command allows for efficient and streamlined file movements, especially when dealing with large numbers of files.

mv doc/accordion.md documentation

In this case, the file accordion.md located in the doc directory will be moved to the documentation directory. The file will be deleted from the doc directory, and if the documentation directory does not exist, it will be created automatically.

The mv command is a versatile tool for organizing files and directories within your system. It allows you to seamlessly move files between directories, ensuring that your file structure remains well-organized and up-to-date.

rm- Remove

The rm command is used to delete files and directories from your system. It is important to exercise caution when using this command, as deleted files or folders cannot be recovered.

To remove a single file, use the following command:

rm <file_name>

Alternatively, you can use the -i flag to be prompted for confirmation before deleting a file or folder:

rm -i <file_name>

For example, to remove the file "accordion.md" located in the "doc" directory, you can run:

rm -i doc/accordion.md

The prompt will ask the following question:

rm: remove regular file 'doc/accordion.md'?

If you type y (or yes), the file will be deleted.

To delete an entire folder or directory, you need to use the -r flag, which stands for "recursive":

rm -r <dir>

For instance, to delete the "folder1" directory and its contents, you can execute:

rm -r folder1

If you wish to delete multiple folders or directories, you can use either the -r or -rf flag:

rm -r <dir1> <dir2> ...

rm -rf <dir1> <dir2> ...

Note: that the rm -rf command is more aggressive and powerful than rm -r. It bypasses confirmation prompts and forcefully removes directories and their contents. This option should be used with caution to prevent accidental data loss.

Remember to double-check your commands before executing them to ensure you are deleting the intended files or directories.

mkdir - Make Directory

The mkdir command is used to create a new directory.

To create a single directory, use the following command:

mkdir <dir_name>

For example, to create a directory named "folder", you can run:

mkdir folder

You can also create multiple directories at once by specifying their names:

mkdir <dir1> <dir2> ...

For example, to create directories named "folder1", "folder2", and "folder3", you can execute:

mkdir folder1 folder2 folder3

Note: that if a directory with the same name already exists, the mkdir command will generate an error. To avoid this, you can use the -p flag, which stands for "parents" and allows the creation of nested directories. This way, if any intermediate directories are missing, they will be created as well.

mkdir -p <dir_path>

For instance, to create a directory named "nested" inside a directory named "parent" (assuming "parent" doesn't exist yet), you can use:

mkdir -p parent/nested

This will create both the "parent" and "nested" directories.

Remember to choose meaningful and descriptive names for your directories to keep your file system organized and easily navigable.

rmdir - Remove Directory

The command rmdir is the opposite of mkdir. It deletes a folder only when it is empty.

View on GitHub

Installation

Search the terminal on your Operating system, but if you are using Windows, don't use the default Windows terminal. Check out the video on how to install a terminal emulator. For Mac users, you don't need installation, use the default terminal.

Common terminals to use are:

• Cmder

• Git Bash

• Hyper

• iTerm2

Common Commands

• pwd (print working directory)

• cd (change directory)

• ls (list file and directory)

• touch

File system

• In a tree-like pattern of the directory (folder)

• A directory may contain files and subdirectories

• The first directory in the file system is called the root directory

One important difference between Windows and Unix-like OS like Linux is that Linux does not employ the concept of drive letters. While Windows drive letters split the file system into a series of different trees (one for each device), Linux always has a single tree.

pwd

The acronym PWD stands for Present Working Directory. It is commonly used in the context of command-line interfaces and operating systems to refer to the current directory in which a user is working. The pwd command is often used to retrieve and display the full path of the current directory. That is the directory we are standing in is called the working directory. To see the name of the working directory, we use the pwd command.

cd

1. Absolute pathname

2. Relative pathname

Absolute pathname

Example

cd /user/bin

cd /foldername

Relative pathname

The . notation refers to the working directory itself and the .. notation refers to the working directory's parent directory.

cd ..

cd ../foldername

If we type cd followed by nothing, cd will change the working directory to our home directory.

A relative shortcut is to type cd ~user_name.

File names that begin with a period character are hidden. This only means that ls will not list them unless we say ls -la.

• An example is .git.

File names in Linux, like Unix, are case-sensitive. The file names File1 and file 1 refer to different files.

Linux has no concept of a file extension like the Windows system. You may name files any way you like. However, while Linux itself does not care about file extensions, many application programs do.

Though Linux supports long file names which may contain embedded spaces and punctuation, limit the punctuation characters to period, dash and underscore. Use underscores instead of spaces to represent spaces between words in a file name.

ls

ls -l

List the files in the working directory in long format.

ls -l

ls -l /etc /bin

List the files in the /bin directory and the /etc directory in long format.

ls -la ..

ls -la /foldername

List all files (even the ones with names beginning with a period character, which are normally hidden) in the working directory's parent in a long format.

Most commands operate like this:

command -option arguments

A Closer Look at Long Format

For example, try ls -la, you will get more information about the file.

If you run the command ls -l you will get the output that looks like this:

total 4
-rw-r--r-- 1 TechstackMedia - Osagie 197610 3092 May 25 14:28 README.md

Let's break down the output:

1. total 4: This line represents the total number of 1KB blocks used by the files listed below it. In this case, the total size is 4KB.

2. -rw-r--r-- 1 TechstackMedia - Osagie 197610 3092 May 25 14:28 README.md: This line represents the details of a specific file called README.md. Let's analyze each part:

   • -rw-r--r--: This section represents the file permissions. In this example, it indicates that the file is readable and writable by the owner (rw-), readable by the group (r--), and readable by others (r--).

   • 1: The number 1 represents the number of hard links to the file. In this case, there is only one hard link pointing to the file.

   • TechstackMedia: This is the owner of the file. In this case, the file is owned by the user TechstackMedia.

   • -: This hyphen represents the group associated with the file. In this case, the group is not explicitly specified.

   • Osagie: This represents the group associated with the file. In this example, the group is Osagie.

   • 197610: This indicates the file size in bytes. In this case, the file README.md is 3092 bytes.

   • May 25 14:28: This represents the file's last modification date and time.

   • README.md: This is the name of the file.

touch

The touch command is a versatile and powerful tool that allows you to create and modify files with ease in various operating systems, including Linux, macOS, and Unix. Its simplicity and efficiency make it a fundamental command for managing files and timestamps.

One of the primary functions of the touch command is to create a new file. Using the command is as simple as typing touch followed by the desired filename. For example, to create a file called example.txt, you would execute the following command:

touch example.txt

You can also specify the timestamp. In the example below a file named custom.txt with a specific timestamp of December 31, 2022, at 12:30 PM, you would execute the following command:

touch -t 202312311230 custom.txt

In the touch command, the timestamp for the -t option follows a specific format: [[CC]YY]MMDDhhmm[.ss].

Here's a breakdown of each component:

• CC: Represents the first two digits of the year (century).

• YY: Represents the last two digits of the year.

• MM: Represents the month (01-12).

• DD: Represents the day of the month (01-31).

• hh: Represents the hour in 24-hour format (00-23).

• mm: Represents the minute (00-59).

• .ss: (Optional) Represents the second (00-61).

In your example, the timestamp 202312311230 corresponds to the following components:

• CC: Not specified, assuming it is the current century.

• YY: 22 (indicating the year 2023).

• MM: 12 (indicating December).

• DD: 31 (indicating the 31st day of the month).

• hh: 12 (indicating 12 PM).

• mm: 30 (indicating 30 minutes).

This command will set the modification and access times of the custom.txt file to the specified timestamp, allowing you to manually define the file's timestamp.

less

less is a program that lets us view text files. This is very handy since many of the files used to control and configure Linux are human-readable.

Click q to quit or keep clicking enter till you are done reading the file.

less text_file

less README.md

References

GitHub Repository

A symbol represents a unique identifier

To create a symbol, the syntax is shown below:

id = Symbol()

To create a symbol with a description (symbol-name), the syntax is shown below:

id = Symbol("description")

The description is just a label that is unique to an object.

It is important to note that symbols with the same description are still different.

See the example below:

const id1 = Symbol("description");
const id2 = Symbol("description");

console.log(id1 === id2); // false

It is also important to note that symbols do not allow auto-conversion (coercion) to string.

See the example below:

const id3 = Symbol("description");
alert(id3); // TypeError...

To do the conversion, use the toString() function on it.

See the example below:

const id4 = Symbol("id");
alert(typeof id4.toString); // string

Alternatively, we can use the id.description to show the description only.

let id5 = Symbol("id");
alert(id5.description, toString id5.description); // id string

Hidden Properties

Symbols allow us to create hidden properties of an object. See the example below:

const person = { // belongs to another code
  name: "Bello"
};

let id = Symbol("id");

person[id] = 4; // added id key to user object

alert( person[id] ); // 4 => accessed data by the symbol as the key

The code above shows that a symbol cannot be accessed accidentally by any part of your code.

If a string is used in place of a symbol, the last string "id" will be overridden (overwritten) by any other previous string id from our script or another JavaScript library script.

See the example below:

const person = { name: "John" };

// my script uses "id" property
person.id = "id value before the last script";

// library script uses the "id" property
person.id = "id value in last script" // overwritten by another script!
console.log(person.id); // id value in last script

Symbol id as key

To use a symbol as a key in an object literal, the square bracket must be used around it.

const id = Symbol("id");

const user = {
  name: "John",
  [id]: 639 // not "id": 639
};

Cloning symbol keys

The for...in skips any symbol key in an object. See the example below:

const id = Symbol("id");
const user = {
  name: "Bello",
  age: 27,
  [id]: 396
};

for (let key in user) {
  console.log(key); // name, age => no symbols
}
// Object.keys(user) also skips them.

The Object.assign copies both string and symbol properties.

See the example below:

const id = Symbol("id");
const user = {
  name: "Bello",
  age: 27,
  [id]: 396
};

let clone = Object.assign({}, user);
alert( clone[id] ); // 396

Global Symbol Registry

Symbols are always different by default even if they have the same description, but sometimes we want to use the same-named symbol of the same entities anyway in a program.

To achieve that, the Symbol.for(key) is used to create a global symbol registry for repeated access by the same name to return exactly the same symbol.

See the example below:

const id1 = Symbol.for("id"); // if the symbol did not exist, it is created
const id2 = Symbol.for("id");

console.log( id1 === id2); // true => the same symbol

Symbols inside the registry are called global symbols.

Symbol.keyFor

The reverse of Symbol.for is Symbol.keyFor, it returns a name by a global symbol.

See the example below:

// get symbol by name
const sym1 = Symbol.for("id1");
const sym2 = Symbol.for("id2");

// get name by symbol
console.log( Symbol.keyFor(sym1) ); // id1
console.log( Symbol.keyFor(sym2) ); // id2

The Symbol.keyFor internally uses the global symbol registry to look up the key for the symbol. If the symbol is not global, it returns undefined

See the example below:

const globalSymbol = Symbol.for("globalName");
const localSymbol = Symbol("localName");

console.log( Symbol.keyFor(globalSymbol) ); // globalName => global symbol
console.log( Symbol.keyFor(localSymbol) ); // undefined => not global

console.log( localSymbol.description ); // localName

System Symbols

Internally, there are different JavaScript System Symbols. Below is a few of them.

• Symbol.hasInstance
• Symbol.isConcatSpreadable
• Symbol.iterator
• Symbol.toPrimitive

Check out the full list on MDN