From d8f0d13fcfa2ebddc862c7dc501708a439ab965b Mon Sep 17 00:00:00 2001
From: Jacques Dainat <jacques.dainat@ird.fr>
Date: Mon, 3 Mar 2025 21:39:28 +0100
Subject: [PATCH] add scripting course and file manipulation

---
 README.md                                     |   3 +
 docs/pages/bash/bash-1-introduction.md        |  24 +-
 docs/pages/bash/bash-2-the-basics.md          |   8 +-
 docs/pages/bash/bash-7-commands.md            |  95 +++++--
 docs/pages/bash/bash-8-loops.md               |   1 -
 docs/pages/bash/bash-9-scripting.md           |  14 -
 .../bash_file/bash-extracting_from_files.md   | 196 ++++++++++++++
 docs/pages/bash_script/bash_script-1-intro.md | 127 +++++++++
 .../bash_script-2-data_structure.md           | 183 +++++++++++++
 .../bash_script/bash_script-3-conditional.md  | 194 ++++++++++++++
 docs/pages/bash_script/bash_script-4-loop.md  | 150 +++++++++++
 .../bash_script/bash_script-5-argument.md     | 243 ++++++++++++++++++
 .../bash_script/bash_script-6-function.md     | 179 +++++++++++++
 .../bash_script/bash_script-7-interface.md    |  75 ++++++
 mkdocs.yml                                    |  17 +-
 15 files changed, 1462 insertions(+), 47 deletions(-)
 delete mode 100644 docs/pages/bash/bash-8-loops.md
 delete mode 100644 docs/pages/bash/bash-9-scripting.md
 create mode 100644 docs/pages/bash_file/bash-extracting_from_files.md
 create mode 100644 docs/pages/bash_script/bash_script-1-intro.md
 create mode 100644 docs/pages/bash_script/bash_script-2-data_structure.md
 create mode 100644 docs/pages/bash_script/bash_script-3-conditional.md
 create mode 100644 docs/pages/bash_script/bash_script-4-loop.md
 create mode 100644 docs/pages/bash_script/bash_script-5-argument.md
 create mode 100644 docs/pages/bash_script/bash_script-6-function.md
 create mode 100644 docs/pages/bash_script/bash_script-7-interface.md

diff --git a/README.md b/README.md
index 9fcaeb1..eed360b 100644
--- a/README.md
+++ b/README.md
@@ -114,6 +114,9 @@ conda activate education
 * `mkdocs new [dir-name]` - Create a new project.
 * `mkdocs -h` - Print help message and exit.
 
+## Acknowledgment
+
+The file manipulation section is build on top of course available at https://forge.ird.fr/isi/isi-formation-unix
 
 ## License
 
diff --git a/docs/pages/bash/bash-1-introduction.md b/docs/pages/bash/bash-1-introduction.md
index 9976d74..e68b7c6 100644
--- a/docs/pages/bash/bash-1-introduction.md
+++ b/docs/pages/bash/bash-1-introduction.md
@@ -87,7 +87,7 @@ A Command-line interface (CLI), a terminal, a shell, a console...
 These terms are often used interchangeably but they have a specific meaning.
 Let's start by deciphering there orignal meaning:
 
-### Terminal / Console
+### Terminal
 
 In a strict sense, a terminal refers primarily to a physical machine equipped with input/output devices and situated at the endpoint of a computer network. It typically consists of a keyboard and a display (monitor).
 A terminal by itself does not offer much functionality. The teletype (`TTY`) was an example of an early-day terminal and predated the use of a computer screen by decades.
@@ -95,7 +95,7 @@ These machines worked like a typewriter excepted the letters you typed got send
 
 ![](../images/1-intro/tty.webp){: style="height:250px"}
 
-A terminal can be a physical devices (`TTY``) communicating over a RS-232 cable. 
+A terminal can be a physical devices (`TTY`) communicating over a RS-232 cable. 
 
 ![](../images/1-intro/DEC_VT100_terminal_transparent.png){: style="height:150px;width:150px"}
 
@@ -103,16 +103,16 @@ Or a software-based emulations
 
 ![](../images/1-intro/emulated_terminal.png){: style="height:250px"}
 
-* A console
+On Unix, files can represent physical devices like your keyboard, mouse, etc. Those type of files are located into the `/dev` directory. They provide a way to communicate with the device drivers handling communications with the underlying physical device.
+As example a program could open the `/dev/tty` file and read from it to get what was being typed on a teletype machine.
+
+### Console
 
 When keyboard and screen replaced the teletypewriter the name of the machine changed into “system console“. So by definition a console is a terminal. The name "Console" comes from the furniture point of view.
 
 ![](../images/1-intro/console.jpg){: style="height:250px"}
 
 
-On Unix, files can represent physical devices like your keyboard, mouse, etc. Those type of files are located into the `/dev` directory. They provide a way to communicate with the device drivers handling communications with the underlying physical device.
-As example a program could open the `/dev/tty` file and read from it to get what was being typed on a teletype machine.
-
 ### Shell
 
 A terminal by itself does not offer much functionality.
@@ -121,9 +121,9 @@ A Unix Terminal is really just a way to pump characters into a `/dev/tty` device
 To be able to parse user input, interpret that input as commands to run and display results, we need a `Unix Shell`. The Shell manages things like the terminal where you write your commands.
 
 Unix operating systems are described with a metaphore: a nut. 
-The nut has 2 layers:
-    * The low level layer is the kernel, the useful part of the nut, and well protected behind the shell.
-    * The high level layer is the nut’s shell. To access the kernel you must go through the shell.
+The nut has 2 layers:  
+    * The low level layer is the kernel, the useful part of the nut, and well protected behind the shell.  
+    * The high level layer is the nut’s shell. To access the kernel you must go through the shell.  
 
 ![](../images/1-intro/nut.png){: style="height:250px"}
 
@@ -170,3 +170,9 @@ Your are now ready to write a command and press `enter` to execute it! You can t
 ```bash
 echo "coucou"
 ```
+
+!!! Success "Quick recap"
+    In this section we've  
+        - demistify the black screen  
+        - disentangle the different terminologies used (terminal, console, shell, CLI)
+        - access the command line interface (CLI) of your computer
diff --git a/docs/pages/bash/bash-2-the-basics.md b/docs/pages/bash/bash-2-the-basics.md
index e0bed45..d41a807 100644
--- a/docs/pages/bash/bash-2-the-basics.md
+++ b/docs/pages/bash/bash-2-the-basics.md
@@ -221,8 +221,11 @@ A last detail to keep in mind: All shell commands are synchronous! the shell wai
 
 ## Variables
 
-### User variables 
+Variables are a fundamental concept in programming. They enable to store, retrieve, and manipulate data dynamically.  
+This will be the first programming concept we explore.
 
+### User variables 
+<!--variables-start-->
 Let's discover the variables.  First we need to think about few things...  
 
 !!! question "what is that?"
@@ -245,7 +248,7 @@ var
     It might be a variable but we do not know what is it yet...
     `var` is just a **String** for now.
 
-But then, what is a variable then?
+But what is a variable then?
 
 **A variable is a named storage location that holds a value or information. Think of a variable as a container. The name of the variable allows you to refer to and access the stored value.**
 
@@ -281,6 +284,7 @@ Much better isn't it?
 
 !!! tip
     You may enconter `$var` and `${var}` syntaxes in the Bash world. The second is prefered by developpers because may avoid some surprises in complex commands.
+<!--variables-end-->
 
 ### System variables 
 
diff --git a/docs/pages/bash/bash-7-commands.md b/docs/pages/bash/bash-7-commands.md
index 9308aeb..6850102 100644
--- a/docs/pages/bash/bash-7-commands.md
+++ b/docs/pages/bash/bash-7-commands.md
@@ -28,51 +28,111 @@ command [ -option ] [ arguments ]
   * **Option** only modify the behavior of the command. It starts with `-` (or `--` for long option)
   * **Argument** controls the output of the command. It specifies a target for the command.
 
+It is possible to save the output of a command in a variable:  
+
+```bash
+var=$(command)
+```
+
+## String Commands Together
+
 It is possible to execute several commands in one line using **;** in between commands:  
 
 ```bash
 command1 ; command2
 ```
 
-It is possible to save the output of a command in a variable:  
+It is possible to send the output (STDOUT) of a command as input (STDIN) of another using `|` :  
 
 ```bash
-var=$(command)
+command1 | command2
 ```
 
-### Input/Output of commmands
+
+## Input/Output of commmands
 
 Commands can take different arguments:
 
-** Nothing **  
+### Nothing 
 ```bash
 ls
 ```
 
-** String **  
+### String
 ```bash
 echo hello world
 ```
 
-** File **  
+### File
 ```bash
 cat file_input
 ```
 
-** A stream **  
-What is a stream?
-    explanation here
+### A stream
+
+In Bash, a stream is a flow of data used for input and output operations. Streams allow data to be read from or written to files, commands, or devices.  
+Streams are essential for scripting, allowing flexible input/output handling and error management.
 
+Here an example:  
 ```bash
-cat file_input | tr a-z A-Z
+echo "Papa" | tr Pp Mm
 ```
 
-It is possible to send the output (STDOUT) of a command as input (STDIN) of another using **|**:  
+Bash primarily deals with three standard streams:
+
+#### Standard Input (stdin) – File Descriptor 0
 
+It is used to take input (e.g., from the keyboard or a file).
+
+To read user input from keyboard:  
 ```bash
-command1 | command2
+read var
+```
+
+To read input from a file:  
+```bash
+command < input.txt
+```
+
+#### Standard Output (stdout) – File Descriptor 1
+
+It is used to display _normal_ command output.  
+When you do `echo "Hello"` the ouput is written to stdout.  
+Stdout can be redirected to a file using `>` or another command using `|`.
+
+```bash
+command > output.txt # redirection to a file
+command1 | command2 # redirection to the next command
+```
+
+#### Standard Error (stderr) – File Descriptor 2
+
+It is used for error messages and diagnostics.
+
+```bash
+ls nonexistentfile
+```
+
+By default, the terminal (stdout) displays both file descriptor 1 (stdout) and file descriptor 2 (stderr).  
+You can redirect specificaly `stderr` in a dedicated file using the file descriptor 2:
+
+```bash
+# test1
+ls nonexistentfile 2> error.log
+# test2
+ls . nonexistentfile 2> error.log
+# test3
+ls . nonexistentfile > output.txt 2> error.txt
 ```
 
+###  Commands specificities
+
+/!\\ commmands that take an input either from a **file** of from **STDIN**: grep, sed, cat, head, sort, wc, etc.  
+/!\\ commmands that **never read STDIN**: ls, cp, mv, date, who, pwd, echo, cd, etc.  
+/!\\ commmands that **read only STDIN**: tr
+
+## Saving output
+
 It is possible to save/send the output of a command in a file:  
 ```bash
 # overwrite file if already exists
@@ -81,9 +141,10 @@ command > file
 command >> file
 ```
 
-/!\\ commmands that take an input either from a **file** of from **STDIN**: grep, sed, cat, head, sort, wc, etc.  
-/!\\ commmands that **never read STDIN**: ls, cp, mv, date, who, pwd, echo, cd, etc.
-/!\\ commmands that **read only STDIN**: tr
-
+!!! Success "Quick recap"
+    In this section we've learned:
 
-### Command pipes
+    - how commands work
+    - how to string commands together
+    - how to deal with input/output of commands
+    - the different file descriptors (stdout, stdin, stderr)
\ No newline at end of file
diff --git a/docs/pages/bash/bash-8-loops.md b/docs/pages/bash/bash-8-loops.md
deleted file mode 100644
index d31a16a..0000000
--- a/docs/pages/bash/bash-8-loops.md
+++ /dev/null
@@ -1 +0,0 @@
-# Loops
\ No newline at end of file
diff --git a/docs/pages/bash/bash-9-scripting.md b/docs/pages/bash/bash-9-scripting.md
deleted file mode 100644
index f201f5b..0000000
--- a/docs/pages/bash/bash-9-scripting.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# Scripting
-
-
-
-## Comment
-
-In bash, everything after the `#` special character is a comment and will be skipped.
-You can check it by yourself:
-
-```bash
-echo # hello my command ls ; cd 
-```
-
-When it will come the time to write scripts, you will have to use it extensively to comment your code...
\ No newline at end of file
diff --git a/docs/pages/bash_file/bash-extracting_from_files.md b/docs/pages/bash_file/bash-extracting_from_files.md
new file mode 100644
index 0000000..842323c
--- /dev/null
+++ b/docs/pages/bash_file/bash-extracting_from_files.md
@@ -0,0 +1,196 @@
+# Extracting from files
+
+To do this exercice you will need to download Frech First name data from "Institut national de la statistique
+et des études économiques"
+
+```bash
+wget https://www.insee.fr/fr/statistiques/fichier/2540004/nat2021_csv.zip
+unzip nat2021_csv.zip 
+```
+
+You should now have a file called `nat2021.csv` in your working directory.
+
+## Displaying sample (head, tail)
+
+When you have a huge dataset, it can be interesting to only display the beginning or the end of the file, to have an idea of how the file is structured.
+Using commands `head` and `tail` allows to do this tasks.
+
+!!! question "Display the first 20 lines of `nat2021.csv` file"
+
+??? example "Click to show the solution"  
+    ```bash
+    head -n 20 nat2021.csv
+    ```
+
+!!! question "Display the last 10 lines of `nat2021.csv` file"
+
+??? example "Click to show the solution"  
+    ```bash
+    tail -n 10 nat2021.csv
+    ```
+
+## Counting words/lines (wc)
+
+!!! question "Count the number of characters of `nat2021.csv` file"
+
+??? example "Click to show the solution"  
+    ```bash
+    wc -c nat2021.csv
+    ```
+
+!!! question "Count the number of line of `nat2021.csv` file"
+
+??? example "Click to show the solution"  
+    ```bash
+    wc -l nat2021.csv
+    ```
+
+## Searching patterns (grep)
+
+!!! question "Select all line related of the year 2001 in `nat2021.csv` file"
+
+??? example "Click to show the solution"  
+    ```bash
+    grep ";2021;" nat2021.csv
+    ```
+
+!!! question "How many names have been provided in 2021?"
+
+??? example "Click to show the solution"  
+    ```bash
+    grep ";2021;" nat2021.csv | wc -l
+    # result: 13501
+    ```
+
+!!! question "Is there more diversity in male or female names in 2021"?
+
+??? example "Click to show the solution"  
+    ```bash
+    # female
+    grep ";2021;" nat2021.csv | grep "^2" | wc -l
+    # result: 7112
+    # male
+    grep ";2021;" nat2021.csv | grep "^1" | wc -l
+    # result: 6389
+    ```
+
+!!! question "How many person are called PARIS in 2021"?
+
+??? example "Click to show the solution"  
+    ```bash
+    # female
+    grep "PARIS;2021;" nat2021.csv
+    # result 16 (5 male and 11 female)
+    ```
+
+The rare name ([see here for documentation](https://www.insee.fr/fr/statistiques/2540004?sommaire=4767262#documentation)) are set as `_PRENOMS_RARES`.
+
+!!! question "Could you find all rare name ? Do you see any pattern?"
+
+??? example "Click to show the solution"  
+    ```bash
+    grep ";_PRENOMS_RARES;" nat2021.csv
+    ```
+    People tends to provide more and more rare names.
+
+
+## Sorting a tabular file (sort)
+
+It is possible to sort a file or tabulated output using the `sort` command:
+
+```bash
+sort nat2021.csv | head
+```
+
+Sort is particularly useful when you use some key options:  
+
+ * `-n` to sort numerically  
+ * `-t` to specify a separator (the default separator is a space or a tab)  
+ * `-k` to specify on which column you want to sort the lines (use together with `-t`)  
+
+Try the numerical sort. 
+
+```bash
+sort -n nat2021.csv | head
+```
+
+!!! question "Do you observe any difference?"
+
+
+!!! question "What year and what name has been the most provided among the records?"
+
+??? example "Click to show the solution"  
+    ```bash
+    # command
+    sort -n -t ';' -k4  nat2021.csv
+    # result: JEAN
+    ```
+
+!!! question "What year was the most prolific fot the name ZINEDINE?"
+
+??? example "Click to show the solution"  
+    ```bash
+    # command
+    grep ";ZINEDINE;" nat2021.csv | sort -n -t ';' -k4
+    # result: 1998
+    ```
+
+## Extracting columns (cut)
+
+The `cut` command allows to cut a line at a specific character and extract a selected field: `cut -d";" -f 2`  
+
+ * `-d` specify the separator  
+ * `-f` specify the field to extract   
+
+!!! question "How to extract the name of the top 100 names/year the most provided"
+
+??? example "Click to show the solution"  
+    ```bash
+    # command
+    sort -n -t ';' -k4  nat2021.csv | tail -n 100 | cut -d";" -f 2
+    ```
+
+The `uniq` command can be used to remove the redundancy. But result need to be sorted to make it work properly/
+
+!!! question "Could you now find a way to filter the redundancy"
+
+??? example "Click to show the solution"  
+    ```bash
+    # command
+    sort -n -t ';' -k4  nat2021.csv | tail -n 100 | cut -d";" -f 2 | sort | uniq
+    ```
+
+!!! question "How many time the name JEAN has been provided in total?"
+
+??? example "Click to show the solution"  
+    It start to be too complicated for the command you have seen so far, you need to use a command specific to column data `awk`
+
+
+## Redirecting an output (>)
+
+You can redirect a result and store it in a file thanks to the `>` redirection:  
+`command > filename`
+
+!!! question "Save all the names from 2005 in a dedicated file?"
+
+??? example "Click to show the solution"  
+    ```bash
+    # command
+    grep ";2025;" nat2021.csv > names2005.txt
+    ```
+
+
+## Filtering a file (awk)
+
+
+
+## Replacing patterns (sed)
+
+
+
+## Combining commands (| && ;)
+
+
+
+
+
diff --git a/docs/pages/bash_script/bash_script-1-intro.md b/docs/pages/bash_script/bash_script-1-intro.md
new file mode 100644
index 0000000..966a60c
--- /dev/null
+++ b/docs/pages/bash_script/bash_script-1-intro.md
@@ -0,0 +1,127 @@
+# Scripting
+
+In this section, we will learn how to write scripts in Bash, allowing us to automate tasks and create powerful command-line programs.
+
+## What is a script?
+
+* A Bash script is a text file containing a sequence of commands.  
+* It automates tasks that you would normally run manually in the terminal.  
+* It is interpreted, not compiled, meaning Bash reads and executes it line by line.  
+* Used for system administration, automation, and data processing in Unix/Linux environments.
+
+
+## Script skeleton
+
+The first step is to **create a file** e.g. `script.sh` using the editor of your choice (vscode,sublime,gedit,etc) or by command line (vi,vim,nano,emacs,etc).  
+
+A good practice is to use suffix `.sh` to tell yourself that this file contain ba**sh** code.
+
+
+### shebang
+
+The good practice is to use a shebang.  
+A **shebang** (#!) is the first line of a file specifying the interpreter to use to translate the code into machine instructions.  
+
+If you read a german text and interpret is as english it does not make any sense... it is the same in programmation!  
+Here we will program in **bash**, so we must tell the machine that the code contained in our file has to be read in bash!  
+
+How to do so? We add as the first line of your file a shebang with the path to the interpreter:
+```bash
+#!/bin/bash
+```
+
+!!! note
+    With a shebang, you can execute the script directly (if it has execution permissions) using `./script.sh`.  
+    Without a shebang, you must specify the interpreter explicitly when running the script: `bash script.sh`.
+
+
+### Executable
+
+A good practice is to provide the execute permissions to that file running:
+
+```bash
+chmod +x script.sh
+```
+
+!!! note
+    check permission before and after using `ls -l script.sh` to observe the difference.
+
+Here you go, you can now execute your file calling its name `./script.sh` (if in the current directory).  
+
+### Code
+
+Your script can contain commands, variables, loops, conditions, and functions to create complex workflows.  
+
+Add a command in your file
+```bash
+#!/bin/bash
+
+echo hello
+```
+
+and execute it `./script.sh`
+
+```bash
+$ coucou
+```
+
+Here it is you have written and executer your first script!
+
+### Comment
+
+Anywhere in your code you can add comment.
+Comment start by `#`. The only excpetion to this rule is the shebang.
+
+Comments are essential for making your script readable and understandable by others (or even your future self). They provide explanations about the code’s purpose and functionality, making maintenance and debugging easier.
+
+```bash
+#!/bin/bash
+
+# This is a comment
+echo hello
+```
+
+### Exit
+
+The `exit`command allows the program to quit prematurely.
+
+```bash
+#!/bin/bash
+
+# stop here
+exit
+
+# This is a comment
+echo hello # <= this will never be executed
+```
+
+In Bash, exit codes (also known as return codes or status codes) indicate the success or failure of a command or script.  
+The best practice is to define an exit code to inform users or other scripts of how things have gone.  
+Here are some common exit codes:  
+
+| exit code | explanation |
+|----------|----------|
+| 0 | Success (no error).
+| 1 | General error (catch-all for miscellaneous errors).
+| 2 | Incorrect usage (misuse of built-in shell commands).
+| 126 | Command invoked cannot be executed (e.g., permission issue).
+| 127 | Command not found.
+| 128 | Invalid argument to exit.
+| 130 | Script terminated by Ctrl+C (SIGINT).
+| 137 | Process killed (usually by kill -9, SIGKILL).
+| 139 | Segmentation fault.
+| 143 | Process terminated by SIGTERM (default termination signal).
+| 255 | Exit status out of range (must be between 0 and 255).
+
+
+!!! Note 
+    Each command in Bash returns an exit code, which can be accessed using `$?`
+
+!!! Success "Quick recap"
+    In this section we've learned:
+
+    - What is a script
+    - The good practices to write and execute a script:  
+            - the use of shebang  
+            - make script executable  
+            - executing it using `./script.sh`  
diff --git a/docs/pages/bash_script/bash_script-2-data_structure.md b/docs/pages/bash_script/bash_script-2-data_structure.md
new file mode 100644
index 0000000..b528775
--- /dev/null
+++ b/docs/pages/bash_script/bash_script-2-data_structure.md
@@ -0,0 +1,183 @@
+# Data Structures
+
+In this section, we will learn 3 essential data structures concepts:
+
+* Variables store single values, such as numbers, text, or other values. 
+* Lists (or arrays) store ordered collections of values, allowing access by index. They help manage multiple values efficiently.
+* Dictionaries (or hashmaps) store key-value pairs, allowing data to be retrieved using meaningful keys instead of numerical indices, making lookups more intuitive.
+
+## Variable
+
+### Basics
+{%
+    include-markdown "../bash/bash-2-the-basics.md"
+    start="<!--variables-start-->"
+    end="<!--variables-end-->"
+%}
+
+### Using Variables
+
+
+| command | explanation |
+|----------|----------|
+| **variable=value** | Assign a value `value` to the variable `variable`. (The variable scipe is restricted to the shell/script) |
+| **local variable=value** | Assign a value `value` to the variable `variable`. (It does not come out a curly bracket area) |
+| **export varialbe=value** | Make the variable `variable` available to the shell abd syb-proessses |
+| **variable=$(command)** | Assign the output of `command` to `variable`|
+| **{% raw %}${#variable}{% endraw %}** | Length of the value contained by the variable |
+| **${variable:N}** | Kepp the character of the value contained by `variable` after the Nth. |
+| **$variable:N:length** | Substring the value contained by `variable` from tje Nth chracter up to the `length` specified |
+| **${variable/pattern/string}** | Match of `pattern` in `variable` value is replaced with `string` |
+
+
+## List (Indexed Array)
+
+Lists (or arrays) store ordered collections of values, allowing access by index. They help manage multiple values efficiently.
+
+
+### create - initialize
+
+This is not mandatory but it is a good practice to create and/or initialize an array!
+
+```bash
+declare -a myarray
+```
+This will declare an array called `myarray`, but it is not initialized.  
+
+```bash
+myarray=()
+```
+This will declare an array called `myarray` and initialize it as an empty array.
+
+```bash
+myarray=(apple banana "cherry cake")
+```
+This `myarray` array is initialized with three values.
+
+### append
+
+In Bash, you can add a value to an array using the following syntax:
+
+```bash
+myarray+=("kiwi")
+```
+
+### access
+
+To check the size of your array (print the last index):
+
+{% raw %}```python
+echo ${#myarray[@]}
+```{% endraw %}
+
+To print all array index key :
+
+{% raw %}```python
+echo ${!myarray[@]}
+```{% endraw %}
+
+**/!\ Index start at 0.**
+
+To print the value stored in index 1 :  
+```bash
+echo ${myarray[1]}
+```
+
+
+To print all values stored in an array :
+
+{% raw %}```bash
+echo ${myarray[@]}
+```{% endraw %}
+
+### remove
+
+To remove element at index 1 from the array:
+{% raw %}```bash
+unset -v myarray[1]
+```{% endraw %}
+
+To remove the whole array:
+{% raw %}```bash
+unset -v myarray
+```{% endraw %}
+
+## Dictionary (Associative array)
+
+Associative arrays were introduced in Bash 4.0, which was released in 2009.
+It significantly increases the flexibility of working with arrays in Bash scripts, but keep in mind it is slow.
+Avoid big associative array, and use it by parsimony.
+
+### create - initialize
+
+To use an associative array you **must** declare it first!  
+Then initialize with value is not mandatory.
+
+```bash
+declare -A myAArray
+```
+
+```bash
+myAArray["name"]="John"
+```
+This `myAArray` array is initialized with 1 values.
+
+```bash
+myAArray=([fruit]=apple [cake]="Paris brest")
+```
+This `myAArray` array is initialized with 2 values. Note the parenthesis!
+
+### append
+
+In Bash, you can add a value to an associative array using the following syntax :
+
+```bash
+myAArray["name"]="John"
+```
+
+### access
+
+To check the number of value/key in your associative array :
+
+{% raw %}```bash
+echo ${#myAArray[@]}
+```{% endraw %}
+
+To print all associative array keys :
+
+{% raw %}```bash
+echo ${!myAArray[@]}
+```{% endraw %}
+
+To print the value associated to a specific key (e.g. cake) :
+
+{% raw %}```bash
+echo "${myAArray[cake]}"
+```{% endraw %}
+
+To print all values stored in an associated array :
+
+{% raw %}```bash
+echo ${myAArray[@]}
+```{% endraw %}
+
+### remove
+
+To remove a specific key-value pair the associative array:
+
+```bash
+unset -v myAArray[cake]
+```
+
+To remove the whole associative array:
+
+```bash
+unset -v myAArray
+```
+
+!!! Success "Quick recap"
+    In this section we've learned:
+
+    - What is variable
+    - What is an array (think as list)
+    - What is an associative array (think as dictionnary)
\ No newline at end of file
diff --git a/docs/pages/bash_script/bash_script-3-conditional.md b/docs/pages/bash_script/bash_script-3-conditional.md
new file mode 100644
index 0000000..d5a865d
--- /dev/null
+++ b/docs/pages/bash_script/bash_script-3-conditional.md
@@ -0,0 +1,194 @@
+# Conditionals
+
+Conditionals allow you to determine whether or not to execute a specific action based on the evaluation of an expression.
+
+## if statement
+
+### Forms
+
+#### if 
+
+```bash
+if expression; then
+
+    code if 'expression' is true.
+
+fi
+```
+
+#### if..else statement
+
+```bash
+if expression; then
+
+    code if 'expression' is true.
+else
+    code if 'expression' is false.
+fi
+```
+
+#### if..elif..else statement
+
+```bash
+if expression1; then
+    code if 'expression1' is true.
+elif expression2; then
+    code if 'expression2' is true.
+else
+    code if 'expression1' AND  'expression2' are false.
+fi
+```
+
+### Expression
+
+In Bash, there are two ways to use conditional expressions: `[ expression ]` and `[[ expression ]]`. While they may seem similar, there are some important differences between them.
+
+#### [ expression ] 
+
+Legacy: This is the older, POSIX-compliant test command that works in many shells, not just Bash.  
+It has limited functionality. It lacks advanced features found in `[[ expression ]]`.  
+If you need your script to work across different shells (e.g., Dash, POSIX shell), you should stick with [ ].
+
+#### [[ expression ]]
+
+You should prioritize the use of this form in bash. It’s more flexible, safer, and easier to read and write.
+
+* String matching: It supports pattern matching with == and != (using *, ?, etc.).
+* Logical operators: You can use && (AND) and || (OR) operators, making it easier to read and use.
+* Regular Expressions: It supports regex with =~ for regular expression matching.
+
+### Test and comparison operators
+
+#### File tests
+
+```bash
+-f file1  # True if file file1 exists
+-d dir1   # True if directory dir1 exists
+
+file1 -nf file2 # True if file1 is newer than file2, or if file1exists and file2 does not
+file1 -ot file2 # True if file1 is older than file2, or if file2 exists and file1 does not
+```
+
+#### String 
+
+##### String comparison
+
+```bash
+string1 == string2  # True if string1 and string are equal
+string1 != string2  # True if string1 and string are different
+string1 =~ regularExpression # True if string1 match the pattern of the regular expression
+```
+
+##### String test
+
+```bash
+-z string # True if string is empty
+-n string # True if string is non-empty
+```
+
+#### Integer comparison 
+
+##### [[ int1 operator int2 ]]
+
+```bash
+int1 -eq int2 # True if int1 is equal to int2
+int1 -ne int2 # True if int1 is not equal to int2
+int1 -lt int2 # True if int1 is less than to int2
+int1 -le int2 # True if int1 is less than or equal to int2
+int1 -gt int2 # True if int1 is greater than to int2
+int1 -ge int2 # True if int1 is greater than or equal to int2
+```
+
+##### (( int1 operator int2 ))
+
+Double parenthesis is used specifically for numeric operations.
+
+```bash
+int1 == int2 # True if int1 is equal to int2
+int1 != int2 # True if int1 is not equal to int2
+int1 < int2 # True if int1 is less than to int2
+int1 <= int2 # True if int1 is less than or equal to int2
+int1 > int2 # True if int1 is greater than to int2
+int1 >= int2 # True if int1 is greater than or equal to int2
+```
+
+##### [[ ... ]] vs (( ... ))
+
+| Feature | [[ ... ]] | (( ... )) |
+|----------|----------|----------|
+| Used for | Strings & Integers|Only Integers|
+|Operators|-eq, -ne, -lt, -le, -gt, -ge|==, !=, <, <=, >, >=|
+|Variable $ needed|Yes|No|
+|Supports Arithmetic|No|Yes|
+|Faster for math?|No|Yes|
+
+### Logical operators
+
+Logical operators in Bash are used to combine multiple conditions.
+
+#### NOT (!)
+
+`!` negates a condition. Example:
+
+```bash
+if [ ! -d myfolder ]; then
+    echo "Directory does not exist"
+fi
+```
+
+#### AND (&&)
+
+Check if both conditions are true.
+
+```bash
+if [[ -f file.txt && -r file.txt ]]; then
+    echo "File exists and is readable"
+fi
+```
+
+#### OR (||)
+
+Check if one of the conditions is true.
+
+```bash
+if [[ ! -f file.txt || ! -r file.txt ]]; then
+    echo "File does not exist or is not readable."
+fi
+```
+
+In this example we used the negation `!` and the `||` logical operators.
+
+## case statement
+
+The Bash case statement is a powerful tool for simplifying complex conditionals, especially when handling multiple choices. It provides a cleaner and more readable alternative to nested if statements, making scripts easier to maintain. A common use case is processing arguments passed to a script.
+
+```bash
+case $variable in
+
+    pattern_1)
+        command1
+        ;;
+    pattern_2|pattern_3|pattern_4)
+        command2
+        ;;
+    pattern_N)
+        commandN
+        ;;
+    *)
+        commands
+        ;;
+esac
+```
+
+A common practice is to use the wildcard asterisk (*) as the final pattern in a case statement, ensuring a default case that matches any input.
+
+
+!!! Success "Quick recap"
+    In this section we've learned:
+
+    - The if, elif and else statements
+    - difference between [ ... ] [[ ... ]] (( ... )) expression structure
+    - File test operator
+    - String and integer comparison operators
+    - Logical operators
+    - The case statement
\ No newline at end of file
diff --git a/docs/pages/bash_script/bash_script-4-loop.md b/docs/pages/bash_script/bash_script-4-loop.md
new file mode 100644
index 0000000..6713147
--- /dev/null
+++ b/docs/pages/bash_script/bash_script-4-loop.md
@@ -0,0 +1,150 @@
+# The Loops
+
+Loops in Bash allow you to repeat a set of commands multiple times. Bash provides three main types of loops: For, While and Until.
+
+
+## The different loops
+
+### For
+
+A for loop iterates over a list of items or a sequence of numbers.
+
+* Looping over a list
+
+```
+#!/bin/bash
+for name in Peter Paul Jack; do
+    echo "Hello, $name!"
+done
+```
+
+* Looping over a list of items - the case of associative array
+
+```
+#!/bin/bash
+for key in ${!myAArray[@]} ; do
+    echo "key: $key"
+    echo "value: ${myAArray[$key]}"
+done
+```
+
+*  Looping over a range of numbers
+
+```
+#!/bin/bash
+for i in {1..5}; do
+    echo "Iteration $i"
+done
+```
+
+*  Looping over a range of numbers using C-style approach
+
+```
+#!/bin/bash
+for (( i=1 ; i<=5 ; i++ )); do
+    echo "Iteration $i"
+done
+```
+
+### While
+
+A while loop executes commands as long as a condition is true.
+
+```bash
+#!/bin/bash
+count=1
+while (( $count <= 5 )); do
+    echo "Count: $count"
+    ((count++))  # Increment the count
+done
+```
+
+### Until
+
+An until loop is the opposite of while: it runs until the condition is true
+
+```bash
+#!/bin/bash
+count=1
+until (( $count > 5 )); do
+    echo "Count: $count"
+    ((count++))  # Increment the count
+done
+```
+
+## Real cases
+
+### Looping Through Files
+
+A common use case in Bash is iterating over files in a directory. 
+
+```bash
+#!/bin/bash
+for file in *.txt; do
+    echo "Processing $file"
+done
+```
+
+This will list all `.txt` file in the current directory.
+
+### Looping over a command's result
+
+Using `$(command)` you can execute first run a command and provide its output to a list to iterate through.
+
+```bash
+#!/bin/bash
+for file in $(ls); do
+    echo "Processing $file"
+done
+```
+
+!!! note
+    By default the internal field separator (IFS) is the space. So to iterate through line that contains spaces you should set the `IFS` to carriage return: `IFS=$'\n'`.
+    Try the command above before and after to see the difference.
+
+### Looping through lines of a file
+
+Set the internal field separator to new line separator `IFS=$'\n'`, then you can use on of this approach:
+
+```bash
+for line in $(cat file.txt);do
+    code # $line will be the variable that contains the line
+done
+```
+or 
+
+```bash
+while read line;do
+    code # $line will be the variable that contains the line
+done < file
+```
+
+## Breaking and Skipping in Loops
+
+### break
+
+The `break` command will exit the loop entirely
+
+```bash
+#!/bin/bash
+for i in {1..5}; do
+    if [[ $i -eq 3 ]]; then
+        break
+    fi
+    echo "Processing $i"
+done
+```bash
+
+### continue
+
+The `continue` command will skip the current iteration and move to the next.
+
+```bash
+#!/bin/bash
+for i in {1..5}; do
+    if [[ $i -eq 3 ]]; then
+        continue
+    fi
+    echo "Processing $i"
+done
+```bash
\ No newline at end of file
diff --git a/docs/pages/bash_script/bash_script-5-argument.md b/docs/pages/bash_script/bash_script-5-argument.md
new file mode 100644
index 0000000..eb595ba
--- /dev/null
+++ b/docs/pages/bash_script/bash_script-5-argument.md
@@ -0,0 +1,243 @@
+# Argument
+
+## Accessing Arguments
+
+When you run a Bash script, you can pass arguments to it from the command line. These arguments can be accessed inside the script using special variables.  
+Bash automatically assigns numbers to each argument:
+
+* $0 - The script name
+* $1 - First argument
+* $2 - Second argument
+
+
+Let’s explore an example of basic argument handling.  
+Write this into `script.sh` :
+
+```
+#!/bin/bash
+echo "Script name: $0"
+echo "First argument: $1"
+echo "Second argument: $2"
+```
+and execute it:
+
+```bash
+./script.sh apple macaron
+```
+
+??? example "Click to show the solution"
+    ```bash
+    Script name: ./script.sh
+    First argument: apple
+    Second argument: macaron
+    ```
+
+## Checking if an Argument is Provided
+
+Before using an argument, it’s a good practice to check if it’s set.
+
+```bash
+#!/bin/bash
+if [[ -z "$1" ]]; then
+    echo "Error: No argument provided!"
+    exit 1
+fi
+
+echo "Argument received: $1"
+```
+
+and execute it:
+
+```bash
+./script.sh
+```
+
+??? example "Click to show the solution"
+    ```bash
+    Error: No argument provided!
+    ```
+
+## Handling Multiple Arguments
+
+You can use `$@` and `$#` to manage multiple arguments:
+	
+* $@ - All arguments as separate words
+* $* - All arguments as a single string
+* $# - Number of arguments provided
+
+Let’s explore an example of looping through arguments.  
+Write this into `script.sh` :
+
+```bash
+#!/bin/bash
+echo "You provided $# arguments:"
+for arg in "$@"; do
+    echo "- $arg"
+done
+```
+
+and execute it:
+
+```bash
+./script.sh apple macaron
+```
+
+??? example "Click to show the solution"
+    ```bash
+    You provided 2 arguments:
+    - apple
+    - macaron
+    ```
+
+## Named Arguments with Flags
+
+To handle named arguments, use a `case` statement.
+
+Let’s explore an example of parsing flags.  
+Write this into `script.sh` :
+
+```bash
+#!/bin/bash
+
+# Parse arguments using case
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -f|--fruit)
+            fruit="$2"
+            shift 2 ;;  # remove flag & value
+        -c|--cake)
+            cake="$2"
+            shift 2 ;;  # remove flag & value
+        *)
+            echo "Unknown option: $1"
+            exit 1 ;;
+    esac
+done
+
+echo "Fruit: $fruit"
+echo "Cake: $cake"
+```
+
+and execute it:
+
+```bash
+./script.sh --fruit apple --cake macaron
+```
+
+??? example "Click to show the solution"
+    ```bash
+    Fruit: apple
+    Cake: macaron
+    ```
+
+## Full Example
+
+Below is a complete Bash script demonstrating how to handle arguments using a case statement. 
+
+* It handle Named Arguments with Flags
+* It validates arguments (one is an integer the other one a string)
+* It checks all arguments are provided
+* It provides a help
+
+
+```bash
+#!/bin/bash
+
+# Initialize variables
+num=""
+text=""
+
+# Parse arguments using case
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        -n)  # Handle number argument
+            
+            if [[ "$2" =~ ^[0-9]+$ ]]; then
+                num="$2"
+            else
+                echo "Error: -n requires an integer." >&2
+                exit 1
+            fi
+            shift 2
+            ;;
+        -s)  # Handle string argument
+            if [[ -n "$2" ]]; then
+                text="$2"
+            else
+                echo "Error: -s requires a string." >&2
+                exit 1
+            fi
+            shift 2
+            ;;
+        -h|--help)  # Handle help option
+            echo "This script perform ...explanation here..."
+            echo "Usage: $0 -n <integer> -s <string>"
+            echo
+            echo "Options:"
+            echo "  -n <integer>  Provide an integer value."
+            echo "  -s <string>   Provide a string value."
+            echo "  -h, --help    Show this help message and exit."
+            exit 0
+            ;;
+        *)  # Handle unknown options
+            echo "Error: Unknown option $1" >&2
+            echo "Usage: $0 -n <integer> -s <string>"
+            ;;
+    esac
+done
+
+# Check if required arguments are provided
+if [[ -z "$num" || -z "$text" ]]; then
+    echo "Error: Both -n <integer> and -s <string> are required." >&2
+    show_help
+fi
+
+# Output the received values
+echo "Integer provided: $num"
+echo "String provided: $text"
+```
+
+Now try with several conditions:
+
+```bash
+./script.sh -n 42 -s "macaron"
+```
+
+??? example "Click to show the solution"
+    ```bash
+    Integer provided: 12
+    String provided: macaron  
+    ```
+
+
+```bash
+./script.sh -n apple -s macaron
+```
+
+??? example "Click to show the solution"
+    ```bash
+    Error: -n requires an integer.
+    ```
+
+
+```bash
+./script.sh --help
+```
+
+??? example "Click to show the solution"
+    ```bash
+    Usage: ./script.sh -n <integer> -s <string>
+
+    Options:
+    -n <integer>  Provide an integer value.
+    -s <string>   Provide a string value.
+    -h, --help    Show this help message and exit.
+    ```
+
+!!! Success "Quick recap"
+    In this section we've learned:
+
+    - How to access arguments within a script
+    - How to use named arguments
+    - How to check provided arguments
+
diff --git a/docs/pages/bash_script/bash_script-6-function.md b/docs/pages/bash_script/bash_script-6-function.md
new file mode 100644
index 0000000..f7a1ff4
--- /dev/null
+++ b/docs/pages/bash_script/bash_script-6-function.md
@@ -0,0 +1,179 @@
+# Functions
+
+In Bash, functions allow you to reuse code and improve readability. 
+Below is an example how to define and use functions in Bash.
+
+## Defining a Function
+
+```bash
+function eat_food() {
+    # Commands go here
+    echo "I love food"
+}
+```
+
+## Calling a Function
+
+```bash
+# Call the function
+eat_food
+```
+
+??? example "Click to show the solution"
+    ```bash
+    $ I love food
+    ```
+
+## Using Arguments in Functions
+
+Functions can take arguments, accessed as $1, $2, $3, etc.
+
+```bash
+#!/bin/bash
+
+# defining a function
+function eat_food() {
+
+    # get arguments
+    food=$1
+    # Commands go here
+    echo "I love $food"
+}
+
+# calling a function
+eat_food macaron
+```
+
+macaron is the argument here.
+
+??? example "Click to show the solution"
+    ```bash
+    $ I love macaron
+    ```
+
+## Arguments with Default Values
+
+It is possible to provide default value if when no argument is provided.
+
+```bash
+#!/bin/bash
+
+# defining a function
+function eat_food() {
+
+    # get arguments
+    food=${1:-"millefeuille"}
+    # Commands go here
+    echo "I love $food"
+}
+
+# calling a function
+eat_food macaron
+```
+
+??? example "Click to show the solution"
+    ```bash
+    $ I love macaron
+    ```
+
+## Capturing Function Output
+
+Bash functions cannot return strings directly, but they can:
+
+* Return an exit status (integer) using `return`
+* Output a string using `echo`, which can be captured.
+
+### Status Code
+
+Here an example on how to deal with status code returned from a function.
+This piece of code determines whether the provided food name has an even or odd number of characters.
+
+{% raw %}
+```bash
+#!/bin/bash
+
+# defining a function
+function eat_food() {
+
+    # get arguments
+    food=${1:-"millefeuille"}
+    if (( ${#food} % 2 == 0 )); then # ${#food} is the length of the string
+        return 0  # Success
+    else
+        return 1  # Failure
+    fi
+
+}
+
+# calling a function
+if eat_food $1; then
+    echo "Even"
+else
+    echo "Odd"
+fi
+```
+{% endraw %}
+
+!!! note
+    The reason we don’t need `[[ ... ]]` when checking a function’s exit status (return code) in an if statement is because `if` in Bash directly evaluates the exit status of a command or function.  
+    The calling can be shrotened as `check_even 4 && echo "Even" || echo "Odd"`
+
+### String
+
+To store function output in a variable you must use the command substitution `$(...)`.
+
+
+```bash
+#!/bin/bash
+
+# defining a function
+function eat_food() {
+
+    # get arguments
+    food=${1:-"millefeuille"}
+    # Commands go here
+    echo "I love $food"
+}
+
+# calling a function and storing it in a variable
+result=$(eat_food $1)
+
+# printing the result
+echo "$result"
+```
+
+## Global vs Local Variables
+
+By default, variables inside functions are global, that means they are available from everywhere in the code. 
+You can create a local variable (available only within the function) usin `local`.
+
+```bash
+#!/bin/bash
+
+name="Global"
+
+set_name() {
+    local name="Local"
+    echo "Inside function: $name"
+}
+
+set_name
+echo "Outside function: $name"
+```
+
+??? example "Click to show the solution"
+    ```bash
+    Inside function: Local
+    Outside function: Global
+    ```
+
+
+!!! Success "Quick recap"
+    In this section we've learned:
+
+    - how to define a function
+    - how to call a function
+    - how to pass arguments
+    - how to return values (Status code and string)
+    - how to capture function output
+    - the difference between global and local variables
diff --git a/docs/pages/bash_script/bash_script-7-interface.md b/docs/pages/bash_script/bash_script-7-interface.md
new file mode 100644
index 0000000..a07c7be
--- /dev/null
+++ b/docs/pages/bash_script/bash_script-7-interface.md
@@ -0,0 +1,75 @@
+# User Interface 
+
+In Bash, user interaction is important for dynamic and flexible scripts.  
+Bash provides built-in commands like:
+
+* `read` - To take user input.
+* `select` - To create menus.
+
+
+## Read
+
+The Bash read command is a built-in utility that reads text from standard input
+
+```bash
+#!/bin/bash
+
+# first example
+echo "Enter your name:"
+read name
+echo "Hello, $name!"
+
+# second example
+read -p "Enter your age: " age
+echo "You are $age years old."
+```
+
+## Select
+
+The select command is great for interactive menus.
+
+Here with a case statement:  
+```bash
+#!/bin/bash
+
+#custom prompt for the select 
+echo "Choose a cake:"
+
+select cake in Eclair Macaron Millefeuille Quit
+do
+    case $cake in
+        Macaron) echo "You chose Macaron." ;;
+        Eclair) echo "You chose Eclair." ;;
+        Millefeuille) echo "You chose Millefeuille." ;;
+        Quit) echo "Exiting..."; break ;;
+        *) echo "Invalid option, try again." ;;
+    esac
+done
+```
+
+Explanation:  
+
+* The select loop automatically displays a numbered menu.
+* The user selects by typing a number (e.g., 1 for Apple).
+* Quit option allows exiting the menu.
+
+
+And with a if statements:  
+```bash
+#!/bin/bash
+
+#custom prompt for the select 
+PS3="Choose a cake:"
+
+select opt in Eclair Macaron Millefeuille Quit;do
+    if [[ $opt == "Eclair" ]];then
+        echo "You chose Eclair." ;
+    elif [[ $opt == "Macaron" ]];then
+        echo "You chose Macaron." ;
+    elif [[ $opt == "Millefeuille" ]];then
+        echo "You chose Millefeuille." ;
+    elif [[ $opt == "Quit" ]];then
+        echo "Exiting..."; break ;
+    fi
+done
+```
\ No newline at end of file
diff --git a/mkdocs.yml b/mkdocs.yml
index 3598e33..29a3919 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -1,5 +1,5 @@
 # Project information
-site_name: Unix basics training
+site_name: Unix / Bash training
 site_author: Jacques Dainat et al.
 site_url: https://mivegec.pages.ird.fr/dainat/malbec-unix-basics/
 site_description: Unix basics training
@@ -91,7 +91,7 @@ extra:
 
 # page tree
 nav:
-    - Linux basics:
+    - Unix basics:
         - Introduction: index.md
         - Setup: pages/course-information/setup.md
         - Introduction: pages/bash/bash-1-introduction.md
@@ -101,8 +101,17 @@ nav:
         - Special_characters: pages/bash/bash-5-special_characters.md
         - PATH: pages/bash/bash-6-path.md
         - Commands: pages/bash/bash-7-commands.md
-        - Conditional structure: pages/bash/bash-8-loops.md
-        - Scripting: pages/bash/bash-9-scripting.md
+    - Unix file manipulation:
+        - File manipulation: pages/bash_file/bash-extracting_from_files.md
+    - Bash scripting:
+        - Introduction: pages/bash_script/bash_script-1-intro.md
+        - Data structures: pages/bash_script/bash_script-2-data_structure.md
+        - Conditional structures: pages/bash_script/bash_script-3-conditional.md
+        - Loops: pages/bash_script/bash_script-4-loop.md
+        - Arguments: pages/bash_script/bash_script-5-argument.md
+        - Functions: pages/bash_script/bash_script-6-function.md
+        - User Interface: pages/bash_script/bash_script-7-interface.md
+      
     - Cheat sheet:
         - Bash Cheat sheet: pages/cheat_sheet/bash/bash.md
         - Interesting ressources: pages/cheat_sheet/interesting_ressources.md
-- 
GitLab