Fix review comments

- Addressing documentation issues reported in below .md files
  contribute.md
  get-source-code.md
  git-installation&configuration.md
  merge-request.md
  windows.md
- Change merge request workflow flow chart

Issue #9

docs/get-involved/build-environment/windows.md

@@ -19,14 +19,12 @@ The tools used are:
 ---
 
 ## Install Git
-- Download and Install the latest release of **Git**: [Download Git :octicons-link-external-16:](https://git-scm.com/download/win){:target="_blank"}
-- Enable the option to make **Git** available in *PATH*.
-- Leave the rest of the options to their defaults.
-
+- Download and Install the latest release of **Git**: [Download Git ![link icon](https://img.icons8.com/ios/16/000000/external-link.png)](https://git-scm.com/download/win)
+- Follow [Install and Configure Git](../../get-involved/git-installation&configuration.md) page for a detailed explanation of how to Install & Configure Git.
 ---
 
 ## Install Python
-- Download and install **Python**: [Download Python :octicons-link-external-16:](https://www.python.org/downloads/windows/){:target="_blank"}
+- Download and install **Python**:[Download Python ![link icon](https://img.icons8.com/ios/16/000000/external-link.png)](https://www.python.org/downloads/windows/){:target="_blank"}
 
 !!! warning
     Please install version  **3.11.8**, select all the default options and check the option to add Python to *PATH* & make sure to include the debug binaries!
@@ -96,19 +94,24 @@ The page should look something like this:
 ```{.sh .copy}
 git clone https://github.com/microsoft/vcpkg.git
 ```
-You can also copy the clone command from  [GitHub Page 🔗](https://github.com/microsoft/vcpkg)
 
 - Create the *vcpkg* executable by executing this command in the opened terminal:
 
-```{.cmd .copy}
-.\vcpkg\bootstrap-vcpkg.bat
-```
+=== "Windows"
 
-If you are using Git Bash , use this command
+    ``` { .cmd .copy }
+    C:\dev\vcpkg\vcpkg.exe install eigen3 boost cgal
+    ```
+
+    !!! note
+        This may take some time and you can install one package after the other.
+
+=== "MinGW"
+
+    ``` { .sh .copy }
+    pacman -S mingw-w64-ucrt-x86_64-eigen3 mingw-w64-ucrt-x86_64-boost mingw-w64-ucrt-x86_64-cgal
+    ```
 
-```{.cmd .copy}
-./vcpkg/bootstrap-vcpkg.bat
-``` 
 To check if the vcpkg is installed on your system, you can run the following command in your terminal or command prompt:
 
 ```{.cmd .copy}
@@ -147,10 +150,4 @@ Install it by executing the following command in a terminal after you have **suc
 
 ```{.sh .copy}
 pip install pipenv
-```
-
-### Install Git
-- Download and Install the latest release of **Git**: [Download Git :octicons-link-external-16:](https://git-scm.com/download/win){:target="_blank"}
-- Enable the option to make **Git** available in *PATH*.
-- Leave the rest of the options to their defaults.
-- Watch the [Git Installation & Configuration tutorial](../../assets/videos/Git_Installation&Configuration.mp4) video for a more detailed explanation on how to download and install Git on a Windows machine.
+```
\ No newline at end of file

docs/get-involved/contribute.md

@@ -17,13 +17,14 @@ Awesome! :sunglasses: Please make sure to read our *style guides* first:
 ## How to actually contribute
 
 This is how you can actually make a difference:
+The flowchart below illustrates the Merge Request workflow, along with the commands used at each stage.
 
-<figure markdown>
-  ![merge-request](../assets/images/merge-request.jpg){width="500"}
+<figure>
+  <img src="../assets/images/merge_request_workflow.png" alt="merge-request" width="500" style="border: 2px solid black;">
   <figcaption>Merge request workflow</figcaption>
 </figure>
 
-You cloned/forked the UNICADO Package successfully acc. to the `ReadMe`. Nice! You want to make a change, e.g. fixing a bug or creating a new feature, so you create a *issue* (see also [types of contribution](#contributions)). Then you :point_up: create a feature branch, change the code and create a merge request (here a [how to](merge-request.md)). An automatic CI/CD pipeline is triggered, which helps your selected reviewer to make sure that request is ok. If it is accepted and ready-to-land :airplane:, the documentation is automatically updated. Nicely done :+1:
+You cloned/forked the UNICADO Package successfully acc. to [Get Source Code](get-source-code.md). Nice! You want to make a change, e.g. fixing a bug or creating a new feature, so you create a *issue* (see also [types of contribution](#contributions)). Then you :point_up: create a feature branch, change the code and create a merge request (here a [how to](merge-request.md)). An automatic CI/CD pipeline is triggered, which helps your selected reviewer to make sure that request is ok. If it is accepted and ready-to-land :airplane:, the documentation is automatically updated. Nicely done :+1:
 
 ## Types of contribution {#contributions}
 
@@ -66,6 +67,6 @@ The issues should **not** be used as a *Q/A* forum.
 
 ---
 
-:heart: Thanks for reading this! We are looking forward to your contributions!
+❤️ Thanks for reading this! We are looking forward to your contributions!
 
 UNICADO Team

docs/get-involved/get-source-code.md

@@ -12,28 +12,86 @@ You can get an overview of which repository contains which topic [here](../docum
 Whenever one repository needs another repository, we include it as a *Git Submodule*.
 If you are not familiar with *Git Submodules*, please read their [Documentation :octicons-link-external-16:](https://git-scm.com/book/en/v2/Git-Tools-Submodules).
 
-## Clone the Unicado Package Repository and update its Submodules
+🎥 **Watch the first part of [Merge Request Workflow](../assets/videos/Merge_Request_Workflow.mp4) video for a more detailed explanation of below mentioned steps**.
 
-The repository [Unicado Package](https://git.rwth-aachen.de/unicado/unicado-package) contains all necessary source code as submodules to get started compiling **UNICADO** and its installer.. It is used to create UNICADO releases and provides a good starting point for development.
-To clone the repository and its submodules, navigate to the desired location on your local machine and run the following commands:
+## Step-by-Step Guide to Fork Unicado Package Repository on GitLab and update its submodules
 
->💡 Open your preferred IDE (e.g., Visual Studio Code). Ensure that Git is integrated within your IDE. Most IDEs, such as VSCode, have built-in Git integration.
+The repository [Unicado Package](https://git.rwth-aachen.de/unicado/unicado-package) contains all necessary source code as submodules to get started compiling **UNICADO** and its installer. It is used to create UNICADO releases and provides a good starting point for development. UNICADO project is hosted on GitLab platform. So you need to have a GitLab account if you want to fork the repsitory and start contributing to it.
 
-`git clone --recurse-submodules git@git.rwth-aachen.de:unicado/unicado-package.git`
+## **Step 1: Create a GitLab Account**
 
-This command will clone the repository to your local machine. To learn more about the structure of this repository, refer to [this guide](../developer/get-source-code.md).
+1. **Visit GitLab Website:**
+   - Open your browser and navigate to [GitLab](https://gitlab.com/).
 
->💡 Login to the UNICADO project on GitLab and copy the SSH clone command directly from there.
+2. **Sign Up:**
+   - Click on the **"Register"** button and fill in the required fields:
+     - Username
+     - Email Address
+     - Password
+   - Optionally, sign up using **Google** or **GitHub** credentials.
 
-Should the default branch not yet contain the submodules or you want to update the submodules afterwards, you can do that with:
+3. **Verify Your Email:**
+   - Check your email for a confirmation link, and click on it to verify your account.
 
-```{.sh .copy}
-git submodule update --init --recursive
-```
+4. **Log In:**
+   - Once verified, log in to your GitLab account.
+
+## **Step 2: Locate the Repository You Want to Fork**
+
+1. **Search for the Unicado Package Repository:**
+   - Use GitLab's **search bar** at the top of the page to find the repository.
+
+2. **Access the Repository:**
+   - Click on the repository from the search results to view its main page.
+
+## **Step 3: Fork the Repository**
+
+1. **Click the "Fork" Button:**
+   - On the repository page, look for the **"Fork"** button in the top-left corner next to star and bell icon.
+
+2. **Select Your Namespace:**
+   - GitLab will ask where you want to fork the repository:
+     - **Personal namespace** (default for individual users). Choose your GitLab user name displayed there from the drop down list.
+     - **Group namespace** (if you're part of an organization or team).
+
+3. **Confirm the Fork:**
+   - Click **Fork project** to create your own copy of the repository.
+
+4. **Wait for Completion:**
+   - The forking process might take a few moments. Once completed, you’ll be redirected to your forked repository.
+
+Fork method is used for contributing to a GitLab project when you are not a member of the project with write access. Allows you to freely make changes to your fork and propose changes to the original repository through a merge request (MR).
+Forking Creates a personal copy of a repo on the server, the general format of forked repository is https://gitlab.com/your-username/repo.git. Now if you want to work on the repository locally using an IDE ( for eg. VSC), you need to clone the forked version of Unicado Package Repository to your locall machine. Cloning will create a local copy of Forked repository. 
+
+## **Step 4: Clone Your Forked Repository**
+1. **Navigate to Your Fork:**
+   - Go to your **GitLab dashboard** and click on the forked repository under **Projects**.
+
+2. **Copy the Clone URL:**
+   - Choose either **HTTPS** or **SSH** URL from the **Clone** button.
+
+3. **Clone the Repository Locally:**
+   - Open your terminal and run:
+     - **For HTTPS:**
+      ```{.cmd .copy}
+      git clone https://gitlab.com/your-username/repository-name.git
+      ```
+     - **For SSH:**
+      ```{.cmd .copy}
+      git clone git@gitlab.com:your-username/repository-name.git
+      ```
+   - Should the default branch not yet contain the submodules or you want to update the submodules afterwards, you can do that with:
+
+      ```{.cmd .copy}
+      git submodule update --init --recursive
+      ```
+
+
+>⚠️You can push to a forked repository without configuring SSH by using HTTPS for authentication instead of SSH. However, SSH is often preferred for its security and ease of use once set up. 🎥**Follow [SSH Configuration](../assets/videos/SSH_Configuration.mp4) tutorial video if you wan to set up SSH**.
 
 >⚠️Only proceed when all submodules could be checked out successfully. Otherwise the builds will not work!
 
-In the following instructions we assume, that you cloned the **Unicado Package** as described.
+In the following instructions we assume, that you forked and cloned the **Unicado Package** as described.
 That means, whenever we talk about building inside the *Aircraft Design* folder, we mean the submodule **inside** the **Unicado Package** repository.
 In general, you should find every mentioned directory or file in one of the submodules of the **Unicado Package**. :point_up:
 
@@ -43,20 +101,18 @@ Once the repository is cloned, you need to update it with the latest changes fro
 
 ### 1. Checkout the `main` branch of your repository
 
-```bash
+```{.cmd .copy}
 git checkout main
 ```
 
 ### 2. Fetch the latest updates from the remote repository
 
-```bash
+```{.cmd .copy}
 git fetch
 ```
 
 ### 3. Pull the latest changes from the remote `main` branch
 
-```bash
+```{.cmd .copy}
 git pull origin main
-```
-
-Watch the first part of [Merge Request Workflow](../assets/videos/Merge_Request_Workflow.mp4) video for a more detailed explanation of above mentioned steps.
\ No newline at end of file
+```
\ No newline at end of file

docs/get-involved/git-installation&configuration.md

@@ -8,13 +8,15 @@ date: 2024-12-05
 
 # Install & Configure Git on Windows
 
+🎥 **If you'd rather skip the text explanations below, watch this video tutorial.[Git_Installation&Configuration](../assets/videos/Git_Installation&Configuration.mp4)**.
+
 ### Download & Install Git
 
 To begin, download and install Git for Windows from the official [Git website](https://git-scm.com/download/win). You will be provided with an installer file that has a `.exe` extension. Locate the downloaded file in your `Downloads` folder and double-click it to start the installation process. Follow the prompts in the installation wizard. While most of the default options are suitable, make sure you select **Git from the command line and also from 3rd-party software**, so Git is accessible from your terminal/command prompt. Once installed, Git will be added to the System Environment Path variable, making it accessible globally.
 
 After installation, open the Git terminal and verify the installation by typing the following command:
 
-```bash
+```{ .cmd .copy }
 git --version
 ```
 
@@ -26,7 +28,7 @@ This should return the installed version of Git, confirming that Git is set up c
 
 Once Git is installed, configure your user name and email, which will be associated with your commits. Run the following commands in the terminal to set these configurations:
 
-```bash
+```{ .cmd .copy }
 git config --global user.name "Your Name"
 git config --global user.email "your.email@example.com"
 git config --list  # Check if the configuration was successful
@@ -41,16 +43,13 @@ Now you're ready to start using Git for version control!
 ### SSH Configuration for GitLab
 
 To securely connect with the UNICADO project hosted on GitLab and access its repositories, you'll need to set up SSH keys. Follow the steps below to generate a new SSH key pair, configure an SSH agent, create an SSH config file (optional), and test the SSH connection.
-
-Before starting, ensure that you have read access to the UNICADO project. Access must be granted by the project administrators. Once you have been added as a member, you can proceed with the following steps to configure SSH.
-
 ---
 
 #### Step 1: Generate an SSH Key Pair
 
-Open a terminal (or Git Bash on Windows) and run the following command to generate a new SSH key pair. Replace the email with the one associated with your GitLab account:
+Open a terminal and run the following command to generate a new SSH key pair. Replace the email with the one associated with your GitLab account:
 
-```bash
+```{ .cmd .copy }
 ssh-keygen -t ed25519 -C "your.email@example.com"
 ```
 
@@ -63,58 +62,47 @@ When prompted, press Enter to save the key to the default location (`C:\Users\Yo
 
 #### Step 2: Create an SSH Config File (Optional but Recommended)
 
-If you use multiple SSH keys (for different services like GitHub, GitLab, etc.), it's a good idea to create an SSH config file for easier management.
+If you use multiple SSH keys (for different services like GitHub, GitLab, etc.), it's a good idea to create an SSH config file for easier management. Open the SSH config file using notepad and 
 
-Start by setting `vim` as the default editor for Git (if you haven't already) by running:
-
-```bash
-git config --global core.editor "vim"
+```{ .cmd .copy }
+notepad C:\Users\<YourUsername>\.ssh\config
 ```
 
-Now, open or create the SSH config file using `vim`:
+Replace <YourUsername> with your actual Windows username. This will open the config file in Notepad (or create it if it doesn't exist).
 
-```bash
-vim ~/.ssh/config
-```
-
-If the file doesn’t exist, `vim` will create it. Press `i` to enter insert mode and add the following configuration:
-
-```bash
+```{ .cmd .copy }
 Host gitlab.com
     User git
     HostName gitlab.com
     PreferredAuthentications publickey
-    IdentityFile ~/.ssh/id_ed25519
+    IdentityFile C:\Users\<YourUsername>\.ssh\id_ed25519
 ```
 
 - `Host`: An alias for the connection (use `gitlab.com` to match the GitLab domain).
 - `User`: The SSH user for GitLab (`git`).
 - `HostName`: The GitLab domain (`gitlab.com`).
 - `PreferredAuthentications`: Specifies that public key authentication should be used.
-- `IdentityFile`: The path to your private SSH key (default is `~/.ssh/id_ed25519`).
-
-After adding the configuration, press `Esc` to exit insert mode. Type `:wq` (write and quit) and press Enter to save and exit.
-
+- `IdentityFile`: The path to your private SSH key (default is `.ssh\id_ed25519`).
 ---
 
 #### Step 3: Add SSH Key to SSH Agent
 
 The SSH agent manages your private keys, so you won’t need to enter your passphrase every time you interact with GitLab. Start the SSH agent by running:
 
-```bash
-eval "$(ssh-agent -s)"
+```{ .cmd .copy }
+ssh-agent bash
 ```
 
-On Windows (using Git Bash), the SSH agent may be automatically set up. Add your private key to the agent:
+On Windows command prompt, the SSH agent may be automatically set up. Add your private key to the agent:
 
-```bash
-ssh-add ~/.ssh/id_ed25519
+```{ .cmd .copy }
+ssh-add C:\Users\<YourUsername>\.ssh\id_ed25519
 ```
 
 If you used a different name or location for your key (e.g., `id_rsa_gitlab`), adjust the path accordingly:
 
-```bash
-ssh-add ~/.ssh/id_rsa_gitlab
+```{ .cmd .copy }
+ssh-add C:\Users\<YourUsername>\.ssh\id_rsa_gitlab
 ```
 
 ---
@@ -125,8 +113,8 @@ GitLab uses SSH to authenticate your identity when interacting with repositories
 
 First, copy the public key to your clipboard. On Windows (with Git Bash), use the following command to display the public key:
 
-```bash
-cat ~/.ssh/id_ed25519.pub
+```{ .cmd .copy }
+cat .ssh\id_ed25519.pub
 ```
 
 Next, log in to your GitLab account and navigate to your **Profile Settings**. In the left sidebar, select **SSH Keys**, paste the public key into the **Key** field, and optionally provide a title (e.g., "My Laptop"). Click **Add key** to save it.
@@ -137,8 +125,8 @@ Next, log in to your GitLab account and navigate to your **Profile Settings**. I
 
 Test whether your SSH key is set up correctly by running the following command:
 
-```bash
-ssh -T git@git.rwth-aachen.de
+```{ .cmd .copy }
+ssh -T git@gitlab.com
 ```
 
 If the key is set up properly, the output should say:
@@ -149,5 +137,5 @@ Welcome to GitLab, @yourusername!
 
 If it’s your first time connecting, GitLab may ask you to confirm the authenticity of the host. Type `yes` to proceed.
 
-By following these steps, you’ve successfully configured SSH for GitLab. You can now securely interact with GitLab repositories over SSH, enabling you to clone, push, and pull using your private key. For a more detailed explanation of the steps mentioned above, watch the [Git_Installation&Configuration](../assets/videos/Git_Installation&Configuration.mp4) video.
+By following these steps, you’ve successfully configured SSH for GitLab. You can now securely interact with GitLab repositories over SSH, enabling you to clone, push, and pull using your private key.
 

docs/get-involved/merge-request.md

@@ -9,48 +9,65 @@ date: 2024-09-25
 # How to create a merge request (MR)
 
 You have already implemented an improvement to the current code base or intend to? Awesome 😎
-Here are some instructions, on how to to that:
+Follow these steps to create a merge request (MR) from your forked repository:
 
-- First, make sure you have read [How to contribute to UNICADO](../developer/contribute.md)
-- Read the following instructions:
+- First, make sure you have read [How to contribute to UNICADO](../get-involved/contribute.md)
+- Then, proceed with the steps below:
 
 There are several ways to create a merge request within GitLab, which are explained in detail in the [official GitLab docs](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html).
 
 However, we will highlight the workflow, we prefer - but feel free to make your own choice.
 
-## Preferred merge request workflow
+## Preferred Merge Request Workflow for a Forked Repository
 This is the first and preferred way to make a merge request, as it is similar to our previous UNICADO workflow.
+Let's assume you have forked( if you are not a direct member of UNICADO project) and cloned the Unicado Package repoistory and updated all it's submodules following [Get Source Code](get-source-code.md ). Open your preferred IDE (e.g., Visual Studio Code). Ensure that Git is integrated within your IDE. Most IDEs, such as VSCode, have built-in Git integration. Go to the sub module where you want to make the change. Create your own (local) branch, where you are developing a new feature / fixing bug / addong documentation.
+For a more detailed explanation of the steps mentioned below, watch the [Merge Request Workflow](../assets/videos/Merge_Request_Workflow.mp4) video.
 
-Let's assume you have cloned the Unicado Package repoistory and updated all it's submodules following [Get Source Code](get-source-code.md ). Go to the sub module where you want to make the change. Create your own (local) feature branch, where you are developing a new feature.
+### 1.  Configure Remotes:
 
-### 1. Create a New Branch
+Verify and set up remotes for your fork and the upstream repository:
 
-Create a new branch from `main` to work on your feature or bug fix. The `main` branch contains the stable version of the code and ‘main’ is the default branch (i.e., the branch you check out when cloning the repository). Developers are not allowed to push directly to this branch. All changes must go through the ‘feature’ branch and a merge request process.
+```{ .cmd .copy }
+git remote -v
+```
+Add the original UNICADO repository as the upstream remote:
+
+```{ .cmd .copy }
+git remote add upstream git@gitlab.com:unicado/unicado.git
+```
+
+### 2. Create a New Branch
+
+Create a new branch from `main` to work on your feature or bug fix. The `main` branch contains the stable version of the code and ‘main’ is the default branch (i.e., the branch you check out when cloning the repository). Developers are not allowed to push directly to this branch. All changes must go through <new-branch-name> branch and a merge request process.
 
-```bash
+```{ .cmd .copy }
 git checkout -b <new-branch-name>  # Create a new branch
 ```
-Where <new-branch-name> is the branch where developers work on new features or bug fixes. Each developer creates their own feature branch from the `main` branch. After completing changes on a feature branch, a Merge Request (MR) is created to merge the changes into the `main` branch. Once the MR is reviewed and approved, it gets merged into `main`.
+Where <new-branch-name> is the branch where developers work on new features or bug fixes. Each developer creates their own  branch from the `main` branch. After completing changes on the new branch, a Merge Request (MR) is created to merge the changes into the `main` branch. Once the MR is reviewed and approved, it gets merged into `main`.
 
-Make sure your branch name follows this convention: `feature/your-feature`, `bugfix/your-bugfix`, or `documentation/your_documentation`. This ensures your branch can be pushed successfully. 
+Make sure your branch name follows this convention: 
 
-### 2. Make Changes
+- `feature/your-feature` # Changes which brings in new feature
+- `bugfix/your-bugfix` # Changes which fixes bug
+- `documentation/your_documentation` #Changes which adapt existing documentation / Adding new documentation.
+
+This ensures your branch can be pushed successfully. 
+
+### 3. Make Changes
 
 Modify the submodule files as needed.
 
-### 3. Stage and Commit Your Changes
+### 4. Stage and Commit Your Changes
 
 After making your changes, stage them using the `git add` command:
 
-```bash
+```{ .cmd .copy }
 git add .  # Stage all modified files
 ```
 
 Next, commit your changes with a meaningful commit message:
 
-```bash
-git commit -m "Description of the changes made"
-```
+
 #### Guidelines for a Good Commit Message 
 
 - **Title**: A short description of what the commit does (use present tense).
@@ -59,57 +76,41 @@ git commit -m "Description of the changes made"
 
 Before committing, ensure that your code is working as expected by running local tests (such as static code analysis) and avoid committing code that is not functioning properly.
 
-### 4. Push Your Changes to GitLab
+### 5. Push Changes to Your Fork
 
-Once your changes are committed, push them to the remote GitLab repository:
+Push your branch to your forked repository on GitLab:
 
-```bash
-git push origin <new-branch-name>  # Push your changes to the remote repository
+```{ .cmd .copy }
+git push origin <new-branch-name>
 ```
 If you are working on this branch locally, and it is not shared with remote ☁️, then you have to push it ⏫ to remote, first in order to create a merge request. 
 
-### 5. Create a Merge Request (MR)
+### 6. Create a Merge Request (MR) to the Original Repository
 
-After pushing your branch, GitLab will often suggest creating a Merge Request (MR). To create an MR:
+To propose your changes to the original UNICADO repository:
 
-1. Navigate to your project in GitLab, and GitLab will prompt you to create an MR.
-2. Select your feature branch as the source branch and `main` as the destination branch.
-3. Click "Create Merge Request."
-4. In the MR description, provide additional context regarding the changes made.
-5. Add reviewers (team members who will review your code).
-6. You will receive email notifications about the MR status and any reviewer comments. Make any necessary changes, and push those updates to the remote repository.
+1. Go to the original UNICADO repository on GitLab.
+2. Click Create Merge Request.
+3. Set your forked repository's <new-branch-name> as the source branch and `main` in the original repository as the target branch.
+4. Fill out the MR details:
+   - Provide a clear title and description of your changes.
+   - Use available MR templates for consistency.( You can choose one available from the available templates. These templates are saved in merge_request_templates folder inside .gitlab)
+5. Add reviewers who will assess your changes (e.g., project maintainers).
+   -Reviewers will leave comments or request changes.
+   -Make the necessary updates locally, commit them, and push to the same branch. In case you need to commit adaptions, check the [Guidelines for a Good Commit Message](#guidelines-for-a-good-commit-message) again!
+6. After pushing your branch, the Continuous Integration (CI) pipeline will run automatically for the MR. CI checks ensure that your code meets the project’s quality standards and passes all tests.
+   - Monitor Pipeline Status: Once your MR is created, GitLab will display the pipeline status in the MR. Look for ✅ (success) or ❌ (failure).
+   - Fixing CI Failures: Open the pipeline logs to identify the issue. Fix the problem in your local branch. Commit and push the updates:
 
-### 6. Review, Approval, and Merging
-
-Then you have to wait for the **Merge request pipeline** to pass ✅ (and hopefully not fail🤞) and for the **reviewer** to approve 👍 the request. In case you need to commit adaptions, check the [Guidelines for a Good Commit Message](#guidelines-for-a-good-commit-message) again! Afterwards on the page of the merge request, you can click on **merge**. Then your feature branch will be automatically merged into `main` (in this example).
-```
 📝 As a reviewer, don't close the merge request. It will be closed automatically, when the merge is completed.
 
 📝 Choose squash as merge strategy, to keep the git history streamlined
 
-```
-### 7. Clean Up After the Merge
+### 7. Approval, Merge and clean up
 
-Once the MR is merged, it’s common practice to delete the feature branch to keep the repository clean and free from unnecessary branches. GitLab provides an option to automatically delete the source branch after the merge. You can select "Remove source branch" during the merge process, and GitLab will delete the branch for you.
-
-Additionally, you can close the related issue, which should have been resolved by the MR.
+The reviewer(e.g., project maintainers) will merge your branch into the main branch. GitLab automatically deletes the source branch(<new-branch-name>) if "Remove source branch" is selected during the merge. Additionally, you can close the related issue, which should have been resolved by the MR.
 
 By following these steps, you ensure that your contributions are properly tracked, reviewed, and merged with minimal disruption to the project.
-```
-📝 You can also perform the git operations via your tool of choice, e.g. VSCode
-```
-The flowchart below illustrates the Merge Request workflow, along with the commands used at each stage.
 
-<style>
-  .center-img {
-    text-align: center;
-  }
-</style>
-
-<p class="center-img">
-  <img src="../../assets/images/MR_Worflow.png" alt="Merge Request Workflow" width="600" />
-  <br>
-  <i>Merge Request Workflow</i>
-</p>
+📝 You can also perform the git operations via your tool of choice, e.g. VSCode
 
-For a more detailed explanation of the steps mentioned above, watch the [Merge Request Workflow](../assets/videos/Merge_Request_Workflow.mp4) video.
\ No newline at end of file