How Does the Shell Command ls -l work ?

crxs14 — Mon, 27 Sep 2021 21:30:51 +0000

Linux ls command is used to list files and directories. By default, it will list the content of the current directory. In this article, I will show linux operate certain process and operations in order to execute this command .
first thing first, before starting talking about the ls command, it’s important to understand how linux work …

****Shell & command line :

****The system calls :
To make this happens, Linux need to operate a succession of operations and tasks, to make the execution of a given command possible ..
When a user type a command , the shell will first make a call to the kernel which is the heart of this operator system , asking him the permission to start executing a process…this fundamental step is called : a system call …
Thanks to this function, the kernel will attribute a private identifier to this process (PID) , giving the birth to anew process that has the ability to exchange data with the kernel using the PID …

**Child process and PID :
It’s important to mention that processes , like the human being , have a parental relation : a process when is born , called : a child Process , and the process that made the **fork()system call , is the father …
A child process inherits most of its attributes, such as file descriptors, from its parent. In Unix, a child process is typically created as a copy of the parent, using the fork system call. The child process can then overlay itself with a different program (using exec) as required. Each process may create many child processes but will have at most one parent process; if a process does not have a parent this usually indicates that it was created directly by the kernel. In some systems, including Linux-based systems, the very first process (called init) is started by the kernel at booting time and never terminates.
After the fork() system call , the operating system has now a free running child process available , so now we can make another function system call , called EXEC() …. thanks to the exec function a new executable file can run in the context of an already existing process (which is the child process) …

Command line interpretation :

let’s go back now to our beloved command Ls , once the shell make the call for a new process , the shell tokenize first the input user(command), and fill it into a null terminated array .

In this array the executable file ls and argument -l are stored separately. Once the command is stored , the program start searching for the full path of the executable file which is the ls in this case …

The shell will look inside the PATH that contain all the environment variables , specifically in the /bin folder where most of the executable files are installed .
If the corresponding path and executable file are found , the shell execute the command through the exec system call , otherwise an error message is printed the user interface .
similarly , and after the executable file was found , the shell will attribute the given stored argument “-l” to the the exe file “Ls” …
So no the full command ls -l is executed , and as a result , a full list of information about files and directories will be printed to the user interface :

Mutable and Immutable objects

crxs14 — Mon, 27 Sep 2021 21:17:22 +0000

If you’ve just started using Python, so you probably heard the theories that everything in python is objects …

Maybe it sounds weird at the beginning, but the further you dive deep on python, the more you start assimilating and understanding the concept of object thing .

Nevertheless, let’s try today to explore together some basic notions and concepts related to our main topic, how objects are mutable and immutable in Python.

Objects in Python could be either mutable or immutable …
Like in science of genetics, the notion of mutation is basically how thing change with the time …Pythonic speaking,a single data object can represent something that evolves independently of the rest of the program. The behavior of a changing object may be influenced by its history, just like an entity in the world.
The concept of mutation in Python could be identified and highlighted by two parameters: id and type …

ID :The built-in function id() returns the identity of an object as an integer. This integer usually corresponds to the object’s location in memory, although this is specific to the Python implementation and the platform being used. The is operator compares the identity of two objects.
Type:The built-in function type() and in association with the print function, print the type of an object. Lets look at a simple example :

a = "Holberton_Tunisia"
>>> id(a) = 1258755887 #this is the addressee memory where the              
                       #object is stored
type(a)
>>> <class: 'string'>

why does it matter and how differently does Python treat mutable and immutable objects ?

As we’ve said earlier, a mutation is the ability to change state through the time… So a mutable object can change its state or contents but there is also object that can not mutate … they are immutable .

a = 14 #a variable of type int
b = 14 #a variable of type int
#if we perform some logical operators:
a == b (TRUE)
a is b (TRUE)
#both of the two variables point to the same object
#simple operation:
a = a + 1
a == b (FALSE)
a is b (FALSE)
#modification of immutable objects is not possible

Let’s do the same but with mutable object:

>>> Listx = list([1, 2, 3])
>>> listy = listx
>>> listx.append(2)
>>> print(listx)
>>> 1, 2, 3, 4
>>> print(listy)
>>> 1, 2, 3, 4
#the two objects hast been mutated 
listx == listy (TRUE)
listx is listy (TRUE)

So, generally in Python:

Mutable and immutable objects are handled differently . Immutable objects are quicker to access and not possible to change … Whereas mutable objects are easy to change. Use of mutable objects is recommended when there is a need to change the size or content of the object like Tuple . But some exceptions are included here!!! in fact we know that tuple in python is immutable. But the tuple consists of a sequence with unchangeable bindings to objects.

tupl = (6, [3, 4, 5])