DEV Community: Arth Vhanesa

How to Remove Secrets From a Git Repository

Arth Vhanesa — Mon, 21 Aug 2023 04:34:30 +0000

As developers, we often work with sensitive information such as API keys, passwords, and other secrets. It’s essential to keep this information secure and out of the hands of unauthorized users.

However, accidents can happen, and sometimes we forgot to add a file containing secrets to the .gitignore and it is accidentally pushed to a Git repository. Even if the secrets are later removed from the repository, they can still be accessed through the commit history which is a potential breach of security.

It’s important to take steps to remove secrets from a Git repository as soon as possible after they are accidentally pushed to ensure your secret information remains safe without affecting other files and commits.

Remove secrets using the `filter-branch` command

If you’ve accidentally pushed secrets to a Git repository, don’t worry – there are several ways to remove them entirely from the repository. One way is to use the filter-branch command, which is a built-in Git command that allows you to rewrite the commit history of a repository.

Step 1: Use the `filter-branch` command

Use the filter-branch command to remove a file from the commit history of a repository:

git filter-branch --force --index-filter \
  "git rm --cached --ignore-unmatch <PATH-TO-YOUR-FILE-WITH-SENSITIVE-DATA>" \
  --prune-empty --tag-name-filter cat -- --all

Run this command to rewrite the commit history of the repository, removing any references to the given file. It’s important to note that this command can be destructive, so make sure you understand what it does before using it.

git filter-branch: Used to rewrite the Git revision history.
--force: Overrides some safety checks.
--index-filter: Specifies a filter that modifies the index, or staging area, of each commit. In this case, the filter is "git rm --cached --ignore-unmatch <PATH-TO-YOUR-FILE-WITH-SENSITIVE-DATA>".
"git rm --cached --ignore-unmatch <PATH-TO-YOUR-FILE-WITH-SENSITIVE-DATA>": Removes the specified file from the index, but not from the working tree. The --ignore-unmatch option prevents the command from failing if the file is not present in a particular commit.
--prune-empty: Removes any empty commits that may be created as a result of removing the file.
--tag-name-filter cat: Specifies how to handle tags. In this case, it specifies that tags should be rewritten to point to the same commit as before.
-- --all: Specifies that all branches and tags should be rewritten.

In addition to the filter-branch command, there are other tools you can use to remove secrets from a Git repository, such as BFG Repo-Cleaner and git-filter-repo. You can read more about these tools in the GitHub documentation.

Step 2: Add secrets into `.gitignore`

After filtering your repository, don't forget to add the files which you've removed using filter-branch containing the secret into your .gitignore file to prevent it from accidentally push to the repository.

Step 3: Push your local changes to a remote repository

Once you are happy with the state of your repository, force-push your local changes to overwrite your remote repository, as well as all the branches you've pushed up:

git push origin --force

Step 4: Push against your Git tags

In order to remove the sensitive file from your tagged releases, you'll also need to force-push against your Git tags:

git push origin --force --tags

Conclusion

In conclusion, accidentally pushing secrets to a Git repository can be a security risk, but there are several ways to remove them entirely from the repository. Using the filter-branch command or other tools such as BFG Repo-Cleaner and git-filter-repo, you can rewrite the commit history of the repository and remove any references to the secrets.

Basics of PHP Variable Scope Explained

Arth Vhanesa — Fri, 18 Aug 2023 02:38:48 +0000

Introduction

Variables are containers that store data values used in computer programs. The scope of a variable defines its visibility and accessibility throughout the program. Understanding PHP variable scope is crucial for efficient programming. Without a proper scope, you may encounter errors that will cost you valuable coding time. So, let's dive into the basics of PHP variable scope and get you up and running in no time!

Types of variable scope

Local Variables

Local variables are variables defined within a function or a block of code. These variables have a limited scope and can only be accessed within the function or block they are declared in. The scope of local variables does not extend beyond the function or block of code in which they are defined.

Examples of local variables include parameters passed to a function and variables declared within loops or conditionals. Understanding the scope of local variables is important for maintaining code cleanliness and avoiding naming conflicts.

function calculateSum($a, $b) {
    $result = $a + $b; // $result is a local variable
    return $result;
}

// Calling the function
$sum = calculateSum(5, 3);
echo "Sum: " . $sum; // Output: Sum: 8

echo $result; // ERROR: Because $result is not accessible here in Global scope

Global Variables

Global Variables are accessible from anywhere in the PHP script. Their scope is not limited to the function where they were declared. Accessing global variables involves using the 'global' keyword before the variable's name.

However, it is essential to understand that relying too much on global variables can result in hard-to-debug code. Be careful not to overwrite global variables accidentally as you can access and modify it from anywhere in the global scope.

$globalVar = 10; // This is a global variable

function accessGlobal() {
    global $globalVar; // Using the 'global' keyword to access the global variable
    echo "Global variable inside function: " . $globalVar; // Output: Global variable inside function: 10
}

accessGlobal();
echo "Global variable outside function: " . $globalVar; // Output: Global variable outside function: 10

References with Global Variables

$language = "PHP"; // global variable

function change_language(&$lang) {
  $lang = "JavaScript";
}

echo "Initial language: " . $language . "<br>"; // Output: Initial language: PHP

change_language($language);

echo "Updated language: " . $language . "<br>"; // Output: Updated language: JavaScript

In this example, we have a global variable $language initially set to "PHP". The function change_language() accepts a reference to a variable, and within the function, it updates the value of the referenced variable to "JavaScript".

As a result, even though the variable is declared outside the function, the change made by reference inside the function affects the global variable's value. When you run this code, you'll observe the transformation of the global variable's value from "PHP" to "JavaScript".

Static Variables

Static variables are those that retain their values even after the execution of a function. The scope of static variables is within the function in which they are defined. Therefore, static variables can only be accessed within that specific function. To define a static variable, the keyword 'static' is used before the variable declaration.

A good example is a counter that needs to keep track of the number of times a particular function gets called. Static variables make this possible. Static variables have a unique property that makes them quite handy in programming.

function incrementCounter() {
    static $counter = 0; // Declaring a static variable
    $counter++;
    echo "Counter: " . $counter . "<br>";
}

incrementCounter(); // Output: Counter: 1
incrementCounter(); // Output: Counter: 2
incrementCounter(); // Output: Counter: 3

References with Static Variables

function track_calls() {
  static $call_count = 0; // static variable
  $num =& $call_count; // create a reference to $call_count
  $num++;
  echo "Function has been called " . $call_count . " times.<br>";
}

track_calls(); // Output: Function has been called 1 times.
track_calls(); // Output: Function has been called 2 times.
track_calls(); // Output: Function has been called 3 times.

In this example, the track_calls() function keeps track of the number of times it has been invoked using a static variable $call_count. By creating a reference $num to the static variable, each time the function is called, the value $call_count is incremented.

The use of references ensures that the same static variable is manipulated across different calls to the function, allowing you to maintain and display a cumulative call count. When you run this code, you'll see the call count increment with each function invocation.

SuperGlobal Variables

SuperGlobal variables in PHP are predefined variables that are always available in all scopes throughout a PHP script. These variables are accessible from any function, class, or file without requiring any additional code to make them available. Some commonly used SuperGlobal variables in PHP include $_SERVER, $_GET, $_POST, $_SESSION, and $_COOKIE.

For instance, the $_SERVER variable contains information such as headers, paths, and script locations that can be useful in debugging or tracking user activity, while the $_GET variable allows data to be passed through the URL. It is essential to be cautious while using SuperGlobal variables as they can be modified from external requests, leading to security vulnerabilities.

// Using the $_GET superglobal variable to get data from the URL query string
$name = $_GET['name'];

// If URL is like: http://example.com/?name=John
echo "Hello, " . $name; // Output: Hello, John

Conclusion

PHP variable scope describes the region where a PHP variable may and may not be accessed by your PHP code. PHP distinguishes between local, global, and static scope. Each scope has its own set of rules on how variables can be accessed, which enhances code efficiency and readability. By mastering PHP variable scope, you'll be able to write more efficient and effective PHP code with fewer bugs and errors.

Bhoomi — The Future of Secure Property Transfers

Arth Vhanesa — Thu, 17 Aug 2023 11:29:15 +0000

Aim: Land Registry using Self-Sovereign Identity to store, protect, and publish land records and ease the transfer of land ownership.

Link: bhoomi.site

Brief about the problem

Land registration has become a tedious and troublesome process with the increasing population. Ongoing system results in an increased number of frauds, loss of paperwork, and legal cases. Major challenges in this sector include an increase in land-related litigations, reselling of the same land, and the absence of a unique record. We can reduce the chances of fraud in land registration with the SSI model and blockchain technology.

The user will have the freedom to manage his property once the government mines the first block. Users can buy or sell the property and transfer ownership without government interference. The user will be provided with an automated Government-authorized digital certificate. With the successful implementation of this software solution, performing a secure real estate transaction and verifying ownership can be achieved.

Approach to solving this problem

We aim to build a single platform for buying and selling property using blockchain technology which ensures the security of transactions.

This blockchain-based model will build trust and ensure the security of transactions so incidents such as reselling of the same property, documents tempering, etc. cannot take place

The process includes building a smart contract. We have written it in such a way that the owner must transfer his full asset to the buyer. No partial transaction of the asset is allowed.

Once the government authority registers the user, the entire process becomes transparent and the transaction happens between the two clients with a few amount of government intervention.

Thus, we are making a distributed system for land registration using blockchain to store all the transactions of land buying.

Flowchart

Technology Stack

Outcome

Citizens can verify the authorization and ownership details of the land.
The user can find the complete history of the property before purchasing the property.
There would be no need for attested copies of documents.
Frauds related to the land registry will not be there.
The government does not need to validate and authorize digital credentials issued by government agencies explicitly.

Features and Benefits

LiveChat: Integrated for customer support.
Geo-Mapping: To get the land view on the map.
Immutability: Recorded data can’t be erased and replaced.
Transparency: It is a decentralized network that uses a digital ledger, hence all transaction records are public.
Security: It uses the hashing technique to store each transaction.
Traceability: It creates an irreversible audit trail allowing easy tracing of changes on the network.

PS:

This project is developed to provide a solution in response to a problem statement presented by the Revenue Department of India in the SSIP (Aazadi Ka Amrit Mahotsav) Hackathon 2022.
The whole credit goes to Team Abhyuday for making the innovative, cost-effective and secure solution. Kudos to us guys🍾!
Team Abhyuday: Vaibhav Chauhan, Arth Vhanesa, Kinjal Shah, Priyal Thummar, Yug Khokhar, Jaimin Chokhawala, Heet Senghani, 3rd-year IT undergraduates from L. D. College of Engineering, Ahmedabad.
Best wishes from Team Abhyuday.✨

Vim Editor in Linux: Mastering the Basics

Arth Vhanesa — Tue, 09 May 2023 13:12:09 +0000

Introduction

As a programmer or a developer, we require an efficient, versatile, and fast text editor. Linux has a built-in Vi text editor. Vim is an improved version of Vi, whereas Vim stands for Vi Improved. Vim is a highly efficient and powerful text editor that is widely used by programmers, and system administrators. In this article, we will explore the different modes of Vim and basic commands for editing.

Vim may or may not be pre-installed depending on the Linux distro. You can download Vim by running this command in the terminal:

sudo apt install vim

Advantages of using CLI text editor

One of the primary advantages of using a CLI editor like Vim is the speed and efficiency. It is better and faster to use Vim rather than just using file explorer to navigate and edit files. Vim supports multiple file formats which makes it more useful and it is faster to create and edit files at the same time. Vim is majorly used when working with remote servers where GUI is not available.

Modes in Vim Editor

We use command vim followed by the name of the file to open or create a file. Like, if we want to edit/create a file named "example.txt", use the command vim example.txt.

You familiarize yourself with the three modes it operates in. These modes are:

Normal mode
Insert mode
Command Mode

1. Normal Mode

This is a default mode in Vim Editor which enables you to navigate through the text and execute various functions using keyboard commands. Some of the essential commands in normal mode include:

h, j, k, l: Allow you to move the cursor left, down, up, and right, respectively.

$: Jump to the end of the line without switching to insert mode

A: Jump to the end of the line and switch to insert mode

0: Jump to the beginning of the line

r: Replace the character. Move the cursor on the character you want to replace and press r and then enter the character you want to replace with

x: Delete the character. Move the cursor on the character you want to delete and press x.

u: Undo the last change

dd: Delete the entire line

d[total number of lines]d: Use for deleting multiple lines. For example, if you want to delete 10 lines after your cursor then press d10d.

[line number]G: Jump to a specific line number. To jump to line 12, we use the command 12G.

2. Insert Mode

In insert mode, you can add text to the file. Press the i key while in normal mode to switch to insert mode. Once you enter the insert mode, you can type in the text you want to add.

Insert mode commands:

i: Switch to insert mode

I: Moves the cursor to the beginning of the line and switch to insert mode

3. Command mode

We use command mode for various functionality like searching, replacing and saving the files using different commands. Press : to enter into command mode.

Command mode commands:

:set number: This command displays line numbers in the file.

:/example: This command searches for the word "example" in the file.

After searching into files you can press:
n for jumping to the next match
N for jumping to the previous match

:%s/old/new/g: This command replaces all occurrences of "old" with "new" in the entire file.

:w filename: This command saves the modifications made to the file with the name "filename".

:wq: This command saves the file and exits the Vim editor.

:q!: This command quits the Vim editor without saving the modifications made to the file.

Conclusion

In conclusion, Vim Editor is a powerful and versatile text editing tool that offers a wide range of functionalities. Whether you are a programmer, developer, or system administrator, Vim Editor caters to your text editing needs. By mastering Vim Editor's basic and advanced commands, you can improve your productivity and efficiency.

I hope that this comprehensive guide has been helpful in your quest to effectively utilize Vim Editor.

Package Managers in Linux: The Basics Explained

Arth Vhanesa — Fri, 05 May 2023 03:58:00 +0000

Introduction

Software installation is a crucial aspect of any operating system, and it can differ significantly between different operating systems. In Windows, We install software by downloading installers or installing executable files. On the other hand, Linux manages software differently. It packages software into binaries and libraries. As Linux supports shared dependencies, it's not recommended to download software that has self-contained dependencies. We will see how package managers work and handle dependencies and the advantages of using them for software installation in Linux.

What is a Software package?

The software package is the bundle of all required files and dependencies and other resources which are required to run the software. For running software smoothly users must have to install all required dependencies. Using the software package, all dependencies are bundled with the application so that users can simply install the package and all files and dependencies will automatically install. This eliminates the need for users to manually search for and install dependencies, which can be time-consuming.

Why do we need a Package Manager?

The package manager helps to manage the all dependencies of the software which splits across different files and folders. It ensures that the integrity and authenticity of software is maintained. Moreover, package managers can manage and resolve all required dependencies automatically. This means that it takes the hassle out of manually searching for and installing all necessary dependencies. In addition, package managers know where to put binaries and library files in the Linux File System. As a result, it helps to prevent conflicts and confusion over where certain files should be stored.

APT Package Manager in Linux

A package manager is already installed in every Linux distribution. In Ubuntu, we have an Advanced Packaging Tool – APT as a package manager. To download software from the repository, we use the apt command, which is usually listed in the software's guide or documentation. We can run the command sudo apt install default-jdk to install Java, which automatically downloads the required files and sets up the system.

The links to the repositories are stored in /etc/apt/sources.list, and when we run an apt command, Linux finds the appropriate repository link from this list and downloads the software from there. As we need sudo access to run the apt command, this helps ensure the security of the system. Overall, APT makes it easy to download and install software in Linux while maintaining the security of the system.

APT vs APT-GET

APT and APT-GET are both package managers available on Linux distributions such as Ubuntu. APT is newer, more user-friendly, and recommended by Linux distros. APT has more organized commands than APT-GET and also provides detailed information about packages, which makes it easier to manage. APT is faster and more robust in handling errors and conflicts between packages, making it a better choice for most users. Although APT-GET is still widely used, APT is a great choice for those new to Linux or looking for a more efficient and streamlined way to manage their system's packages.

Alternative Ways to Install Software

In Linux, downloading software using the package manager is the most common and preferred method. There are alternative ways to download software too. Here are the popular 3 methods for downloading software on Linux.

1. Snap package manager

Snap package manager is a popular package manager available in Linux. It allows users to download software in a bundle that contains all the necessary dependencies. The software downloaded using Snap does not share the dependencies. In such cases, the dependencies download more than once, which makes the installation size large. Snap automatically updates the software packages which makes it convenient.

2. Ubuntu software center

Ubuntu software center is Graphical User Interface (GUI) application to download and install software packages with ease. The software center uses Snap in the background, which downloads self-contained dependencies as Snap packages. It simplifies the installation process and takes care of all the necessary. In short, the Ubuntu software center is providing an intuitive user interface to browse and install software from an extensive collection of packages.

3. Add the repo to the official list of repository

When the repo is not officially available in the Ubuntu repos list or on the Ubuntu software center, we can add the repo to the list. The add-apt-repository command is used to add a repository to the list of repositories in /etc/apt/sources.list and it will be used by apt install <package-name> command for installing it.

Personal Package Archives (PPAs) are software packages that are built and maintained by individuals in the community. Anybody can distribute the software using PPAs. Usually, developers use PPAs to provide updates more quickly than official Ubuntu repositories. It is important to be aware that PPAs do not go through the same screening process as the official Ubuntu repository, which means that there is no guarantee of security or quality.

Conclusion

Using package manager we can easily install, upgrade, and remove software packages. Additionally, package managers ensure compatibility of the software with the operating system. In conclusion, the package manager is a crucial component of Linux that simplifies the software installation and management process with the stability and security of the system.

5 Reasons Why Command Line Interface (CLI) is More Efficient Than GUI

Arth Vhanesa — Sat, 29 Apr 2023 02:43:13 +0000

As a computer user, you have probably heard about Command Line Interface (CLI) and Graphical User Interface (GUI). CLI is a method of interacting with a computer system through text-based commands, while GUI provides a visual interface with icons, menus, and windows. While GUI is more commonly used among computer users, CLI offers several advantages that make it a more efficient option. In this article, we'll explore the differences between CLI and GUI and dive into five key reasons why you might want to consider using CLI over GUI.

What is Command Line Interface (CLI)?

Command Line Interface (CLI) is a text-based interface that allows users to interact with a computer system using commands. It is a way of interacting with a computer system that predates the development of a Graphical User Interface (GUI). With CLI, users enter a command into a text prompt, and the system responds accordingly. CLI is an efficient way to interact with a computer system, especially for experienced users who prefer to work with a keyboard.

The difference between CLI and GUI

GUI is a visual interface that allows users to interact with a computer system using graphical elements such as icons, buttons, and windows. GUI is more user-friendly than CLI and is the most commonly used interface among computer users. However, GUI has its limitations, especially when it comes to efficiency and flexibility. CLI, on the other hand, is a text-based interface that allows users to interact with a computer system using commands. CLI is more efficient and flexible than GUI, but it requires some level of technical expertise.

Advantages of CLI over GUI

CLI has several advantages over GUI that make it a more efficient option for certain tasks. Here are the top five advantages of CLI over GUI:

Improved efficiency with CLI

CLI is a highly efficient way to interact with a computer system, especially when it comes to performing repetitive tasks. With CLI, you can automate repetitive tasks using scripts, which can save you a lot of time and effort. In today's fast-paced world, where efficiency and time-saving are crucial, CLI can help users achieve these goals. CLI also allows you to perform tasks faster than GUI, especially if you are an experienced user who prefers to work with a keyboard.

Flexibility and customization options with CLI

CLI is more flexible than GUI when it comes to customization options. With CLI, you can customize your environment to suit your needs, such as defining your own aliases and functions. You can also use CLI tools to perform a wide range of tasks, such as text processing, file management, and network administration.

CLI for automation and scripting

CLI is the preferred interface for automation and scripting. With CLI, you can create scripts to automate repetitive tasks, such as backups, updates, and installations. CLI scripting is also useful for system administration tasks, such as user management and network configuration.

CLI in programming and development

CLI is the preferred interface for programming and development. Many programming languages, such as Python, Ruby, and Perl, are designed to be used with CLI. CLI also allows you to use a wide range of development tools, such as Git, Docker, and Vim.

CLI for troubleshooting and system maintenance

CLI is an excellent choice for troubleshooting and system maintenance tasks. As opposed to GUI, CLI allows you to access system logs, diagnose issues, and perform system maintenance activities more effectively. CLI also offers greater control over system settings and enables you to interact with the system at a lower level, which can be helpful in identifying and resolving complex problems. Whether you're an experienced system administrator or a curious user looking to dive deeper into your computer's inner workings, CLI provides an efficient and flexible way to maintain and troubleshoot your system.

CLI tools and resources

Here are some popular CLI tools and resources:

Bash: A popular shell for UNIX-based systems.
Zsh: An alternative shell with advanced features and customization options.
PowerShell: A CLI shell for Windows systems.
Vim: A powerful text editor for CLI.
Git: A version control system for software development.
Docker CLI: A containerization platform for software development.

By using these tools, you can take advantage of the power and flexibility of CLI for programming, system maintenance, and automation.

Conclusion

In conclusion, Command Line Interface (CLI) is a more efficient option than Graphical User Interface (GUI) for certain tasks. CLI is more efficient, flexible, and customizable than GUI, and is the preferred interface for automation, scripting, programming, troubleshooting, and system maintenance. If you are a computer user who values efficiency and flexibility, then learning CLI is a valuable skill that can help you get the most out of your computer system. If you found this article informative, be sure to follow me for more articles like this.

Understanding Linux File System: An Overview of Essential Directories

Arth Vhanesa — Sat, 22 Apr 2023 12:20:30 +0000

Introduction

The Linux operating system has a special component called the file system, which helps store and access files and data. It has a hierarchical structure that helps keep things organized and standardized. Knowing how this hierarchy works is important for anyone using Linux so they can find what they need quickly and easily. In this blog post, we'll go over each folder in the Linux file system hierarchy and explain what they're used for. By the end, you'll have a better idea of how the Linux file system works and how to navigate it.

Linux File System

The Linux file system is structured hierarchically, with a single root folder / as the starting point for all directories and files. Within the root folder, there are various directories, including /bin, /home, /usr, and /var, among others. Every user on Linux gets their own space inside the /home directory, making it easier to organize and access personal files. In addition, each user has its own space for system configuration files and settings, which helps to prevent conflicts between users. Programs installed system-wide are available to all users, ensuring that everyone has access to the same tools and resources.

On the other hand, the Windows file system has multiple root folders, with each drive letter (such as C:\ or D:\) serving as a separate root folder. Within each root folder, there are various directories, such as Program Files, Users, and Windows, among others. Unlike Linux, Windows does not have a single root folder that serves as the starting point for all directories and files. Each user on Windows also gets their own space, typically located in the Users directory, which includes personal files, documents, and settings.

In Linux, the root directory / is where all other directories and files stem from, and it includes important directories like /home, /root, /bin, /sbin, /dev, and others. Understanding the meaning of these directories is essential for navigating the Linux file system efficiently.

Directories

/home

The /home directory in Linux is where all non-root user home directories are stored. Each user has a folder in this directory with their name as the folder name.

Any programs installed in the /home directory is available only to the user associated with that directory. This allows each user to have their own set of programs and applications without interfering with other users' settings.

Another important thing about the /home directory is that you can read and write to it without needing root access.

/root

The /root directory in Linux is the home directory of the root user. Unlike the /home directory which contains home directories of non-root users, the /root directory is specifically for the root user. It's important to note that this directory is not the same as the root directory /, which is the starting point for all directories and files in the Linux file system.

/bin

The /bin directory in Linux stands for "binaries" and it contains the essential executable files (commands) for most user commands like ls, cat, pwd, and touch.

These executable files are available system-wide, meaning all users can access them. The reason why they are stored in the /bin directory is that they are binary files that the computer can understand, hence the name "binaries."

Having these essential commands available in the /bin directory, users can quickly access them and perform common tasks efficiently.

/sbin

The /sbin directory in Linux stands for "system binaries" and it contains essential commands related to the system. These commands are used by system administrators for tasks like setting up users, networks, and passwords.

Since these tasks require administrative privileges, you need superuser permissions to execute commands in the /sbin directory. These binaries are considered essential for system maintenance and are not available to regular users.

Overall, the /sbin directory contains critical system binaries that system administrators use to manage and maintain the Linux system.

/lib

The /lib directory in Linux stands for "library" and it contains essential shared libraries that are required by executables in the /bin and /sbin directories.

In Linux, a program is often split into multiple components, with the executable files stored in the /bin or /sbin directories and the necessary libraries stored in the /lib directory. This separation allows programs to be more modular and efficient.

All programs downloaded on Linux are stored in this way, with their binaries in the /bin directory and their libraries in the /lib directory. The /lib directory is an important component of the Linux file system that ensures that programs can run efficiently and with the necessary resources.

/usr

The /usr directory in Linux stands for "user". It originally contained home directories but now it contains the /bin, /sbin, and /lib folders. The bin folder contains commands like ls and copy that is executed from the terminal.

The separation of binary files in both the root and user binary folders is due to limitations in storage space in the past. Though this limitation no longer exists, the concept remains the same. Some Linux OS versions have fewer commands in the root /bin and /sbin directories.

/usr/local

The /usr/local directory in Linux contains the /bin, /sbin, and /lib folders, and it's where third-party applications are installed. When a user installs a program on their computer, its binaries go into /usr/local/bin, and its libraries go into /usr/local/lib. This directory is available to all users on the computer, and any program installed here can be accessed system-wide.

/opt

The /opt directory in Linux stands for "optional" and is initially empty. It is used for programs that do not split their components like binaries and libraries.

These programs are typically third-party programs that we install on our system. Code editors and browsers are some examples of programs that are installed in /opt. Programs installed in /opt are available system-wide, just like those installed in /usr/local.

However, it is important to note that programs that can split their components are typically installed in /usr/local, whereas those that cannot are installed in /opt.

/boot

The /boot directory in Linux contains the essential files required for booting the operating system. These files include the Linux kernel, initial ramdisk image, bootloader configuration files, and other boot-related files.

This directory is crucial for the proper functioning of the operating system and should not be modified or deleted by the user. The files in this directory are automatically updated during system upgrades and kernel updates.

/etc

The /etc directory in Linux stands for "et cetera" and is the location where system configurations are stored, including Linux user data and passwords, network settings, and other important system information. It is a read-write directory and has emerged as the main configuration location for various Linux distributions.

/dev

The /dev directory stands for "devices" and contains device files for hardware such as webcams, keyboards, hard drives, and microphones. Applications and drivers access this directory, not users. All files the system needs to interact with hardware will be found here. In other words, it is a location of special files that represent hardware devices installed on the system. The files in this directory are generally not directly readable or writable, but the system uses them to interact with hardware.

/proc

The /proc directory in Linux is a virtual file system that provides a way for users and programs to access system information. It does not contain physical files, but instead, the files within it are created dynamically and reflect the current state of the system.

Users and programs can read and write to these files to get information about system hardware, processes, and kernel settings. For example, the /proc/cpuinfo file provides details about the system's CPU usage, while the /proc/meminfo file contains information about memory usage.

Overall, the /proc directory is a critical component of the Linux system and is used extensively by system administrators and programmers for debugging, monitoring, and system analysis.

/sys

The /sys directory in Linux is a special file system that offers a structured view of kernel data structures and hardware device information. It is presented in a hierarchical manner of directories and files, allowing easy access and modification of device parameters.

The directory contains crucial details of system devices like input/output (I/O) devices, network interfaces, and storage devices. Additionally, it holds information regarding system status, including power management settings and system clock configurations.

It is different from the /proc directory, /sys provides information about the hardware and drivers in a structured and standardized way, whereas the /proc directory provides information about the system's processes and kernel more systematically. The /sys directory is used by system administrators and device driver developers to interact with the system's hardware and configure the system's devices.

/var

The /var directory in Linux stands for "variable". It contains files and directories that may change in size and content over time during the system's operation. The /var/log directory stores system log files, while the /var/cache directory contains cached data from application programs.

Other directories in /var may include spool directories for printing and mail, and directories for temporary files created by applications. These files are typically read and written by system services and applications, rather than users directly.

/run

The /run directory in Linux is a temporary file system that stores runtime data of processes running on the system. It is used by system services to store data that needs to be preserved across reboots. The data stored in /run is lost when the system is shut down.

This directory was created to replace the /var/run directory which is used to store volatile runtime data. The files in the /run directory are created by the system at boot time and are automatically cleaned up on shutdown. Some of the files stored in /run include process IDs, socket files, and lock files.

/tmp

The /tmp directory in Linux is used to store temporary files that applications create during their operation. These files are usually deleted automatically at some point, as they are not meant to persist beyond the current session. The /tmp directory is accessible by all users, and applications typically use it to store data that does not need to be kept long-term.

/media

The /media directory in Linux is used to mount removable media devices such as USB drives, CD-ROMs, and DVDs. Whenever a new removable media device is inserted into the computer, a corresponding directory will automatically be created in /media, and the contents of the device will be accessible inside the directory. This directory is used by the system to automatically mount and unmount the removable media.

/mnt

The /mnt directory is used for temporarily mounting file systems. It is usually empty but can be used by system administrators to manually mount file systems as needed. Unlike the /media directory which is used for automatically mounting removable media devices, the /mnt directory is used for manually mounting file systems.

Hidden files

Hidden files are files that are not shown in the directory listing by default. These files are often used to prevent important data from being accidentally deleted or to store auto-generated files or configuration settings that are specific to a particular user.

In Linux, hidden files are denoted by a dot (.) preceding the file name, and are often referred to as "dotfiles". When we enable the option to show hidden files, we can view these files and modify them as needed. It is important to be aware of the presence of hidden files, as they can contain critical information related to the functioning of the system or specific applications.

Conclusion

In conclusion, although users may not typically interact with the various directories on a Linux system, it is important to understand their purpose and location. Applications installed using package managers or installers automatically handle the creation of folders, binaries, and libraries. For example, the insertion of a USB device will automatically create a directory in /media. Knowing where these files are located and how the system works can be beneficial for troubleshooting purposes.

The 6 Stages of the Software Development Life Cycle (SDLC) Explained

Arth Vhanesa — Mon, 27 Feb 2023 03:30:00 +0000

What is SDLC?

Software development life cycle (SDLC) is a methodology for designing and developing sophisticated software which fulfills the requirements of a company and its users. Companies at large scale use SDLC for developing software with high-quality assurance within a given time and cost.

The model has 6 significant steps with specific instructions making the process more systematic. This can be used to develop any kind of software from small-scale applications to large-scale enterprise systems.

Stages of SDLC model

The Software Development Life Cycle consists of six stages:

Requirement gathering
Analysis and Design
Implementation
Testing
Deployment
Maintenance

This model ensures the quality of software and the overall development process. Each step includes a specific task to be performed during the development of software.

1. Requirement gathering

Requirement gathering is the first and fundamental step of the Software Development Life Cycle. To gain a better understanding of a need, the developer team collects information, ideas, and requirements by taking inputs from all stakeholders.

They also analyze the current system, stakeholders' interests, end users' needs, and expected outcomes to ensure the development process meets everyone's objectives. Creating a project plan, defining the scope, setting goals, and identifying risks are essential steps in requirement gathering.

2. Analysis and Design

During the analysis phase, the team analyzes the requirements of a project collected in requirement gathering and identifies any potential problems or areas for improvement. After analyzing the requirements, the team generates Software Requirement Specification (SRS) document which includes all requirements to be designed and developed.

Design is a foundation phase of SDLC. It involves creating a blueprint of the software product. The team defines the final requirements and plans and creates detailed specifications. They create the best approach for software architecture, user interface design, database design, and other necessary components, and document them in Software Design Document. (also known as a software design specification or technical specification document)

3. Implementation

Implementation is a phase where actual development starts. In this phase, The team develops the software according to Software Design Document. Developers must follow the fundamentals and standard practices of coding to produce a working system that meets all functional requirements according to plan. They also need to debug when it is necessary for maintaining the quality of the software.

4. Testing

The testing phase begins after the implementation phase. Here, the team conducts various types of testing to ensure that the software product is functioning properly and meeting the required specifications. Bugs and other issues of the development stage are detected and fixed at this stage.

Testing includes unit testing, system testing, integration testing, functional testing, user acceptance testing, security testing and other types of tests as well. The software has to be tested thoroughly to ensure all the issues are identified and fixed before the deployment.

5. Deployment

Once a product is tested, developers deploy it from the developer environment to the production environment making it available to end users. This involves installing the software on one or more servers according to need. Sometimes, software gets deployed in stages for testing in a real environment. Once the software is deployed, developers start collecting feedback on its performance.

6. Maintenance

After deployment, maintenance of the software is needed. Maintenance is a very crucial stage of this cycle where maintainers monitor and fix the issues. New features can be introduced that was not originally planned, during maintenance. It ensures that the performance, speed, and robustness of the software remains the same with updated technology and meet users' requirement.

SDLC Models

Many SDLC models are designed to meet different development needs. Each model has its own set of advantages and disadvantages. Developers need to choose one of the models to develop software considering the risk, efficiency improvement, customization and flexibility. Some of the most popular SDLC models include the Waterfall model, Iterative Model, Spiral Model, V-Model, Big Band Model, Agile Model and Prototype Model.

Models are shaped to achieve a particular outcome. For example, Waterfall Model is best suited for projects with clearly defined requirements and scope of work. On the other hand, the agile model is appropriate for projects that require flexibility and adaptability to changing requirements.

Conclusion

Software Development Life Cycle (SDLC) is a model that guides the development of top-notch software in a structured and systematic way. Its 6 stages make it easy to develop software more efficiently.

The development team ensures that every requirement is fulfilled. Thus the successful application of the SDLC model helps in building the desired software.

DEV Community: Arth Vhanesa

How to Remove Secrets From a Git Repository

Remove secrets using the filter-branch command

Step 1: Use the filter-branch command

Step 2: Add secrets into .gitignore

Step 3: Push your local changes to a remote repository

Step 4: Push against your Git tags

Conclusion

Basics of PHP Variable Scope Explained

Introduction

Types of variable scope

Local Variables

Global Variables

Static Variables

SuperGlobal Variables

Conclusion

Bhoomi — The Future of Secure Property Transfers

Brief about the problem

Approach to solving this problem

Flowchart

Technology Stack

Outcome

Features and Benefits

PS:

Vim Editor in Linux: Mastering the Basics

Introduction

Advantages of using CLI text editor

Modes in Vim Editor

1. Normal Mode

2. Insert Mode

3. Command mode

Conclusion

Package Managers in Linux: The Basics Explained

Introduction

What is a Software package?

Why do we need a Package Manager?

APT Package Manager in Linux

APT vs APT-GET

Alternative Ways to Install Software

1. Snap package manager

2. Ubuntu software center

3. Add the repo to the official list of repository

Conclusion

5 Reasons Why Command Line Interface (CLI) is More Efficient Than GUI

What is Command Line Interface (CLI)?

The difference between CLI and GUI

Advantages of CLI over GUI

Improved efficiency with CLI

Flexibility and customization options with CLI

CLI for automation and scripting

CLI in programming and development

CLI for troubleshooting and system maintenance

CLI tools and resources

Conclusion

Understanding Linux File System: An Overview of Essential Directories

Introduction

Linux File System

Directories

/home

/root

/bin

/sbin

/lib

/usr

/usr/local

/opt

/boot

/etc

/dev

/proc

/sys

/var

/run

/tmp

/media

/mnt

Hidden files

Conclusion

The 6 Stages of the Software Development Life Cycle (SDLC) Explained

What is SDLC?

Remove secrets using the `filter-branch` command

Step 1: Use the `filter-branch` command

Step 2: Add secrets into `.gitignore`