DEV Community: Mennatallah Ashraf

How to Use Git: A Simple Tutorial for Beginners

Mennatallah Ashraf — Thu, 18 Jul 2024 18:02:57 +0000

Why should every software engineer learn Git?

Every software engineer should learn Git because it is essential for modern software development. Git tracks and manages code changes, allows multiple developers to collaborate without conflicts, and serves as a backup for the code.

For open-source contributions, Git is essential as many projects use it for version control. Proficiency in Git is often required for software engineering jobs, making it important for career growth.

Setting up Git

Before learning how to use Git, you should make sure that you have Git on your machine. To verify that you have Git installed, type the following command at your command line:

git --version

If this command returns the version of Git on your machine, it means you have Git installed.

However, if nothing is returned or you get an output like "git is not recognized", that means you have to install Git on your system. Don't worry, installing Git is easy, and I will show you how to do it whether you are using Linux, Windows, or Mac.

Git Installation

On Linux

Installing Git in Linux is easy all you have to do is to run the following commands.

If you are using a Debian-based distribution like Ubuntu, First, update your local package index:

sudo apt update

then type this command to install Git:

sudo apt install git

But if you’re on Red Hat-based Distributions (e.g., Red Hat Enterprise Linux, CentOS, Fedora), you can use yum:

sudo yum install git

Or you can use dnf:

sudo dnf install git

On Windows

First, navigate to the latest Git for Windows installer and download the most recent version.

Once the installer starts, follow the instructions provided in the Git Setup wizard until the installation is complete.

On Mac

You can follow the instructions provided in this link to install Git on Mac.

Whether you are using Linux, Windows, or Mac, once you've finished installing Git, run git --version to verify that Git is installed.

Configuring Git

Configuring Git is important because it ensures that your commits and interactions with the repository are properly attributed to you and managed according to your preferences.

Setting up username

To set up your username, type this command:

 git config --global user.name "your-name"

Make sure to replace "your-name" with your own username.

Setting up email

Then, set up your email using this command:

git config --global user.email "your-email@example.com"

Make sure to replace "your-email@example.com" with your actual email address.

Initializing a Git repository

To initialize a Git repository, first navigate to the directory where you want to create your repository using this command:

cd /path/to/your/project

Then, you can initialize a repository in this directory by running:

git init

This command creates a new subdirectory named .git in your project directory, which contains all the necessary metadata for the repository.

Congrats, you have initialized your first Git repository! 🥳

Basic Git Commands

After you have initialized your Git repository, you need to know the essential Git commands to manage it, and they are:

git status

The git status command checks what files Git will add to your new repository.

git add .

The command git add . stages all the changes in the current directory and its subdirectories for the next commit.

If you want to stage specific file you can use the following command instead:

git add path/to/your/file/example1.txt

Next you will need to commit the files you have just staged and you can do that by running:

git commit -m "write the commit comment here"

Then if you need to see the history of all the files you have committed use the following command:

git log

It will display all your commits with the author and hash.

But if you prefer to show each commit in a single line per commit, add the --oneline option as follows:

git log --oneline

That is it with basic Git commands. Next, we will learn about branches and how to manage them.

Branching and Merging

Understanding branches in Git

In Git, branches are basically references to a certain commit. They are used to develop features, fix bugs, or experiment in isolation from the main codebase.

Git creates a branch named main (or master in older versions) by default. This is the main line of development.

Creating a new branch and switching branches

If you want to create a new branch but stay on the current branch, use:

git branch branch_name

To create a new branch and switch to it:

git checkout -b branch_name

You may easily return to the previous branch by using:

git checkout -

Renaming a branch

To rename the current branch, use:

git branch -m new_branch_name

If you want to rename another branch:

git branch -m branch_you_want_to_rename new_branch_name

Merging branches

If you want to merge the changes you made from a branch called new_branch to the current branch:

git merge new_branch

After initiating a merging, you may want to pause it and restore everything to its pre-merge condition. Use --abort:

git merge --abort

Deleting branches

To delete a branch locally:

git branch -d branch_name

⚠
Be aware that the previous command will fail (produce an error) if the branch branch_name has unmerged changes that would be lost.

In that case, if you really want to delete that branch and don't care about losing the changes that have not been merged, you can force delete the branch (and lose any unmerged changes in that branch) by using the -D flag:

git branch -D branch_name

Conclusion

Learning Git is a must for every software engineer. It helps you track code changes, collaborate smoothly with others, and is often a job requirement. With this guide, you now know how to set up Git, use basic commands, and manage branches.

Get comfortable with Git, and you'll see your development skills and career opportunities grow. Happy learning! 😊

Top 15 Linux Commands Every Beginner Should Know

Mennatallah Ashraf — Mon, 01 Jul 2024 18:16:48 +0000

Why is it important to learn Linux commands?

Learning Linux commands is essential for anyone who wants to use the terminal effectively. If you are a beginner interested in fields where Linux is important, this article is perfect for you. Mastering these commands will make you more efficient and give you a deeper understanding of how your system works. So, let's dive in and explore the fundamental Linux commands that every aspiring professional should know!

In this article, we will learn about:

Basic Commands

* pwd

* ls

* cd

* mkdir

* rmdir

File Operations

* touch

* cp

* mv

* rm

* cat

* nano

Permissions and Ownership

* chmod

* chown

Searching and Finding Files

* find

* grep

Basic Commands

`pwd` - Print Working Directory

Syntax:

pwd [options]

This command id used to print the current working directory.

Examples:

Basic usage:

pwd

This will print the current working directory.

Using the-L option:

pwd -L

This will print the logical current working directory, showing the path as it appears logically, including any symbolic links.

`ls` - List Directory Contents

Syntax:

ls [options] [directory]

ls command is used to display the contents of the current directory.

Example:

ls -l /

The command ls -l / in Linux lists the contents of the root directory / in long format.

-l: An option to list the contents in long format, providing detailed information about each file and directory.
/: The root directory of the filesystem.

`cd` - Change Directory

Syntax:

cd [options] [directory]

cd command allows you to change your current working directory.

Example:

cd -P /home/user/Documents

This command will take you to /mnt/storage/Documents, the physical location to which /home/user/Documents points. The output of pwd (print working directory) will show /mnt/storage/Documents instead of /home/user/Documents.

-P: will change the directory to the actual location that /home/user/Documents points to.
/home/user/Documents: This is the target directory to which you want to change.

`mkdir` - Make Directory

Syntax:

mkdir [options] directory

mkdir is used to create a directory if not already exist.

Examples:

mkdir dir1

The previous example creates a new directory named dir1 in the current working directory. If a directory named dir1 already exists in the current location, you will get an error message indicating that the directory already exists.

mkdir dir1 dir2 dir3

This creates multiple directories named dir1 , dir2 and dir3 in the current working directory.

`rmdir` - Remove Directory

Syntax:

rmdir [options] directory

The rmdir command in Unix/Linux is used to remove empty directories.

Example:

rmdir -v dir1

-v: This is an option that stands for "verbose". In this case, it will print a message for each directory that is successfully removed.
dir1: This is the name of the directory you want to remove. The directory must be empty for rmdir to succeed.

But what if I want to remove a non-empty directory?🤔

In the following section, we will learn how to do that using the rm command.

File Operations

`touch` - Create an Empty File

Syntax:

touch [options] filename

touch command is used to create empty files. You can update the modification and access time of each file with the help of the touch command.

Example:

touch test.txt

This example is used to create a new file named test.txt or update the timestamp of an existing file.

`cp` - Copy Files or Directories

Syntax:

cp [options] [source] [destination]

You use the cp command in Linux to copy files and directories from one location to another.

Example:

cp file1.txt file2.txt file3.txt testdir

This command copies multiple files (file1.txt, file2.txt, file3.txt) into the directory testdir.

`mv` - Move or Rename Files and Directories

The mv command can be used for various purposes, such as:

mv [options] [sourceFile] [destinationFile]

We use this syntax if we want to rename a file.

mv [options] [sourceDir] [destinationDir]

This syntax is used when renaming/moving a directory.

mv [options] [filename] [destinationDir]

If we want to move a file we use this syntax.

Examples:

mv file1 file2

The previous example changes the name of the file file1 to be file2 .

mv dir1 dir2

This example renames the directory dir1 to be dir2 .

mv dir1 /path/to/new/location/

Here we are changing the location of dir1 to /path/to/new/location/ .

mv file.txt /path/to/new/location/

This example moves the file file.txt to /path/to/new/location/ .

`rm` - Remove Files or Directories

Syntax:

rm [options] filename/directory

The rm command deletes files and directories.

Example:

rm file.txt

This command removes the file file.txt .

rm -r dir1

Another useful use of the rm command is that it can remove non-empty directories. As shown in the example, it removes the directory dir1 when we use the -r option with it.

`cat` - Concatenate and Display Files

Syntax:

cat [options] [filename]

The cat (concatenate) command in Linux displays file contents. It reads one or multiple files and prints their content to the terminal. cat is used to view file contents, combine files, and create new files.

Example:

cat -n filename

This command displays the contents of filename with line numbers.

-n: Option to number all output lines, starting from 1.

`nano` - Edit File with Nano Text Editor

Syntax:

nano [options] filename

Nano is a simple, easy-to-use text editor available in many Unix-based operating systems, including Linux.

Example:

nano file1

This example opens the Nano text editor with file1 loaded for editing. After modifying file1, if you want to save the changes, press Ctrl + O. To exit Nano, press Ctrl + X.

Permissions and Ownership

`chmod` - Change File Mode

Syntax:

chmod [options] [mode] [filename]

The chmod command is used to change the permissions of files and directories.

Example:

chmod u+x myfile

u+x: This specifies the permission change:
- u: Refers to the user (owner) of the file.
- +: Indicates that you are adding a permission.
- x: Represents the execute permission.

After executing this command, the owner of myfile will be able to execute it as a program or script.

`chown` - Change File Owner and Group

Syntax:

chown [options] [owner][:group] filename(s)

We use chown command to change the owner and group of a file or directory.

Example:

chown -R user:group mydirectory

-R: This option stands for "recursive." It means that the command will apply the ownership change not only to the specified directory (mydirectory) but also to all files and subdirectories within it.
user:group: This specifies the new owner and group for the directory and its contents.
- user: This is the new owner of the files and directories.
- group: Refers to the new group of the files and directories.

This example changes the owner of mydirectory and all files and subdirectories within mydirectory to user and the group to group.

Searching and Finding Files

`find` - Search for Files in a Directory

Syntax:

find [path] [options] [expression]

The find command helps you locate files, and not just by their names.

Example:

find / -name '*test*'

In this example find searches for files and directories containing the word "test" anywhere in their names, starting from the root directory (/).

/: The directory to start the search from (root directory).
-name: Option to specify the name pattern to search for.
'*test*': The pattern to match. The asterisks (*) are wildcards that match any number of characters before and after "test".

`grep` - Search Inside Files

Syntax:

grep [options] pattern [files]

The grep command in Linux is used to search for patterns within files.

Example:

grep "test" file.txt

Here we search for the string "test" within the file file.txt.

Conclusion

Learning these top 15 Linux commands is a great start for any beginner. They help you move around the system, manage files, and check what's going on with your computer. Getting comfortable with these basics will make using Linux a lot easier and more fun.

Remember, this is just the beginning. There are many more commands and tools to discover. Keep exploring, and don't be afraid to try new things. The Linux community is always there to help with plenty of tutorials and guides.

Happy learning, and enjoy your Linux journey!

DEV Community: Mennatallah Ashraf

How to Use Git: A Simple Tutorial for Beginners

Why should every software engineer learn Git?

Setting up Git

Git Installation

On Linux

On Windows

On Mac

Configuring Git

Setting up username

Setting up email

Initializing a Git repository

Basic Git Commands

Branching and Merging

Understanding branches in Git

Creating a new branch and switching branches

Renaming a branch

Merging branches

Deleting branches

Conclusion

Top 15 Linux Commands Every Beginner Should Know

Why is it important to learn Linux commands?

In this article, we will learn about:

Basic Commands

pwd - Print Working Directory

ls - List Directory Contents

cd - Change Directory

mkdir - Make Directory

rmdir - Remove Directory

File Operations

touch - Create an Empty File

cp - Copy Files or Directories

mv - Move or Rename Files and Directories

rm - Remove Files or Directories

cat - Concatenate and Display Files

nano - Edit File with Nano Text Editor

Permissions and Ownership

chmod - Change File Mode

chown - Change File Owner and Group

Searching and Finding Files

find - Search for Files in a Directory

grep - Search Inside Files

Conclusion

`pwd` - Print Working Directory

`ls` - List Directory Contents

`cd` - Change Directory

`mkdir` - Make Directory

`rmdir` - Remove Directory

`touch` - Create an Empty File

`cp` - Copy Files or Directories

`mv` - Move or Rename Files and Directories

`rm` - Remove Files or Directories

`cat` - Concatenate and Display Files

`nano` - Edit File with Nano Text Editor

`chmod` - Change File Mode

`chown` - Change File Owner and Group

`find` - Search for Files in a Directory

`grep` - Search Inside Files