Basic Linux Commands | The grep Command – Your Text Search Master

grep Command – Your Text Search Master

Command Overview

In the world of Linux, the grep command is like a master of the art of searching. Its name comes from “Global Regular Expression Print,” which means it can perform global searches in text using regular expressions. This search master can not only find content in a single file but can also recursively search through an entire directory tree and even filter information from standard input.

What makes this search master most commendable is its proficiency with regular expressions. Whether it’s simple string matching or complex pattern searching, it can accurately find the content you need. In scenarios such as log analysis, code review, and text processing, this capability makes it an indispensable tool.

Syntax Format

grep [options] pattern [file...]

Common Parameters

Basic Parameters – The Toolbox of the Search Master

  • <span>-i</span>: Ignore case
  • <span>-v</span>: Invert match, show non-matching lines
  • <span>-n</span>: Show line numbers
  • <span>-r, -R</span>: Recursively search directories
  • <span>-l</span>: Show only matching file names
  • <span>-c</span>: Show only the count of matching lines
  • <span>-w</span>: Match whole words
  • <span>-x</span>: Match whole lines
  • <span>-A <number></span>: Show matching line and the following n lines
  • <span>-B <number></span>: Show matching line and the preceding n lines
  • <span>-C <number></span>: Show matching line and n lines before and after
  • <span>-E</span>: Use extended regular expressions
  • <span>-F</span>: Do not use regular expressions
  • <span>-o</span>: Show only the matching part

Common Examples

Basic Search

Example 1: Simple text search – Basic search

$ grep "error" log.txt
# Search for lines containing "error"

Example 2: Ignore case – Flexible search

$ grep -i "error" log.txt
# Case insensitive search for "error"

Advanced Search

Example 3: Using regular expressions – Pattern search

$ grep -E "[0-9]{3}-[0-9]{4}" contacts.txt
# Search for content in phone number format

Example 4: Recursive search – Deep search

$ grep -r "TODO" /path/to/project/
# Recursively search for "TODO" in the project directory

Context Display

Example 5: Show context – Contextual search

$ grep -C 2 "error" log.txt
# Show matching line and 2 lines before and after

Example 6: Show line numbers – Locating search

$ grep -n "function" script.js
# Show lines containing "function" and their line numbers

Practical Application Scenarios

Example 7: Log analysis

# Search for errors and count occurrences
$ grep -i "error" log.txt | sort | uniq -c

Example 8: Code review

# Search for all TODO comments
$ grep -r -n "TODO:" --include="*.{js,py,java}" .

Example 9: System log analysis

# Search for recent system errors
$ grep -i "error|failed|warning" /var/log/syslog

Example 10: File filtering

# Find configuration files containing specific content
$ grep -l "database_url" config/*

Advanced Techniques

Regular Expression Examples

  1. Match IP addresses:
$ grep -E "([0-9]{1,3}\.){3}[0-9]{1,3}" log.txt
  1. Match email addresses:
$ grep -E "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}" contacts.txt
  1. Match URLs:
$ grep -E "https?://[\w\.-]+\.[a-zA-Z]{2,}" links.txt

Combined Usage

  1. Using pipes to combine commands:
$ ps aux | grep "nginx"
# Find processes related to nginx
  1. Combine with wc for counting:
$ grep -c "ERROR" log.txt
# Count occurrences of errors
  1. Multi-condition search:
$ grep -E "error|warning|critical" log.txt
# Search for multiple keywords

Notes

Note 1: Be careful with escaping special characters when using regular expressions

Note 2: Be aware of performance impacts when recursively searching large directories

Note 3: Use the -a option when processing binary files

Note 4: Be cautious with file permissions when using the -r option

Note 5: It is recommended to test complex regular expressions on a small dataset first

Related Commands

  • <span>egrep</span>: Equivalent to grep -E
  • <span>fgrep</span>: Equivalent to grep -F
  • <span>sed</span>: Stream editor
  • <span>awk</span>: Text processing tool
  • <span>find</span>: File searching tool

Further Reading

Further 1: Detailed explanation of regular expressions

  • Basic Regular Expressions (BRE)
  • Extended Regular Expressions (ERE)
  • Perl Compatible Regular Expressions (PCRE)

Further 2: Performance optimization

  • Search strategy optimization
  • Regular expression optimization
  • Large file handling techniques

Further 3: Special application scenarios

  • Binary file searching
  • Multi-language environment handling
  • Special character handling

Further 4: Automation applications

  • Usage tips in scripts
  • Batch processing best practices
  • Error handling strategies

Practical Configuration

  1. Create common aliases:
# Add to ~/.bashrc
alias gp='grep -n'
alias gr='grep -r'
alias gi='grep -i'
  1. Set default colors:
# Add to ~/.bashrc
export GREP_COLORS='ms=01;31:mc=01;31:sl=:cx=:fn=35:ln=32:bn=32:se=36'
  1. Create functions to simplify complex searches:
# Add to ~/.bashrc
# Search and highlight
search() {
    local pattern="$1"
    local dir="${2:-.}"
    local type="${3:-*}"
    
    find "$dir" -type f -name "$type" -exec grep --color=auto -Hn "$pattern" {} \;
}

# Recursively search code files
codesearch() {
    local pattern="$1"
    local dir="${2:-.}"
    
    grep -r --include="*.{c,cpp,h,hpp,java,py,js,go,rs}" \
         --color=auto -n "$pattern" "$dir"
}

Advanced Applications – The Advanced Skills of the Search Master

Intelligent Search Tools

  1. Code Search Analyzer
#!/bin/bash
# Code search analysis tool
code_search_analyzer() {
    local pattern="$1"
    local dir="${2:-.}"
    local file_pattern="${3:-*.*}"
    local context=${4:-2}
    local temp_file="$(mktemp)"
    
    echo "=== Code Search Analysis Report ==="
    echo "Search Pattern: $pattern"
    echo "Directory: $dir"
    echo "File Type: $file_pattern"
    echo "Analysis Time: $(date '+%Y-%m-%d %H:%M:%S')"
    
    # Search code
    find "$dir" -type f -name "$file_pattern" | while read -r file; do
        # Get file type
        local ext="
        # Search matches
        grep -n -C "$context" "$pattern" "$file" > "$temp_file"
        
        if [ -s "$temp_file" ]; then
            echo "\n=== File: $file ==="
            cat "$temp_file"
            
            # Statistics
            local matches=$(grep -c "$pattern" "$file")
            echo "\nMatch Count: $matches"
            
            # Context analysis
            echo "Related Functions:" 
            grep -A 5 "^[[:space:]]*(def|function|class|void|int|char)" "$file" | \
                grep -B 5 "$pattern"
        fi
    done
    
    rm -f "$temp_file"
}
  1. Log Search Analyzer
#!/bin/bash
# Log search analysis tool
log_search_analyzer() {
    local pattern="$1"
    local log_file="$2"
    local context=${3:-2}
    local temp_file="$(mktemp)"
    
    echo "=== Log Search Analysis Report ==="
    echo "Search Pattern: $pattern"
    echo "Log File: $log_file"
    echo "Analysis Time: $(date '+%Y-%m-%d %H:%M:%S')"
    
    # Basic statistics
    echo "\n=== Basic Statistics ==="
    echo "Total Match Count: $(grep -c "$pattern" "$log_file")"
    echo "First Occurrence Time: $(grep -m 1 "$pattern" "$log_file" | awk '{print $1, $2}')"
    echo "Last Occurrence Time: $(grep "$pattern" "$log_file" | tail -n 1 | awk '{print $1, $2}')"
    
    # Time distribution
    echo "\n=== Time Distribution ==="
    grep "$pattern" "$log_file" | awk '{print $1}' | sort | uniq -c
    
    # Context analysis
    echo "\n=== Context Analysis ==="
    grep -C "$context" "$pattern" "$log_file" > "$temp_file"
    if [ -s "$temp_file" ]; then
        cat "$temp_file"
    fi
    
    # Related errors
    echo "\n=== Related Errors ==="
    grep -B "$context" -A "$context" "$pattern" "$log_file" | \
        grep -i "error|warning|fail" | sort | uniq -c
    
    rm -f "$temp_file"
}

Automation Tools

  1. Code Quality Checker
#!/bin/bash
# Code quality check tool
code_quality_checker() {
    local dir="$1"
    local patterns_file="${2:-patterns.txt}"
    
    echo "=== Code Quality Check Report ==="
    echo "Directory: $dir"
    echo "Check Time: $(date '+%Y-%m-%d %H:%M:%S')"
    
    # Check TODO and FIXME
    echo "\n=== TODO Check ==="
    grep -r -n "TODO\|FIXME" "$dir"
    
    # Check debug code
    echo "\n=== Debug Code Check ==="
    grep -r -n "console\.log\|print\|debug" "$dir"
    
    # Check hardcoding
    echo "\n=== Hardcoding Check ==="
    grep -r -n "localhost\|root\|password\|admin" "$dir"
    
    # Check code standards
    if [ -f "$patterns_file" ]; then
        echo "\n=== Code Standards Check ==="
        while read -r pattern; do
            echo "Check Pattern: $pattern"
            grep -r -n "$pattern" "$dir"
        done < "$patterns_file"
    fi
}
  1. Security Audit Tool
#!/bin/bash
# Security audit tool
security_audit() {
    local dir="$1"
    local report_file="${2:-security_report.txt}"
    
    {
        echo "=== Security Audit Report ==="
        echo "Directory: $dir"
        echo "Audit Time: $(date '+%Y-%m-%d %H:%M:%S')"
        
        # Check passwords and keys
        echo "\n=== Sensitive Information Check ==="
        grep -r -n "password\|secret\|key\|token" "$dir"
        
        # Check potential SQL injection
        echo "\n=== SQL Injection Risk Check ==="
        grep -r -n "SELECT\|INSERT\|UPDATE\|DELETE.*\$" "$dir"
        
        # Check security configurations
        echo "\n=== Security Configuration Check ==="
        grep -r -n "ssl\|tls\|http:" "$dir"
        
        # Check debug mode
        echo "\n=== Debug Mode Check ==="
        grep -r -n "debug\|development\|test" "$dir"
        
    } > "$report_file"
    
    echo "Security audit report generated: $report_file"
}

Best Practices – Insights from the Search Master

Performance Optimization

  1. Search Strategy

  • Use appropriate options:

    # Use -F for fixed string search to avoid regex overhead
grep -F "exact string" file.txt

# Use -w for word matching to avoid partial matches
grep -w "word" file.txt

# Use -l to show only file names to improve efficiency in searching many files
grep -l "pattern" *.txt

  • Optimize regular expressions:

    # Use non-greedy matching to reduce backtracking
grep -P "a+?b" file.txt

# Use atomic groups to avoid unnecessary backtracking
grep -P "(?>[a-z]+)\d" file.txt

# Use character classes to optimize range matching
grep "[[:digit:]]" file.txt

  • Limit search scope:

    # Specify search depth
find . -maxdepth 2 -type f -exec grep "pattern" {} \;

# Exclude specific directories
grep -r "pattern" --exclude-dir={.git,node_modules} .

# Limit file types
grep "pattern" --include="*.{c,h}" -r .

  • Utilize caching mechanisms:

    # Use mlocate database to speed up file searches
locate "*.txt" | xargs grep "pattern"

# Use tmpfs to store temporary search results
grep "pattern" file.txt > /dev/shm/results.txt

  • Efficiency Improvement

    • Parallel processing:

      # Use xargs for parallel processing
find . -type f | xargs -P 4 -I {} grep "pattern" {}

# Use parallel command
parallel "grep 'pattern' {}" ::: *.txt

# Split large files for processing
split -l 1000000 large.txt split_ && \
parallel "grep 'pattern' {}" ::: split_*

    • Incremental search:

      # Use inotifywait to monitor file changes
inotifywait -m -e modify file.txt | \
while read; do grep "pattern" file.txt; done

# Record last search time
find . -type f -newer timestamp.txt -exec grep "pattern" {} \;

    • Index building:

      # Create text index
cat file.txt | tr ' ' '\n' | sort | uniq -c > index.txt

# Use ctags to build code index
ctags -R . && grep "function" tags

    • Result filtering:

      # Use awk for precise filtering
grep "pattern" file.txt | awk '$2 ~ /specific/'

# Use sed to process matching results
grep "-o" "pattern.*" file.txt | sed 's/unwanted//g'

    Usage Tips

    1. Regular Expressions

    • Pattern design:

      # Match email addresses
grep -E "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"

# Match URLs
grep -E "https?://[\w\.-]+\.[a-zA-Z]{2,}/[\w\./\-]*"

# Match IP addresses
grep -E "([0-9]{1,3}\.){3}[0-9]{1,3}"

    • Special characters:

      # Use character classes
grep "[[:space:]]pattern" file.txt

# Use boundary matching
grep "<word>" file.txt

# Use negated character sets
grep "[^0-9]" file.txt

    • Capture groups:

      # Use backreferences
grep -E "(\w+)=\1" file.txt

# Named capture groups (requires -P option)
grep -P "(?<year>\d{4})-(?<month>\d{2})"

# Non-capturing groups
grep -E "(?:https?|ftp)://" file.txt

    • Backtracking control:

      # Use atomic groups
grep -P "(?>\w+)\s" file.txt

# Use lookahead assertions
grep -P "\w+(?=\s)" file.txt

# Use lookbehind assertions
grep -P "(?<=\s)\w+" file.txt

  • Tool combination:

    • Pipe processing:

      # Multiple filtering
grep "error" log.txt | grep -v "debug" | grep "critical"

# Combine sorting and deduplication
grep -o "[0-9]+" file.txt | sort -n | uniq -c

# Combine multiple commands
find . -type f -exec grep -l "pattern" {} \; | xargs wc -l

    • Result filtering:

      # Use cut to extract specific fields
grep "pattern" file.txt | cut -d',' -f2,3

# Use sed to process matching lines
grep "pattern" file.txt | sed 's/old/new/g'

# Use awk for complex processing
grep "pattern" file.txt | \
awk '{sum += $2} END {print "Average:", sum/NR}'

    • Statistical analysis:

      # Count matches
grep -o "pattern" file.txt | wc -l

# Count by category
grep "pattern" file.txt | cut -d',' -f1 | sort | uniq -c

# Generate summary report
grep "error" log.txt | \
awk '{count[$3]++} END {for(i in count) print i, count[i]}'

    • Formatted output:

      # Custom output format
grep -n "pattern" file.txt | \
awk -F: '{printf "Line %s: %s\n", $1, $2}'

# Add color highlighting
grep --color=always "pattern" file.txt

# Generate HTML report
grep "pattern" file.txt | \
awk '{print "<li>" $0 "</li>"}' > report.html

    Security Considerations

    1. Input validation

    • Special character handling:

      # Escape special characters
pattern=$(printf '%q' "$user_input")
grep "$pattern" file.txt

# Use fixed string matching
grep -F "$user_input" file.txt

# Validate input format
if [[ "$input" =~ ^[a-zA-Z0-9]+$ ]]; then
    grep "$input" file.txt
fi

    • Command injection protection:

      # Wrap variables in quotes
grep "${pattern}" "${file}"

# Check input validity
if [[ "$file" != *";"* && "$file" != *"|"* ]]; then
    grep "pattern" "$file"
fi

    • Path traversal protection:

      # Normalize path
file=$(realpath "$input_file")
if [[ "$file" =~ ^/allowed/path/ ]]; then
    grep "pattern" "$file"
fi

# Limit search scope
grep -r "pattern" --exclude-dir="../" .

    • Permission control:

      # Check file permissions
if [[ -r "$file" ]]; then
    grep "pattern" "$file"
fi

# Limit file owner
find . -user "$USER" -type f -exec grep "pattern" {} \;

  • Result handling

    • Sensitive information filtering:

      # Mask password information
grep "password" file.txt | sed 's/password=[^[:space:]]*/password=****/g'

# De-sensitization
grep "[0-9]\{16\}" file.txt | sed 's/\([0-9]\{12\}\)[0-9]\{4\}/\1****/g'

    • Error handling:

      # Check command execution status
if ! grep -q "pattern" file.txt; then
    echo "Pattern not found or error occurred"
    exit 1
fi

# Handle file not found situation
for file in *.txt; do
    [[ -f "$file" ]] || continue
    grep "pattern" "$file" || echo "Error in $file"
done

    • Logging:

      # Log search operations
grep "pattern" file.txt 2>&1 | \
tee -a search.log

# Format log output
grep "pattern" file.txt | \
logger -t "search_script" -p user.info

    • Output filtering:

      # Remove special characters
grep "pattern" file.txt | tr -cd '[:print:]\n'

# Limit output length
grep "pattern" file.txt | cut -c1-80

    Further Reading – Advanced Courses for the Search Master

    Technical Depth

    1. Implementation Mechanism

    • Search algorithms:

      # Boyer-Moore algorithm example (fixed string search)
grep -F "pattern" file.txt

# Regular expression engine selection
grep -P "(?<=look)behind" # PCRE engine
grep -E "extended|regex" # ERE engine

    • Regular expression engines:

      # Basic regular expressions (BRE)
grep "pattern" file.txt

# Extended regular expressions (ERE)
grep -E "pattern+" file.txt

# Perl compatible regular expressions (PCRE)
grep -P "(?<=pattern)" file.txt

    • Memory management:

      # Stream processing of large files
tail -f large.log | grep --line-buffered "pattern"

# Limit memory usage
grep --mmap "pattern" large.txt

    • System calls:

      # Use strace to analyze system calls
strace -e trace=file grep "pattern" file.txt

# Optimize file system access
grep -r --devices=skip --directories=skip "pattern" .

  • Performance Characteristics

    • Resource consumption:

      # Monitor CPU usage
time grep -r "pattern" /path

# Memory usage analysis
/usr/bin/time -v grep "pattern" large.txt

    • Concurrent processing:

      # Multi-process search
find . -type f -print0 | \
xargs -0 -P $(nproc) -I {} grep "pattern" {}

# Load balancing
parallel --load 80% grep "pattern" ::: *.txt

    • Cache mechanisms:

      # File system cache
echo 3 > /proc/sys/vm/drop_caches
grep "pattern" file.txt

# Use ramdisk for acceleration
grep "pattern" /dev/shm/file.txt

    • Optimization strategies:

      # IO optimization
nice -n 19 grep -r "pattern" /path

# Buffer adjustments
grep --line-buffered "pattern" file.txt

    Advanced Features

    1. Special applications

    • Binary search:

      # Search binary files
grep -a "pattern" binary.file

# Hexadecimal search
grep -P "\x48\x45\x4C\x4C\x4F" binary.file

    • Distributed search:

      # SSH remote search
for host in $(cat hosts.txt); do
    ssh $host "grep 'pattern' /var/log/*.log"
done

# Parallel remote search
parallel -S host1,host2 grep "pattern" ::: *.txt

    • Real-time processing:

      # Real-time log monitoring
tail -f log.txt | grep --line-buffered "error"

# Event-triggered search
inotifywait -m -e modify file.txt | \
while read; do grep "pattern" file.txt; done

    • Incremental updates:

      # Incremental log analysis
grep "pattern" <(tail -f file.txt)

# Difference comparison search
diff old.txt new.txt | grep "^+" | grep "pattern"

  • Tool integration:

    • Version control:

      # Git history search
git grep "pattern" $(git rev-list --all)

# Commit message search
git log -G "pattern" --patch

    • Continuous integration:

      # Jenkins build log analysis
curl -s $BUILD_URL/consoleText | grep "error"

# Automated test result analysis
find test-results/ -name "*.xml" -exec grep "failure" {} \;

    • Code review:

      # Code quality check
grep -r "TODO|FIXME|XXX" .

# Security vulnerability scanning
grep -r "eval\|exec\|system" .

    • Security scanning:

      # Sensitive information detection
grep -r "password\|secret\|key" .

# Vulnerability pattern matching
grep -r "CVE-[0-9]\{4\}-[0-9]\{4,\}" .

    Best Practices

    1. Development Tools

    • IDE plugins:

      # VSCode integration
code --install-extension grep-console

# Sublime Text command palette
subl --command "grep_in_folder"

    • Command line tools:

      # Create search alias
alias gsearch='grep -r --color=always'

# Create search function
search() {
    grep -r "$1" "${2:-.}"
}

    • Script framework:

      #!/bin/bash
# Advanced search script
search_files() {
    local pattern="$1"
    local path="${2:-.}"
    find "$path" -type f -exec grep -l "$pattern" {} \;
}

    • Automation tools:

      # Monitoring script
while true; do
    grep "error" log.txt | notify-send "Error detected"
    sleep 60
done

  • Operations Tools

    • Log analysis:

      # Error statistics
grep "ERROR" /var/log/*.log | \
awk '{print $1}' | sort | uniq -c

# Performance monitoring
grep "response_time" access.log | \
awk '{sum+=$1} END {print "avg:",sum/NR}'

    • Monitoring systems:

      # System health check
grep "OOM|OutOfMemory" /var/log/syslog

# Service status monitoring
grep "service.*failed" /var/log/messages

    • Audit tools:

      # User activity audit
grep "session opened" /var/log/auth.log

# File access audit
grep "accessed" /var/log/audit/audit.log

    • Report generation:

      # HTML report
grep "ERROR" log.txt | \
awk '{print "<tr><td>"$1"</td><td>"$2"</td></tr>"}' \
> report.html

# Statistical report
grep -r "exception" logs/ | \
awk '{count[$1]++} \
END {for(i in count) print i,count[i]}' | \
sort -nrk2 > report.txt

    Practical Tips

    1. Intelligent log analysis:
    # Analyze error logs and count
log_analyze() {
    local log_file="$1"
    local pattern="${2:-error}"
    
    echo "=== Log Analysis Report ==="
    echo "File: $log_file"
    echo "Pattern: $pattern"
    
    echo "\n=== Error Statistics ==="
    grep -i "$pattern" "$log_file" | sort | uniq -c | sort -nr
    
    echo "\n=== Time Distribution ==="
    grep -i "$pattern" "$log_file" | awk '{print $1}' | sort | uniq -c
}
    1. Code search:
    # Search for specific patterns in code
code_search() {
    local pattern="$1"
    local dir="${2:-.}"
    
    find "$dir" -type f -name "*.{c,cpp,h,java,py,js,go}" | \
        while read -r file; do
            echo "=== $file ==="
            grep -n -C 2 "$pattern" "$file"
        done
}
    1. Security check:
    # Check for sensitive information
security_check() {
    local dir="$1"
    
    echo "=== Security Check ==="
    grep -r -n \
        -e "password" \
        -e "secret" \
        -e "token" \
        -e "key" \
        "$dir"
}
    1. Performance analysis:
    # Analyze slow requests in logs
slow_requests() {
    local log_file="$1"
    local threshold="${2:-1000}"
    
    grep "duration" "$log_file" | \
        awk -v t="$threshold" '$NF > t {print}' | \
        sort -k NF -nr | head -n 10
}
    1. Code review:
    # Code quality check
code_review() {
    local dir="$1"
    
    echo "=== Code Review ==="
    echo "\n=== TODO Check ==="
    grep -r -n "TODO" "$dir"
    
    echo "\n=== Debug Code Check ==="
    grep -r -n "console.log\|print\|debug" "$dir"
    
    echo "\n=== Hardcoding Check ==="
    grep -r -n "localhost\|root\|admin" "$dir"
}

    # Add to ~/.bashrc
function search_code() {
    grep -r --include="*.{$2}" "$1" .
}
# Usage: search_code "pattern" "js,py,java"

    Common Problem Solutions

    1. Handling special characters:
    # Search for content containing special characters
$ grep -F "[special]" file.txt
    1. Handling large files:
    # Use LC_ALL=C to improve performance
$ LC_ALL=C grep "pattern" large_file.txt
    1. Handling encoding issues:
    # Specify file encoding
$ grep --binary-files=text -i "pattern" utf8_file.txt

    <span>#Linux commands</span> #grep command #text processing #regular expressions #log analysis #operations management #linux beginner’s guide

    Related posts

    1. Creating and Deleting Directories in C++
    2. Applications of C Language in the Internet of Things: Device Communication and Data Processing
    3. How to Check Port Usage in Linux
    4. Overview of Seven Major Desktop Environments on Linux
    5. Understanding Linux Folios: A New Approach to Memory Management
    6. Linux btop Usage Tutorial
    7. Essential for Linux Beginners! The fuser Command: Easily Understand the Relationship Between Files and Processes
    8. Is Nitrux 3.9.1 Worth Upgrading? Designed for a Modern Linux Experience!
    9. Analysis of Packet Loss Issues in Linux Server Network Interfaces – Final Part
    10. Viewing Remote Login User Status in Linux
    11. Basic Linux Tutorial
    12. Top 8 Notepad++ Alternatives for Linux in 2025
    13. What is PLC? Classification and Functions Explained in Detail!
    14. Linux System Common Commands Quick Reference Guide
    15. A Beautiful Shell for Linux
    16. Pillow-SIMD: The Supercharged Version of Image Processing!
    17. Linux | I.MX6ULL Peripheral Function Verification (Day 10)
    18. Create Your First Progress Bar Application with Linux
    19. Ten Cool Linux Commands for Stunning Effects

    Leave a Comment