the_information_nexus/tech_docs/cli_skills.md

To improve your CLI skills, focusing on efficiency and mastery of shell commands, here are some tips and techniques:

1. Use Aliases: Create aliases for commonly used commands to save time. For example:

   alias cdp='cd ..'
   alias ll='ls -la'
   alias v='vim'
   

   Add these to your ~/.bashrc or ~/.zshrc file.

2. Navigation Shortcuts:

   • Use cd - to quickly switch to the previous directory.
   • Use cd with shortcuts like .. for parent directories or ~ for the home directory.
   • Implement pushd and popd for managing directory stack:

     pushd /path/to/directory
     popd
     

3. Tab Completion: Leverage tab completion to quickly fill in file and directory names.

4. Search Command History: Use Ctrl + r to reverse search through your command history.

5. Bash/Zsh Shortcuts:

   • Ctrl + a moves to the beginning of the line.
   • Ctrl + e moves to the end of the line.
   • Ctrl + w deletes the word before the cursor.
   • Ctrl + u deletes from the cursor to the beginning of the line.
   • Ctrl + k deletes from the cursor to the end of the line.

6. Scripting: Write simple scripts for repetitive tasks. For example, to navigate to a commonly used directory and open a file:

   #! /bin/bash
   cd ~/repos/the_information_nexus/tech_docs/linux
   vim vim.md
   

   Save this as edit_vim_docs.sh and run it with ./edit_vim_docs.sh.

7. Combine Commands with && and ;: Combine commands on a single line to streamline workflows:

   cd ~/repos/the_information_nexus/projects && vim The-Digital-Pulse-Series.md
   

8. Use find and grep: Search for files and content within files efficiently:

   find . -name '*.md'
   grep -r 'search_term' .
   

9. Keyboard Macros: Use Ctrl + x followed by ( and ) to start and end a keyboard macro in bash, which can be used to repeat a sequence of commands.

10. Automation with Makefile: Use Makefiles to define commands you often run, simplifying complex workflows:

    edit_vim_docs:
        cd ~/repos/the_information_nexus/tech_docs/linux && vim vim.md
    

11. Learning Resources:

    • Books:
      • "The Linux Command Line" by William Shotts
      • "Learning the bash Shell" by Cameron Newham
    • Online Courses:
      • Codecademy's Command Line course
      • Udemy's Linux Command Line Basics

12. Experiment with Shell Customization: Customize your shell prompt to include useful information like the current directory, Git branch, etc. For example, using oh-my-zsh:

    ZSH_THEME="agnoster"
    

Implementing these tips will help you become more efficient and powerful with your command-line skills.

---

To enhance your Git skills, here are some detailed explanations and examples of commands and best practices:

Basic Git Workflow

1. Check Status:

   git status
   

   • Shows the current state of your working directory and staging area.
   • Use it frequently to keep track of changes.

2. Add Changes:

   git add .
   

   • Stages all changes in the working directory.

   git add file_name
   

   • Stages specific files.

3. Commit Changes:

   git commit -m "Your commit message"
   

   • Records the staged changes in the repository with a message.
   • Use clear, descriptive messages. For example, "Fix typo in README.md".

4. Push Changes:

   git push origin main
   

   • Uploads your local commits to the remote repository.
   • Ensure your local branch is up to date with git pull before pushing.

Advanced Git Commands and Practices

1. Interactive Add:

   git add -p
   

   • Interactively review and stage changes hunk by hunk.
   • Useful for staging specific parts of a file.

2. Restore Changes:

   git restore <file>
   

   • Discards changes in the working directory.
   • For example, git restore README.md will revert changes to the file.

3. Remove Files:

   git rm <file>
   

   • Stages the removal of files from the repository.
   • For example, git rm old_file.txt will remove and stage old_file.txt for deletion.

4. Check Logs:

   git log
   

   • Shows commit history.

   git log --oneline --graph --decorate --all
   

   • Provides a visual representation of commit history.

5. Branching and Merging:

   git branch
   

   • Lists all branches.

   git branch new-branch
   

   • Creates a new branch.

   git checkout new-branch
   

   • Switches to the specified branch.

   git checkout -b new-branch
   

   • Creates and switches to a new branch.

   git merge new-branch
   

   • Merges the specified branch into the current branch.

6. Rebasing:

   git rebase main
   

   • Integrates changes from another branch, maintaining a linear history.
   • Use git pull --rebase to keep your branch updated.

7. Stashing:

   git stash
   

   • Temporarily saves changes.

   git stash apply
   

   • Applies stashed changes.

   git stash list
   

   • Lists all stashes.

8. Resetting:

   git reset --soft HEAD~1
   

   • Moves HEAD to the previous commit, keeping changes in the working directory.

   git reset --hard HEAD~1
   

   • Moves HEAD to the previous commit and discards changes.

9. Tagging:

   git tag v1.0
   

   • Creates a tag.

   git push origin v1.0
   

   • Pushes the tag to the remote repository.

10. Reverting:

    git revert <commit>
    

    • Creates a new commit that undoes changes of a specific commit.
    • For example, git revert abc1234 will undo changes from commit abc1234.

Best Practices

1. Write Meaningful Commit Messages:

   • Use the imperative mood: "Fix bug" instead of "Fixed bug".
   • Separate subject from body with a blank line.
   • Limit the subject line to 50 characters.

2. Use Branches for Features and Bug Fixes:

   • Keep your main branch clean and stable.

3. Regularly Pull and Rebase:

   • Keep your branch up to date with the main branch by regularly pulling and rebasing.

4. Review Changes Before Committing:

   • Use git diff to review changes before staging and committing them.

Additional Tools and Resources

1. Graphical Interfaces:

   • Tools like GitKraken, Sourcetree, or GitHub Desktop can help visualize changes and manage branches.

2. Learning Resources:

   • Books: "Pro Git" by Scott Chacon and Ben Straub.
   • Online Courses: GitHub Learning Lab, Codecademy, and Udacity.

3. Automation with Git Hooks:

   • Automate tasks with Git hooks (e.g., pre-commit, post-commit).

   # .git/hooks/pre-commit
   #!/bin/sh
   npm test
   

Implementing these advanced commands and best practices will help you become more proficient with Git, making version control and collaboration smoother and more efficient.