DEV Community: Ugochi Ukaegbu

Linux Permissions: A Beginner's Guide

Ugochi Ukaegbu — Thu, 02 May 2024 09:56:02 +0000

INTRODUCTION

By now, you should be aware that on Linux, everything is a file. Different permission levels are assigned to these files. Permission, according to the Cambridge Dictionary, is the act of permitting someone or something to happen.

As an illustration, the owner of a document in Google Docs can provide different access to all users or only specific users.

The owner can grant read-only permission, meaning that other users can view the document but not alter it. Other users may be permitted to join as editors with the owner's consent. By doing this, they can edit the file. With Linux, the same is true.

As the title suggests, this article is for beginners who are interested in knowing about Linux Permissions.

LINUX PERMISSIONS ON A PLATTER

A key component of the operating system's security model in Linux is the concept of permissions. Linux permissions regulate who can access and alter files and directories on a Linux system.

In Linux, who is eligible to gain access to files?

Owner: The user who is the directory's or file's owner.
Group: A collection of users who may require access to the files.
Others: All other individuals not affiliated with the group or the owner.

-rwxrwxrwx 1 vagrant vagrant 3771 Aug 3 21:56 Nigeria

The first group of permission (rwx) is for the owner.

 The second group of permission (rwx) is for the group.

 The third group of permission (rwx) is for other users

They may receive the following permissions:

Read (r): This permission command allows you to view or read the file or directory.
Write (w): This permission allows you to modify a file or directory.
Execute (x): This permission allows you to run the file or directory.

How to tell a file and directory apart?

(d) indicates that the document is a directory while (-) indicates that it is a file.

-rw-r--r-- 1 vagrant vagrant 3771 Aug 3 21:56 .bashrcdrwx------ 2 vagrant vagrant 4096 Aug 14 16:56 .cache-rw-r--r-- 1 vagrant vagrant 807 Aug 3 21:56 .profiledrwx------ 2 vagrant vagrant 4096 Aug 14 16:56 .ssh-rw------- 1 vagrant vagrant 11048 Sep 17 21:03 .viminfo

How to specify permissions?

There are three methods for specifying permissions:

The use of octal notation.
The symbolic approach.

Octal Notation Method

Linux file and directory permissions can be represented using octal (base-8) numbers using the octal notation approach. It's an efficient approach to communicate authorization settings that use numbers.

Each permission (read, write, execute) is assigned a numeric value and they are:

Read (r) is represented by the value 4.
Write (w) is represented by the value 2.
Execute (x) is represented by the value 1.

You must add these values for each permission type (owner, group, and others) in order to use octal notation. This indicates that the number must be 7 for any of the actors to have full permission.

Example:

A file that has permission 765 implies that:

the owner has permission to read(4), write(2) and execute(1) which totals (7).

the users in the group has permission to read(4) and write(2) which totals (6).

the other users has permission to read(4) and execute (1) which totals (5).

The Symbolic Method

This approach makes use of operators and enables the specification of permission using single-letter abbreviations.

There are three main components to this method's basic structure :

Who: The following letters can be used to denote different authorization categories:
Operator: The following symbols can be used to denote the operation you wish to carry out:
Permissions: The specific permissions you wish to request are represented by letters:

Changing file permissions

You can change file permissions in Linux using the chmod command which means change mode. There are multiple ways to specify the new permissions, including the symbolic method and the absolute (octal) method.

Examples:

Using the symbolic notation to assign permissions to files or directories:

chmod u+r file.txt (This command adds read permission to the owner of file.txt).
chmod g+rw file.txt (This command adds both read and write permissions to the group of file.txt).
chmod g=rw file.txt (This command sets the group permissions of file.txt to read and write only.
chmod -R u+rw directory (This command adds read and write permissions to the owner recursively for all files and subdirectories within directory).

Using the Octal method to assign permissions to files and directories:

chmod 755 file.txt (This command sets the permissions of file.txt to read, write, and execute for the owner, and only read and execute for the group and others).
chmod 640 file.txt (This command sets the permissions of file.txt to read and write for the owner, read-only for the group, and no permissions for others).
chmod -R 644 directory (This command sets the permissions of all files and subdirectories within directory to read and write for the owner and read-only for the group and others).

Conclusion

Linux file permissions are essential for regulating access to files and directories on a Linux system, and you can modify the permissions of the files and directories using any of these techniques.

Bash Script Operators

Ugochi Ukaegbu — Sun, 22 Oct 2023 23:08:17 +0000

INTRODUCTION

A Bash shell script, often known as a shell script or just a shell, is a text file that contains a series of commands written in the Bash (Bourne Again Shell) scripting language.

Operators are special symbols or characters used in Bash scripting to carry out various operations on values and variables; these operators are frequently employed with commands to carry out numerous operations, comparisons, and conditional checks.

This article is for beginners who are interested in learning the definition of bash operators and how to use them with Linux commands.

Note: You should have prior knowledge of Shebang and the importance of including them in the script.

You should also have knowledge of Linux permissions.

KNOW YOUR BASH OPERATORS

There are different categories of bash operators but for the purpose of this article we will focus on four:

Arithmetic Operators
Relational or Comparison Operators
Boolean or Logical Operators
FileTest Operators

Arithmetic Operators

These operators are used to perform mathematical operations. The following is a list of the seven bash arithmetic operators:

For the purpose of the explanation of these operators, two variables would be used:
num1=20
num2=5

Addition +: This operator is used to add two operands or concatenate two strings and returns the result of that operation.

echo $(( num1 + num2 ))
echo $(( 20 + 5 ))
echo $(( 25 ))
output: 25

Subtraction-: This operator is used to subtract one operand from the other and returns the result of that operation.

echo $(( num1 - num2 ))
echo $(( 20 - 5 ))
echo $(( 15 ))
output: 15

Multiplication*: This operator is used to multiply two operands and returns the result of that operation.

echo $(( num1 * num2 ))
echo $(( 20 * 5 ))
echo $(( 100 ))
output: 100

Division/: This operator is used to divide two operands and returns only the integer part.

echo $(( num1 / num2 ))
echo $(( 20 / 5 ))
echo $(( 4 ))
output: 4

Modulus %: This operator is used to divide two operands and returns only the remainder part.

echo $(( num1 % num2 ))
echo $(( 20 % 5 ))
echo $(( 0 ))
output: 0

Increment++: This is a unary operator used to increase the operand by one.
Using the same example, we introduce another variable:
sum=$num1+$num2

echo $(( ++sum ))
output: 26

Decrement--: This is a unary operator used to decrease the operand by one.
Using the same example, we introduce another variable
sum=$num1*$num2

echo $(( --sum ))
output: 99

**An alternative way to use arithmetic operators is to use the expr command. **This command is only used for integer values. This means that this command will not work with float numbers. This method will give the same output as the method above.

echo $( expr $num1 + $num2 )
echo $( expr $num1 - $num2 )
echo $( expr $num1 / $num2 )
echo $( expr $num1 \* $num2)

This is because * without \ will produce a syntax error.

Relational Operators

These operators specify the relationship between two operands. Depending on the relationship, they either yield true or false. These operators are:

*Equal to *(==) or (-eq): It returns true if the two operands are equal otherwise returns false.

var1=40
var2=40

if (( $var1 == $var2 ))
then
    echo True
else
    echo False
fi

output: True

Another example:

var1='banana'
var2='banana'

if [[ "$var1" -eq "$var2" ]]
then
    echo True
else
    echo False
fi

output: True

*Not Equal to *(!=) or (-ne): It returns true if the two operands are not equal, otherwise it returns false.

var1=40
var2=20

if [[ "$var1" -ne "$var2" ]]
then
    echo True
else
    echo False
fi

Another way to write this is:
if (( "$var1" != "$var2" ))
then
    echo True
else
    echo False
fi

output: True
*Less than *(<) or (le): The operator returns true if the first operand is less than the second operand otherwise returns false.

var1=40
var2=20

if [[ "$var1" -lt "$var2" ]]
then
    echo True
else
    echo False
fi

Another way to write this is:
if (( "$var1" < "$var2" ))
then
    echo True
else
    echo False
fi

output: False

Greater than (>) or (-gt): It returns true if the first operand is greater than the second operand, otherwise it will return false

var1=40
var2=20

if [[ "$var1" -gt "$var2" ]]
then
    echo True
else
    echo False
fi

Another way to write this is:
if (( "$var1" > "$var2" ))
then
    echo True
else
    echo False
fi

output: True

Less or equal to(<=) or (-le): This operator returns true if the first operand is less than or equal to the second operand otherwise returns false.

var1=40
var2=20

if [[ "$var1" -le "$var2" ]]
then
    echo True
else
    echo False
fi

Another way to write this is:
if (( "$var1" <= "$var2" ))
then
    echo True
else
    echo False
fi

output: False

Greater or equal to (<=) or (-ge): This operator returns true if the first operand is less than or equal to the second operand otherwise returns false.

var1=40
var2=20

if [[ "$var1" -ge "$var2" ]]
then
    echo True
else
    echo False
fi

Another way to write this is:
if (( "$var1" >= "$var2" ))
then
    echo True
else
    echo False
fi

output: True

Boolean Operators

These operators are used for comparing two values or expressions, if they are true then it will return True else False.

Logical And(&&): This operator returns true if both the operands are true otherwise returns false.

var=40

if [ "$var" -gt 20 -a "$var" -lt 60 ]
then
    echo true
else
    echo false
fi 

Alternatively, it can be written in the following ways:

if ["$var" -gt 20] && ["$var" -lt 60]
then
    echo true
else
    echo false
fi

or this way;
if [[ "$var" -gt 20 && "$var" -lt 60 ]]
then
    echo true
else
    echo false
fi

output: True

Logical Or(||): This operator returns true if either of the operands is true or both the operands are true and returns false if none of them is false.

var=40

if [ "$var" -gt 60 -o "$var" -lt 50 ]
then
    echo true
else
    echo false
fi 

Alternatively, it can be written in the following ways:

if [ "$var" -gt 60 ] || [ "$var" -lt 50 ]
then
    echo true
else
    echo false
fi

or this way;
if [[ "$var" -gt 60 || "$var" -lt 50 ]]
then
    echo true
else
    echo false
fi

output: True

Logical Not(!): This unary operator returns true if the operand is false and returns false if the operand is true.

var=40

if [ ! "$var" -gt 60 -o "$var" -lt 50 ]
then
    echo true
else
    echo false
fi 

Alternatively, it can be written in the following ways:
if [[ ! "$var" -gt 60 && "$var" -lt 50 ]]
then
    echo true
else
    echo false
fi

False

File Operators

In Bash, file operators are used to verify and test files and directories. In order to show whether a certain condition is satisfied, file operators return a Boolean value (true or false).

-b operator: This operator determines whether or not a file is a block special file. If the file is a block special file, it returns true; otherwise, it returns false.

-c operator: This operator determines whether or not a file is a character special file. If the file is a character special file, it returns true; otherwise, it returns false.

-d operator: This operator checks if a directory. If it exists it returns true; otherwise, it returns false.

-e operator: This operator checks if a file exists. If it exists it returns true; otherwise, it returns false.

-f operator: This operator checks if a path exists and points to a regular file (not a directory or device). If it exists it returns true; otherwise, it returns false.

-l operator: This operator checks if the path exists and is a symbolic link. If the path exists then it returns true; otherwise, it returns false.

-r operator: This operator checks if the file and directory exist and are readable. If the file or directory is readable then it returns true; otherwise, it returns false.

-s operator: This operator checks the size of the given file. If the size of the given file is greater than 0 then it returns true; otherwise, it is false

-w operator: This operator checks if the file and directory exist and are writable. If the file or directory is writable then it returns true; otherwise, it returns false.

-x operator: This operator checks if the file and directory exist and are executable. If the file or directory is executable then it returns true; otherwise, it returns false.

The syntax to use any of the file operators is:

if [ fileoperator file-name ]

var=/etc/ssh/sshd_config
if [ -l $var ]
then
    echo ' '
else
    echo ' '
fi

Conclusion

You can write Bash scripts that make decision, carry out computations, and interact with files and directories by using operators such the arithmetic, comparison, logical, and file operators. These operators are necessary for building flexible, error-handling scripts that can respond to a variety of situations.

JAVASCRIPT INTRO FOR BEGINNERS

Ugochi Ukaegbu — Fri, 30 Jun 2023 17:01:30 +0000

INTRODUCTION

Creating the front end of a web page requires using tools like Hypertext Markup Language (HTML), Cascading Style Sheets (CSS), and JavaScript. JavaScript is a programming language that allows you to add interactivity and dynamic functionality to a web page.

Front-end developers employ the popular programming language JavaScript to make webpages interactive. When an instruction is requested, Java Script instructs the computers what to perform and executes that command.

Consider an e-commerce site where the product you have chosen is immediately added to the cart when you click the add to cart button. JavaScript is carrying out this command.

An additional example of how JavaScript is used is in a smart home, where the instructions have been established so that when someone enters the house, the lights turn on, and when they depart, the lights turn out. The lights turn on as a result of instructions being delivered, which can be accomplished using JavaScript.

Are there other programming languages? Yes, they are but JavaScript is the main language used for the interactivity and dynamic functionality of a website.

Read this article on the history and origin of JavaScript

Setting up the Development Environment:

The different options for running JavaScript code include:

using a web browser
using an Integrated Development Environment (IDE)

The following steps are required when using a web browser to run JavaScript code:
Open a new tab on your browser

Right-click on the web page

Click on inspect

Click on the console

Clear out the error message

Type your code

What is an IDE?
An integrated development environment is a tool developers use to write, edit, and manage their code more efficiently. Examples of some of the IDEs are:

The following are the steps required to use Visual Studio Code to run JavaScript code:

Download Visual Studio Code
Install Visual Studio Code
Create a Folder inside the document folder on your computer
Open your VS Code.
To open your VS code do the following:

a. Click on File

b. Click on Open your folder

c. Click on the File icon to create a JavaScript file

d. Type in the name of your file
e. Install Quokka in your VS code
Note:
Your file name must end with a .js extension. e.g newTask.js
Read this article to learn more about Quokka

Variables in JavaScript

Variables are containers used to store values. You can think of variables as a box that contains various items.

Items like books, clothes, kitchen utensils, and so on can be stored in a box. In JavaScript, these items are called values and they are of different data types.

Data is a collection of facts and information to be examined and used for decision-making. This data is categorized into:

Numbers
Strings
Bigint
Boolean
Null
Undefined
Arrays
Object

Consider this equation:
let X = 5.
In JavaScript, this means that X is a container that holds 5.

Declaration of Variable
JavaScript is case-sensitive so when declaring variables take note of your words.

The different keywords used when declaring variables are:

Automatically
let
const
var

e.g let firstName;

"Let" is the Keyword while "firstName" is the variable name.

Assigning Values to variables
The assignment operator (=) is used to assign values to the variable. Think of a woman who wants to relocate to another city; she could pack all her clothes in a red leather bag and kitchenware in a paper box. She chooses what each box should hold. Variables store different values as a result of the assignment operator. The variable remains empty if the assignment operator doesn't assign it any values.

Example 1: let firstName = “Sandra”

Naming variables
There are different ways of naming variables and they include:

Camel Case.
Snake Case.
Pascal Case.

Camel Case: This is the practice of writing where each word or abbreviation after the first word begins with a capital letter with no punctuation or spaces
Examples:

let firstName
let multipleUserName
const secondJourney

Snake Case: This is the practice of separating different words with an underscore. The words are written in lowercase.
Examples:

var my_car
const the_three_numbers

Paschal Case: This is the practice of writing the first letter of the words in uppercase.
Examples are:

let UserAccount
const FullName
Note: Do not try to use the different styles on the same project. Choose a style and stick with it.

Arithmetic Operators in JavaScript

There are different types of operators in JavaScript but this article will focus only on arithmetic operators.

In JavaScript, the arithmetic operators used to perform operations on number data type:

ARITHMETIC OPERATORS

(+ Addition)
(- Subtraction)
(* Multiplication)
(/ Division)
(% Modulus)
(** Exponential)
(++ Increment)
(-- Decrement)

Examples:
Using (+) operator
let x = 18;
let y = 30;
console.log(x + Y)
output: 48

Using (-) operator
let priceOfShirt = 400;
var priceOfTie = 150;
console.log(priceOfShirt - priceOfTie)
output: 250

Using (*) operator
var m = 40;
var n = 8;
console.log(m * n)
output: 320

Using (/) operator
const unitsOfBags = 200;
var priceOfBags = 5;
console.log(unitsOfBags / priceOfBags)
output: 40

Using (%) operator
let a = 50;
let b = 6;
console.log(a % b)
output: 2

Using the exponential operator

Conclusion

You have started the process of learning JavaScript by becoming familiar with these key ideas. To further develop your skills, keep in mind to practice writing code, look into alternative sources, and look for real-world applications.

As a constantly changing language, there is always more to learn about JavaScript. You will therefore be well on your road to becoming a JavaScript developer if you keep exploring and trying new things.

TECHNICAL WRITING 101: THE BASICS

Ugochi Ukaegbu — Mon, 19 Jun 2023 21:06:58 +0000

INTRODUCTION
You are reading this because you want to learn more about technical writing. The article is not for you if you have experience with technical writing. This article aims to simplify technical writing for beginners and show them how to communicate their experiences.

How technical writing is used varies, but one such situation is when people choose to develop technical skills because of the numerous work opportunities that technology provides.

What happens when they hear words like HTML and JavaScript? If the meaning of the words is conveyed in a way that they can’t understand, they'll become overwhelmed and confused. Technical writing can help with this.

READY TO DIVE INTO THE WORLD OF TECHNICAL WRITING?

In the simplest of terms, technical writing involves technical skills that require training, and writing requires documenting those skills on a Notebook, Note-pad, or, Laptop.

Technical writing is a style of communication that involves empathizing with your readers by providing them with detailed instructions or explanations of what a technical subject is all about.

ANALYSE YOUR AUDIENCE

You went through the elementary, high school, and university stages of studying the same topic. The only difference is the content underwent significant improvement; the same applies to technical writing.

Before you start writing on any concept, you have to ask yourself this question:

Who do I intend to write to?
Do I want to write to beginners, intermediate or advanced learners?
What are the pain points of the audience?
How do I solve these challenges?

Consider that the goal of your writing is to make HTML simpler for readers who are just learning about it. It's improper to create an article and use the abbreviation HTML, with the expectation that the reader would comprehend the full form of HTML. For them to become familiar with the concept, it is required to write out the full form of HTML multiple times.

MASTER THE ART OF RESEARCH AND INFORMATION GATHERING

The ideology that you must be an expert in a particular field before writing about it is false. Some properties in the programming languages used in the past are deprecated today, so it's crucial that whatever you put out there for readers to digest has to be up-to-date.
Researching a concept in your field that is foreign to you is another option. When you are knowledgeable enough about the subject to explain it to a teenager, you are ready to make it available for readers to digest.

CLEAR AND CONCISE COMMUNICATION

Technical writing originated from the need to break down complex terms for every stakeholder to understand. The stakeholders can be students, colleagues, and so on.
Avoid using jargon; make sure that you are clear and concise as possible. Communication in technical writing is effective when the receiver can assimilate your message.

KNOW YOUR TOOLS
Technical Writers utilize different tools to publish their works, making their writings very engaging and explanatory for the readers.
The following tools used by technical writers are:
writing tools.

spell-check tools.
publishing tools.
image editing tools.
screen capture tools.
Use writing tools like Microsoft Word and Google Docs to pen down your thoughts.

Install spell-check tools like Grammarly to correct your spelling and check your grammar for clarity.

Some readers are visual learners. They get bored when it's only text used from the beginning to the end of the article, so using image editing tools like Canva to create beautiful pictures and story is necessary for a Technical Writer.

Use screen-capturing tools to capture snippets of your code. You need to realize that some readers would prefer watching a video in, let’s say C++. If you have to write a text-based explanation on C++, you have to include snippets of your code.

REGISTER ON A PUBLISHING PLATFORM

When your content is ready for readers to digest, the next step is to register on a publishing platform. Register on publishing platforms like DEV to publish your articles.

CONCLUSION
Technical writing is a skill that makes it possible to explain complex information effectively. Technical writers can create documents that their readers can readily access and understand by understanding the intended audience, adopting clarity and conciseness. Careful planning, research, and the use of visual aids all help to increase the impact and quality of technical writing.
Beginners can learn the skill of technical writing and unleash their ability to communicate information clearly and precisely. Accept the challenge, learn about technical writing, and embark on a path that enables you to speak clearly and authoritatively.