Mostly cosmatic changes in codeblocks. Renamed a section to Important Note from Important Limitation.

Author: rajwanur

site/posts/understanding-gitignore/index.qmd

@@ -2,25 +2,23 @@
 title: "Understanding gitignore: A Simple Guide"
 author: "rajwanur"
 date: "2025-09-04"
-categories: [git, tools, version-control]
+categories: [git, tools, gitignore]
 toc: TRUE
 toc-title: "Table of contents"
-toc-depth: 5
+toc-depth: 3
 ---
 
-# Understanding gitignore: A Simple Guide
-
-If you are working with Git but find yourself dealing with unnecessary files cluttering your repository, **.gitignore** is a tool that can help. Let's explore what it does in plain terms.
+If you are working with Git but find yourself dealing with unnecessary files cluttering your repository, `.gitignore` is a tool that can help. Let's explore what it does in plain terms.
 
 ## What is gitignore?
 
-.gitignore is simply a text file that tells **Git** which files or folders to ignore in your project. It works like an instruction list for version control - when Git sees something mentioned in this file, it pretends that file doesn't exist and will not include it in tracking changes.
+`.gitignore` is simply a text file that tells **Git** which files or folders to ignore in your project. It works like an instruction list for version control - when Git sees something mentioned in this file, it pretends that file doesn't exist and will not include it in tracking changes.
 
-Think of it as creating a "do not pack" list before the travel. .gitignore helps programmers avoid committing files they don't want to track. It also helps programmers exclude the files that don't need to be versioned.
+Think of it as creating a "do not pack" list before the travel. `.gitignore` helps programmers avoid committing files they don't want to track. It also helps programmers exclude the files that don't need to be versioned.
 
 ## The Problem It Solves
 
-When working with code - especially languages like SAS, R, or Python - we often generate temporary files:
+When working with code - especially languages like `SAS`, `R`, or `Python` - we often generate temporary files:
 
 - Log files showing execution results
 - Temporary output files
@@ -30,11 +28,11 @@ When working with code - especially languages like SAS, R, or Python - we often
 
 These files can clutter the repository, making it harder to see actual code changes. They also unnecessarily increase repository size, which can slow down operations.
 
-.gitignore solves this by automatically excluding these unwanted files from version control without someone having to manually specify each time.
+`.gitignore` solves this by automatically excluding these unwanted files from version control without someone having to manually specify each time.
 
 ## How It Works
 
-The .gitignore file uses simple patterns to match filenames:
+The `.gitignore` file uses simple patterns to match filenames:
 
 - `*.log` - ignores all files ending with .log
 - `temp/` - ignores any folder named temp
@@ -47,16 +45,16 @@ For complete syntax please refer to the [official documentation](https://git-scm
 
 These rules are applied whenever Git checks for changes, so you only see relevant modifications.
 
-## About Multiple .gitignore Files
+## About Multiple `.gitignore` Files
 
-It's worth noting that it is possible to have multiple .gitignore files throughout the project. .gitignore files are not limited to just one in the root directory. When we place a .gitignore file in a subfolder, Git applies those specific ignore patterns only within that folder.
+It's worth noting that it is possible to have multiple `.gitignore` files throughout the project. `.gitignore` files are not limited to just one in the root directory. When we place a `.gitignore` file in a subfolder, Git applies those specific ignore patterns only within that folder.
 
 This is particularly useful for tools like R's renv package or Python's virtual environments, which might have their own temporary files and configurations that should be ignored at different levels of project structure.
 
 ```{mermaid}
 ---
 config:
-  layout: fixed
+  layout: auto
 ---
 flowchart LR
     A[🏠 my-r-project/] --> B[📄 .gitignore<br/>ROOT LEVEL]
@@ -97,9 +95,9 @@ flowchart LR
 
 ### Basic Setup
 
-For most projects, create a .gitignore file in your project's root directory with patterns specific to your language or tools:
+For most projects, create a `.gitignore` file in your project's root directory with patterns specific to your language or tools:
 
-```
+```bash
 # Ignore log files
 *.log
 *.tmp
@@ -118,15 +116,15 @@ For most projects, create a .gitignore file in your project's root directory wit
 Different programming languages often have different temporary files:
 
 - For SAS programs:
-  ```
+  ```bash
   # To exclude SAS log, lst, and sas7bdat files
   *.log
   *.lst
   *.sas7bdat
   ```
 
 - For R projects:
-  ```
+  ```bash
   # To exclude R temporary files
   .RData
   .Rhistory
@@ -135,7 +133,7 @@ Different programming languages often have different temporary files:
   ```
 
 - For Python projects:
-  ```
+  ```bash
   __pycache__/
   *.pyc
   .env
@@ -147,40 +145,40 @@ Different programming languages often have different temporary files:
 
 We can set up global ignore patterns that apply to all our repositories:
 
-```
+```bash
 git config --global core.excludesfile ~/.gitignore_global
 ```
 
-Then add common patterns in .gitignore_global file located at ~/ (home directory) that should be ignored across all projects.
+Then add common patterns in `.gitignore_global` file located at `~/` (home directory) that should be ignored across all projects.
 
-## Important Limitation
+## Important Note
 
-While .gitignore is powerful, it has an important limitation: it won't ignore files that are already included (staged or committed) in Git. If a file is added to the staging area with `git add`, Git will continue tracking it even if it matches patterns in existing .gitignore file.
+While `.gitignore` is powerful, it has an important feature: it won't ignore files that are already included (staged or committed) in Git. If a file is added to the staging area with `git add`, Git will continue tracking it even if it matches patterns in existing `.gitignore` file.
 
-If such a file is already included and needs to be excluded, this need to explicitly remove it from tracking using:
-```
+If such a file is already included and needs to be excluded from version control, this need to explicitly remove it from tracking using:
+```bash
 git rm --cached filename
 ```
 
 This removes the file from version control but leaves it on the local filesystem.
 
 ## Best Practices
 
-1. **Create early**: Add .gitignore at the beginning of a project
-2. **Commit it**: Make sure .gitignore itself is version controlled
+1. **Create early**: Add `.gitignore` at the beginning of a project
+2. **Commit it**: Make sure `.gitignore` itself is version controlled
 3. **Share with team**: Everyone working on a project should use the same rules
 4. **Review occasionally**: As your project evolves, update your ignore patterns
 5. **Exclude all/include some**: To avoid new file types from being tracked, exclude all and include what is expected
 
 ## Resources
 
-- [.gitignore syntax](https://git-scm.com/docs/gitignore)
-- [Understanding .gitignore](https://www.atlassian.com/git/tutorials/saving-changes/gitignore)
-- [Automatically Generate gitignore Files](https://www.gitignore.io/)
+- [`.gitignore` syntax](https://git-scm.com/docs/gitignore)
+- [Understanding `.gitignore`](https://www.atlassian.com/git/tutorials/saving-changes/gitignore)
+- [Automatically Generate `.gitignore` Files](https://www.gitignore.io/)
 
 
 ## Conclusion
 
-.gitignore is a simple but powerful tool that helps maintain clean repositories by excluding unnecessary files. It's not magical - just practical configuration that saves time and reduces clutter in version control systems.
+`.gitignore` is a simple but powerful tool that helps maintain clean repositories by excluding unnecessary files. It's not magical - just practical configuration that saves time and reduces clutter in version control systems.
 
-If you haven't used .gitignore before, give it a try on your next project. You'll likely find yourself wondering how you ever worked without it!
+If you haven't used `.gitignore` before, give it a try on your next project. You'll likely find yourself wondering how you ever worked without it!