What is grep?

At its core, grep is a command-line utility that searches for a specific pattern of text in a file or a stream of data. If it finds a match, it will print the line containing that pattern to the console. Its power lies in its simplicity and its support for regular expressions, which allows for incredibly flexible and powerful search queries.

Basic Syntax

The basic syntax for grep is straightforward:

grep [options] pattern [file...]

• [options]: These are flags that modify the behavior of grep.
• pattern: This is the text or regular expression you are searching for.
• [file...]: This is the file or files you want to search in. If no file is specified, grep will search the standard input.

Daily Use Cases

Here are some of the most common ways you’ll use grep in your day-to-day tasks:

Simple Text Search

The most basic use of grep is to search for a specific word in a file.

grep "error" log.txt

This command will search for the word “error” in the log.txt file and print all lines that contain it.

Case-Insensitive Search

If you want to ignore the case of the text you’re searching for, use the -i option.

grep -i "error" log.txt

This will find “error”, “Error”, “ERROR”, and so on.

Searching in Multiple Files

You can search for a pattern in multiple files by listing them after the pattern.

grep "api_key" config.yml settings.py

Recursive Search

To search for a pattern in all files within a directory and its subdirectories, use the -r option.

grep -r "database_url" .

This is incredibly useful for finding where a particular variable or function is used in a large project.

Medium Complexity Use Cases

Once you’re comfortable with the basics, you can start using grep for more complex tasks.

Inverting the Search

If you want to find all the lines that don’t contain a pattern, use the -v option.

grep -v "success" log.txt

This is useful for filtering out noise from log files.

Counting Matches

To count the number of lines that match a pattern, use the -c option.

grep -c "warning" log.txt

Showing Line Numbers

To display the line number of each match, use the -n option.

grep -n "TODO" *.py

This helps you quickly jump to the relevant line in your code editor.

Advanced grep with Regular Expressions

The true power of grep is unlocked when you use it with regular expressions. Here are a few examples:

Matching the Start and End of a Line

You can use ^ to match the beginning of a line and $ to match the end.

grep "^import" *.py  # Find all lines that start with "import"
grep ")$" *.js      # Find all lines that end with ")"

Matching Any Character

The . character in a regular expression matches any single character.

grep "gr.p" words.txt # Matches "grep", "grip", "grap", etc.

Using Character Classes

You can use character classes to match a set of characters.

grep "[aeiou]" text.txt # Find all lines with at least one vowel

Combining grep with Other Commands

grep is often used with other commands to create powerful command-line pipelines.

ps aux | grep "nginx" # Find all running processes with "nginx" in their name

This command takes the output of ps aux and uses grep to filter it.

Conclusion

grep is a versatile and powerful tool that is essential for anyone who works with the command line. From simple text searches to complex pattern matching with regular expressions, grep can handle it all.

Thank you

HomeBrew

Homebrew is a package manager for macOS (and Linux) that lets you easily install, update, and manage software and developer tools from the command line.

# Installation command
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

After running the command, restart your terminal, and you’re good to go. Before we start installing, let’s understand the difference between a “formula” and a “cask” in Homebrew.

Formula: Command-line tools, libraries, and languages (e.g., Kotlin, Go). No special flags are needed when using brew commands with formulas. All Formulas

Cask: GUI applications like Chrome, VSCode, etc. These require a --cask flag for brew operations. Cask Directory

brew install git             # Installing a formula
brew install --cask firefox  # Installing a cask

brew uninstall foo           # Remove a package
brew upgrade foo             # Upgrade a specific package
brew list                    # See all installed packages
brew search foo              # Find available packages
brew info foo                # Get details about a package
brew update                  # Update Homebrew's package list
brew upgrade                 # Upgrade all outdated packages

🔗 HomeBrew-Official

Ollama - Local and OpenSource LLMs

This is an incredibly useful tool that I find myself using constantly. Local models are fantastic for answering general or timeless questions where you need accuracy without requiring up-to-the-minute data. They’re fast, private, work offline, and have another big advantage: 🌱 a reduced environmental impact.

Instructions:

1. Install Ollama by running the official script in your terminal. If you prefer, you can also download it manually from the official site.

   curl -fsSL https://ollama.com/install.sh | sh
   

2. Browse the Model Library to find a model. Keep an eye on the size, as some models can be several gigabytes.
3. Once you’ve picked a model, pull it using the pull command. For example, to get the Llama 3 model:

   ollama pull llama3
   

4. After the download is complete, you can run the model to start a chat session. To exit, just type /bye.

   ollama run llama3
   

That’s it! Now, anytime you have a question, you can just run ollama run <model_name> to interact with your local LLM.

Here is an example of how you can download and run another model in one line:

ollama pull mistral && ollama run mistral

🔗 Ollama

Gemini-cli

Gemini CLI is an open-source tool that brings the power of Google’s Gemini models directly into your terminal. It provides lightweight, direct access to the API, making it a versatile utility for a wide range of tasks, from coding and content generation to problem-solving and research.

Installation

1. Ensure you have Node.js (version 18+). You can check with node -v. If you don’t have it, install it with Homebrew:

   brew install node
   

2. Install the Gemini CLI globally using npm:

   npm install -g @google/gemini-cli
   

3. Run the setup and authentication command:

   gemini
   

   Follow the prompts to choose a theme and log in with your Google account.

Troubleshooting Tip: On some systems, the authentication flow in the terminal might not complete. If this happens, run gemini again, and then check your default web browser for the Google authentication page to complete the login.

⚠️ Unlike Ollama, only the tool is open-source, not the model. Your prompts and data will be processed by Google’s servers.

⚠️ The free tier has a rate limit (e.g., 60 requests per minute). You can upgrade to a paid plan to overcome this.

Common Commands

• /chat save <name>: Saves your current chat with a memorable name.
• /chat list: Lists all your saved chats.
• /chat resume <name>: Resumes a saved chat session.
• /compress: Replaces the current chat context with a summary to save tokens.
• /auth: Manages your authentication settings.
• /quit or /exit: Exits the tool.

Switching to Shell Mode

You can input ! to toggle shell mode. For example, type !pwd to see your current directory. The theme will change to indicate you’re in shell mode. To return to the chat, just input ! again.

Providing Context

Use the @ symbol to provide file or directory context for your prompts.

• @path/to/your/file.txt Explain this text file.
• @src/my_project/ Summarize the code in this directory.

You can find more commands in the official documentation.

Gemini CLI-Github repo

DuckDuckGo

Sometimes you just need to verify things quickly with a search engine. ddgr brings the DuckDuckGo search engine to your CLI, delivering fast results.

# Installation
brew install ddgr

Common Commands

These are the commands you’ll likely use most often:

navigation Commands

When results are displayed, you can use these keys to navigate:

Here’s an example I use extensively:

# Shows 5 results from GitHub for "awesome shell scripts"
ddgr -n 5 -w github.com "awesome shell scripts"

Profile Configuration

You can customize ddgr’s default behavior by editing the ~/.ddgrrc file (vi ~/.ddgrrc). Here are some of the options you can configure:

🔗 ddgr-Repo

Git CLI

brew install git

I’m sure you’re familiar with the basic git commands, but you can create powerful aliases to make your workflow faster. For example, you can run git st instead of git status.

1. Find your global git config file by running git config --list --show-origin.
2. Open that file (e.g., vi ~/.gitconfig) and add your aliases.

Here is an example ~/.gitconfig file:

[credential]
    helper = store
[user]
    name = Eganathan R
    email = md-email@gmail.com
[filter "lfs"]
    smudge = git-lfs smudge -- %f
    process = git-lfs filter-process
    required = true
    clean = git-lfs clean -- %f
[init]
    defaultBranch = master
[http]
    proxy = http://127.0.0.1:xxxx
[alias]
    st = status
    co = checkout
    br = branch
    ci = commit
    lg = log --oneline --graph --decorate # Pretty and compact log view

Podman (Optional)

Podman is a powerful, daemonless(It does not require a background service) container engine for developing, managing, and running containers. It provides a command-line interface that is compatible with Docker, making it an excellent alternative for container management without requiring a central daemon, i most use podman only for experimentation.

Installation

brew install podman

After installation, you may need to initialize a Podman machine, which is a lightweight virtual machine for running containers on macOS.

podman machine init
podman machine start

Common Commands

Many Podman commands are identical to their Docker counterparts, so you can often use podman as a drop-in replacement for docker.

🔗 Podman-Official

I’m certain this will help you. There are many other interesting command-line tools out there (like starship, tmux), but I consider them more for customization.

Thanks for reading, and have a great day ☺️

btw BASH is short for Bourne Again SHell, just in case some one asks, so lets move it:

Mac Switching between Zsh and Bash

As a software developer, choose Bash if you’re new to shell scripting due to its familiarity and abundance of online resources, while opting for Zsh for improved performance, customization, and security features, keeping in mind that switching to Zsh might require adapting to some differences when working with Linux distributions.

chsh -s /bin/bash  # switch to bash
chsh -s /bin/zsh   # Switch to zsh

Identity

pwd             # Print current working directory
whoami          # Show current user
clear           # Clear the terminal screen
history         # Show command history

File & Directory Navigation

ls              # List files
ls -la          # List all files with details
cd /path/to/dir # Change directory
cd ..           # Go up one directory
cd -            # Go to previous directory

File Operations

touch file.txt              # Create a new empty file
mkdir folder                # Create a new directory
cp file1.txt file2.txt      # Copy file or dir
mv file1.txt file2.txt      # Rename or move file or dir
rm file.txt                 # Delete file 
rm -r folder                # Delete directory recursively

Searching & Finding

grep "text" file.txt        # Search for text in a file
grep -r "text" .            # Recursive search in directory
find . -name "*.sh"         # Find all .sh files

Editing Files

vi file.txt                 # Open file in Vim editor (i don't like nano sorry!) 
cat file.txt                # Print file content
less file.txt               # Scroll through file
head file.txt               # First 10 lines
tail file.txt               # Last 10 lines

• Vim Editor has its own commands and pallets, will add my reference here.

Manual

The man command provides access to the manual pages for other commands, offering detailed information on their usage and options.

man ls # show the manual for ls command

Permissions

chmod +x script.sh          # Make script executable
chmod 755 file              # Set permissions (owner rwx, others rx)
chown user:group file       # Change ownership
ls -l file                  # Get info of file permissions and owner etc
ls -ld folder               # Get info of folder permissions and owner etc

Permissions String Quick Reference

-rw-r--r-- 1 user group 1234 Jun 16 19:00 myfile.txt # Example output for ls -l file check the table for ref
drwxr-xr-x 2 user group 4096 Jun 16 19:00 mydir # Example output for ls -ld folder check the table for ref

Scripts & Variables

#!/bin/bash
echo "Hello, $USER"         # Sample Bash script

# Variables
name="Eganathan"
echo "Hi, $name"

Loops & Conditions

# If
if [ -f "file.txt" ]; then
  echo "Exists"
fi

# For loop
for f in *.txt; do
  echo "$f"
done

Time Savers

!!              # Repeat last command
!abc            # Run last command starting with 'abc'
Ctrl + R        # Reverse search command history
Ctrl + L        # Clear screen (same as `clear`)
Ctrl + A / E    # Move to beginning / end of line

Date Time

date # Print current date and time
date +"%T"        # Print current time in 24-hour format (HH:MM:SS)
date +"%r"        # Print current time in 12-hour format with AM/PM
date +"%F"        # Print current date in YYYY-MM-DD format
date +"%d-%m-%Y"  # Print current date in custom format: Day Month Year
date -u           # Print current UTC time

Use alias to create shortcuts

alias gs="git status" # hope you have git installed
alias ..="cd .." # this have saved a quite a lot of time for me

Combine commands

command1 && command2  # Run command2 only if command1 succeeds
command1 || command2  # Run command2 only if command1 fails

copy file contents

cat file.txt | pbcopy

Cleaning

df -h           # Disk usage
du -sh *        # Folder sizes
top             # Real-time process list
ps aux | grep xyz  # Check if a process is running

Configuration Files

# Bash
cat ~/.bash_profile   # Main configuration file
cat ~/.bashrc         # Profile configuration file

# Zsh (Mac)
cat ~/.zshrc          # Main configuration file
cat ~/.zprofile       # Profile configuration file

These files persist aliases or environment variables and your personal scripts, this is really helpful to customize the shell for your taste

✅ Use the Main configuration file for environment variables like JAVA PATH and others. ✅ Use the Profile Configuration File for aliases and other similar settings.

⚠️ Once you add your alias or update the profile configuration, you will need to re-start the terminal for the new configuration to come into effect.

I keep a copy of the profile configuration in git so i have access to my configurations both on my work and other systems if i need em.

Common commandline tool that is used often by me

• homebrew - package manager like npm
• ddgr - search from the commandline (DuckDuckGo)
• ollama - for local offline AI models for simple tasks and quires.
• zip/unzip – Compress/uncompress
• curl - API testing and others

“Warning: Terminal use may cause excessive productivity and happiness.” - Ollama 3.5