# 9. Practical Example: Using GitFlow

#### Let's walk through a practical example of using GitFlow for a hypothetical project.

#### **Setting up a project with GitFlow**

1. **Initialize a new Git repository:**

   ```bash
   bashCopy code
   mkdir myproject
   cd myproject
   git init

   ```
2. **Commit an initial empty commit (this helps in setting up the base for branching):**

   ```bash
   bashCopy code
   git commit --allow-empty -m "Initial commit"

   ```
3. **Create the `develop` branch and switch to it:**

   ```bash
   bashCopy code
   git checkout -b develop

   ```

Now you have both **`master`** and **`develop`** branches, with **`develop`** being the one you'll work on.

#### **Developing a new feature**

1. **Create a new feature branch:**

   ```bash
   bashCopy code
   git checkout -b feature/new-awesome-feature develop

   ```
2. **Make changes for the feature and commit them:**

   ```bash
   bashCopy code
   echo "This is my new feature" > feature.txt
   git add feature.txt
   git commit -m "Add new awesome feature"

   ```
3. **Once the feature is complete, merge it into the `develop` branch:**

   ```bash
   bashCopy code
   git checkout develop
   git merge --no-ff feature/new-awesome-feature
   git branch -d feature/new-awesome-feature

   ```

#### **Preparing for a release**

1. **Create a release branch:**

   ```bash
   bashCopy code
   git checkout -b release/1.0.0 develop

   ```
2. **Make any final adjustments needed for the release (like bumping version numbers, updating documentation, etc.) and commit those changes.**
3. **Once the release is ready, merge it into `master` and tag it:**

   ```bash
   bashCopy code
   git checkout master
   git merge --no-ff release/1.0.0
   git tag -a 1.0.0

   ```
4. **Also, merge the changes back into `develop`:**

   ```bash
   bashCopy code
   git checkout develop
   git merge --no-ff release/1.0.0

   ```
5. **Delete the release branch:**

   ```bash
   bashCopy code
   git branch -d release/1.0.0

   ```

#### **Handling hotfixes**

1. **Create a hotfix branch from `master`:**

   ```bash
   bashCopy code
   git checkout -b hotfix/1.0.1 master

   ```
2. **Make and commit the hotfix changes:**

   ```bash
   bashCopy code
   echo "Hotfix applied" > hotfix.txt
   git add hotfix.txt
   git commit -m "Fix critical issue"

   ```
3. **Merge the hotfix branch into both `master` and `develop`:**

   ```bash
   bashCopy code
   git checkout master
   git merge --no-ff hotfix/1.0.1
   git tag -a 1.0.1

   git checkout develop
   git merge --no-ff hotfix/1.0.1

   ```
4. **Delete the hotfix branch:**

   ```bash
   bashCopy code
   git branch -d hotfix/1.0.1

   ```

#### **Merging back to the main branches**

Throughout the GitFlow process, you've been merging changes back to the main branches (**`master`** and **`develop`**) at the end of each feature, release, or hotfix. This ensures that:

* The **`master`** branch always reflects the production-ready state.
* The **`develop`** branch always contains the latest delivered and approved features.

By consistently merging back, you ensure that both branches are up-to-date and that features, fixes, and releases are systematically integrated into your project's main lines of development.