DEV Community: Pragmatic Programmer

Inbox Zero Workflow: Filters, Labels, and Shortcuts That Actually Work

Pragmatic Programmer — Sat, 12 Apr 2025 01:12:58 +0000

Note: This workflow was originally created in 2016 and is being edited/republished in 2025.

In the early days of email—AOL, Yahoo, Hotmail—it felt exciting to get a message.

Now, email is mostly noise. Work threads, newsletters, order confirmations, social updates, and spam pile up quickly. The inbox becomes unusable.

At one point, I had thousands of unread messages. Important emails would get buried.

I needed a system—not a one-time cleanup, but a way to keep it under control.

Gmail’s built-in features—filters, labels, and keyboard shortcuts—turned out to be enough.

What used to take an hour now takes minutes.

This post shares how I use those features, with examples and a workflow that helps me get through email quickly every day.

I have been sharing this cheat sheet with friends and family for years now.

Here it is for everyone—I hope this helps.

Prerequisite

Gmail Settings Tip:

To use keyboard shortcuts, you need to enable them in Gmail settings first.

Go to Gmail → Settings (⚙) → See all settings → General tab → Keyboard shortcuts → Turn ON,

then scroll down and click Save Changes.

Foundation: Filters and Labels

Labels are like folders, but more flexible. You can:

Apply multiple labels to a single message
Create nested labels (e.g., orders/amazon)
Assign colors for quick visual scanning

Filters are rules that automatically sort incoming email based on sender, subject, keywords, attachments, etc.

I use filters and auto-labels to prioritize my inbox.

This helps me visually scan and take action on important emails while filtering out routine or low-priority messages.

Note on Archiving

The Inbox in Gmail shows only messages that are not archived.

When you archive an email, it's removed from the inbox but not deleted.

So when a filter applies “Skip the Inbox” + “Apply label”, the message is out of sight, but still retrievable.

My Workflow

If the selected email is...	Action to Take	Shortcut / Method
Junk / No longer needed	Delete it	`#` (Shift + 3)
Useful for reference, but needs no action	Archive it (remove from inbox)	`e`
Belongs in a specific project/topic	Move to label (archives + labels)	`v` → type label name, `Enter`
Needs action, but not right now	Snooze it (hide until needed)	`b` (then choose time)
—	Pro Tip: Star (`s`) it first	I use this for tickets, appointments, etc.
Important / Needs follow-up (not snoozed)	Star it	`s`
Needs to be read fully	Open it	`o` or `Enter`
Finished with it	Archive / Delete / Move / Snooze	`e` / `#` / `v` / `b`
Go back to inbox list	Return to inbox	`u`
Schedule a task/meeting from it	Create calendar event	Open → `⋮ More` → `Create event`
Made a mistake (archive/delete)	Undo the last action	`z`

The Gmail Keyboard Shortcut Cheatsheet

Key / Feature	Action	Notes / My Use Case
`j`	Move selection down	Navigate email list
`k`	Move selection up	Move back up the list
`o` / `Enter`	Open conversation	Read full email
`u`	Return to inbox list	After opening or acting on email
`x`	Toggle selection	For bulk action
`e`	Archive	My most-used shortcut
`#` (Shift + 3)	Delete	Remove irrelevant mail
`b`	Snooze	Hide now, show up later
`v`	Move to... label	Archive + label in one
`l`	Label as... (no archive)	Tag without moving
`s`	Star / Unstar	Flag for later / mark important
`!` (Shift + 1)	Report as spam	For junk / phishing
`z`	Undo last action	Quick recovery from misclick
`?` (Shift + /)	Show shortcut help	View all shortcuts in Gmail

Final Thoughts

This isn’t a complete system or productivity advice.

Just what I do to keep email under control.

Filters reduce inbox clutter
Shortcuts speed up triage
It took a bit of practice, but now it’s second nature

It’s not about perfection—I still occasionally have hundreds of emails.

But the system helps me stay clear on what needs attention and what doesn’t.

Over time, muscle memory builds, and the process becomes natural.

This isn’t rigid. It’s just structure that helps keep email manageable.

Use what’s useful. Skip what isn’t.

# Automate Your Mac Setup: A Developer’s Guide

Pragmatic Programmer — Thu, 03 Apr 2025 18:42:40 +0000

Setting up a new Mac for development can be tedious. Installing tools, configuring the shell, and tweaking settings by hand often takes hours and can vary between machines. After years of doing this manually across multiple devices, I created an automated setup to handle it more efficiently.

This post outlines a tool that cuts Mac setup time to about an hour. It’s something I’ve used myself and shared with others, like when I set up my son’s Mac mini. You can find it on GitHub at ravishan16/dotFile. Feel free to try it, tweak it, or suggest improvements.

Why Automate?

Manual setups have drawbacks. Automation offers a few clear advantages:

Saves Time: Drops setup from several hours to roughly one by handling repetitive tasks.
Keeps Things Consistent: Applies the same configuration every time, avoiding differences between machines.
Simplifies Replication: Makes it easy to set up new devices or assist someone else.
Tracks Changes: Uses Git to manage your environment, so you can see or undo modifications.
Speeds Recovery: Re-runs quickly if you reset your system.
Teaches Skills: Shows how shell scripting and configuration work if you dig into the code.

These points come from real experience, not hypotheticals.

What’s in the Setup?

The repository (ravishan16/dotFile) includes scripts and files to automate a developer environment on macOS. Here’s what it covers:

Installation Scripts (scripts/):
- Homebrew: Manages CLI tools and GUI apps.
- CLI Tools: Adds git, node, ripgrep, and more (check 02_install_brew_core.sh).
- GUI Apps: Installs VS Code, iTerm2, Docker, Raycast, etc. (see 06_install_apps_cask.sh).
- Shell Setup: Installs Zsh with Oh My Zsh and plugins like zsh-autosuggestions, zsh-syntax-highlighting, and autojump for a better terminal.
- Python: Sets up Miniconda for isolated Python environments.
- Git & SSH: Configures Git and creates SSH keys for GitHub access.
- Rust: Installs Rust and Cargo via rustup for managing Rust projects and tools like mdBook (see 09_install_rust.sh). * Dotfiles (dot/):
- Includes .zshrc, .aliases, .gitignore_global, and others.
- Symlinks these to your home directory so updates in the repo apply instantly.
Docs (docs/):
- Offers guides on Homebrew, Zsh, Git, Conda, Docker, Rust, and macOS shortcuts.
- These guides are built into an online book using mdBook (installed via script 09) and published automatically via GitHub Actions. It’s a straightforward package to get a working dev setup with minimal effort.

It’s a straightforward package to get a working dev setup with minimal effort.

Guides (Published via mdBook)

The detailed guides for installation and tool usage are maintained as Markdown files in the /docs directory. They are automatically built into an online book using mdBook and published via GitHub Actions to GitHub Pages.

📚 Access the Online Guides Here You can also build and view the guides locally:

Ensure you have Rust and mdbook installed (script 09_install_rust.sh handles this).
Navigate to the repository root directory.
Run mdbook serve --open.

Guide Title	Description
dotFile: Installing Your Automated macOS Setup	Step-by-step guide to set up your macOS environment with automation.
Managing Software with Homebrew 🍺	Learn how to install, update, and manage software using Homebrew.
Using Your Zsh Shell Superpowers ✨	Tips and tricks for using Zsh with Oh My Zsh, Powerlevel10k, and plugins.
Basic Git & GitHub Workflow	A beginner-friendly guide to using Git and GitHub for version control.
Managing Python with Conda (Miniconda)	Guide to managing Python environments and packages with Conda.
Basic Docker Maintenance 🐳🧹	Learn how to prune and clean up Docker containers, images, and volumes.
Your Terminal Command Center (iTerm2) 💻	Guide to customizing and using iTerm2 for an efficient terminal experience.
Rust Essentials Guide 🦀	Quick reference for essential Rust and Cargo commands.
Mac Keyboard Shortcut Cheat Sheet ⚡️	A handy list of keyboard shortcuts to boost your productivity on macOS.
Basic Mac Housekeeping 🧹✨	Tips for keeping your Mac clean, organized, and running smoothly.
Custom Shell Aliases & Functions 🛠️	Learn how to create and use custom aliases and functions in your shell.
Redis Cheatsheet for macOS 🍎	Quick commands and tips for installing, managing, and using Redis on macOS.

How to Run It

Here’s how to use the setup on your Mac:

Fork the Repo: Go to ravishan16/dotFile and fork it to your account.

Clone It: Pull it down to your machine:

mkdir -p ~/projects/git
cd ~/projects/git
git clone <your-fork-url> dotFile

Set Up .env: Copy the example and fill it in:

cp .env_example .env # Or touch .env if no example exists
nano .env

Add:

GIT_HOME="~/projects/git" # Adjust if you cloned elsewhere
GIT_AUTHOR_NAME="Your Name"
GIT_AUTHOR_EMAIL="your.email@example.com"

Edit Dotfiles: Tweak dot/.zshrc, dot/.aliases, or others to fit your needs.
Run the Script: Go to the scripts folder and start it:
```
cd ~/projects/git/dotFile/scripts
bash run_all.sh
```
Pick "all" from the menu and enter your password when asked.
Finish Up:
- Restart your terminal.
- Add the SSH key to GitHub (script will guide you).
- Log into any GUI apps like Docker.

After this, your Mac will have a configured dev environment, including Zsh with Oh My Zsh and plugins.

How to Customize

You can adjust the setup to suit your workflow:

Change Tools: Edit 02_install_brew_core.sh for CLI tools or 06_install_apps_cask.sh for apps.
Tune the Shell: Modify dot/.zshrc for Zsh settings or dot/.p10k.zsh for the prompt (run p10k configure to update it).
Update Python: Adjust python/requirements.txt and re-run script 05 for Conda packages.

Forking the repo lets you make it your own.

Get Involved

This setup works for me, but it’s better with input from others. Here’s how you can help:

Fork It: Adapt it for yourself.
Submit Pull Requests: Share fixes or new features.
Open Issues: Flag bugs or ideas.
Give Feedback: Tell me what’s useful or what’s not.

Contributions keep it practical and relevant.

Wrapping Up

Automating your Mac setup cuts down on time and hassle. This tool gets you a consistent dev environment with Zsh, Oh My Zsh, and plugins included, so you can focus on coding.

Check it out: ravishan16/dotFile

If it helps or you’ve got thoughts, let me know. I’d like to see it grow into something developers can rely on.

Beyond the Hype: A Practical Guide to Cloud and Datacenter Decisions

Pragmatic Programmer — Tue, 01 Apr 2025 22:47:55 +0000

The technology infrastructure landscape is perpetually in flux. Recent attention on companies like CoreWeave($CRWV), particularly following their recent IPO and focus on bare-metal GPU rentals for AI/ML workloads, has brought the long-standing datacenter versus cloud computing debate back into focus. While hyperscalers – massive-scale cloud providers like AWS and Azure known for their vast global infrastructure and comprehensive service suites – offer predominantly virtualization-based services (alongside bare-metal options), the demand for raw compute power highlights diverse infrastructure needs. This necessitates a clear-eyed look at the fundamental trade-offs involved, moving beyond marketing hype to examine the practical implications for different business requirements.

The Case for Cloud: Flexibility and Agility

Cloud computing's primary appeal lies in its adaptability, especially valuable for projects facing uncertainty or fluctuating demands.

Scalability: The capacity to rapidly provision and de-provision resources (elasticity) is crucial during development, testing, and for applications with variable user load. This agility enables quick iteration and responsiveness.
Pay-as-you-go Model: This operational expenditure (OpEx) model eliminates the large upfront capital expenditure (CapEx) typically required for hardware procurement. However, for consistent, high-utilization workloads, these recurring costs can eventually surpass the total cost of ownership for dedicated hardware.
Global Reach: Major cloud providers maintain vast global networks of datacenters, enabling organizations to deploy services closer to end-users, potentially reducing latency and improving user experience.
Managed Services: Cloud platforms offer a wide array of managed services (databases, queues, machine learning platforms, etc.) that can accelerate development by abstracting away underlying infrastructure management.

The Case for Datacenters: Control and Predictability

For organizations with stable, predictable workloads, or those with specific performance, security, or regulatory requirements, traditional or co-located datacenters offer distinct advantages.

Control: Direct ownership and management of hardware allow for deep customization of network and server configurations, potentially optimizing for specific performance characteristics.
Cost Efficiency (Long-Term): For sustained, predictable workloads, the initial CapEx for hardware and facilities can lead to lower long-term costs compared to equivalent, continuously running cloud resources.
Predictable Performance: Dedicated hardware can offer more consistent performance characteristics compared to multi-tenant virtualized environments, although cloud providers also offer dedicated instances.
Data Residency & Security: Direct control can simplify meeting strict data residency requirements and allows organizations to implement bespoke security measures.

Cloud First, Datacenter Next: A Pragmatic Approach

Launching a new product—whether at a startup or within a big company—comes with a big challenge: predicting compute needs. How much processing power, storage, or bandwidth will you require? Guessing wrong can waste time and money, and locking into hardware early limits your ability to adapt. A smarter move? Start in the cloud, scale as you go, and optimize with a datacenter or tailored setup once you’ve got solid data.

Why Forecasting Is Tough: Estimating workloads for an untested product is a shot in the dark. Customer adoption, usage patterns, and shifting requirements defy precise planning. Build a datacenter too big, and you’re stuck with unused capacity; too small, and performance tanks when demand spikes. This uncertainty makes traditional infrastructure risky for new ventures.

Cloud as an Initial Platform: The cloud's elasticity and OpEx model mitigate this initial risk, allowing teams to scale resources based on actual usage data and user feedback, rather than projections. This facilitates experimentation and data gathering without significant upfront investment.

Data-Driven Transition: Once a product matures and usage patterns stabilize, the data collected during the cloud phase enables informed decisions about long-term infrastructure. This might involve:

Optimizing cloud usage (right-sizing instances, using reserved instances/savings plans).
Migrating specific, stable workloads to dedicated hardware (in a datacenter or co-location facility).
Adopting a hybrid model, balancing cloud flexibility with datacenter control/cost-efficiency.

A notable example comes from Amazon's Prime Video Video Quality Analysis team. As detailed on their tech blog, they achieved significant cost savings (reportedly over 90% for that specific service) by re-architecting their audio/video monitoring service, moving components from a serverless approach (using Step Functions and distributed Lambda functions) to a more consolidated model running on EC2 and ECS, once usage patterns and bottlenecks were well understood.

Key Considerations and Caveats

Factor	Cloud Consideration	Datacenter Consideration
Cost Structure	Variable OpEx can spiral without governance; potential for higher TCO on steady loads.	Significant CapEx & lead times; potentially lower TCO long-term for steady loads.
Scalability & Agility	Elastic scaling; complexity can increase with scale/abstractions.	Constrained by physical installs & planning cycles; less immediate elasticity.
Maintenance & Operations	Provider handles underlying infrastructure maintenance.	Requires dedicated resources & expertise for hardware/software upkeep, facilities management.
Control & Customization	Limited by provider offerings and abstraction layers.	Full hardware/software control allows deep customization.
Security & Compliance	Shared responsibility model; requires careful customer configuration & oversight.	Full responsibility; direct control can simplify meeting specific residency or security requirements.
Platform Dependence	Potential vendor lock-in via proprietary services complicates migration.	Less platform lock-in, but dependent on specific hardware/software choices; migration still involves effort.

Real-World Perspectives

Prime Video (Monitoring Service): As mentioned, their optimization illustrates how understanding specific workload characteristics can drive significant cost savings, sometimes involving shifts within or away from certain cloud architectures.
Prime Vidoe Tech Blog
Amazon Prime Statistics
37signals (Basecamp/Hey): Their public decision to repatriate workloads from the cloud, citing substantial cost savings ($7 million over five years projected), underscores that for companies with predictable usage and the necessary scale/expertise, owning hardware can be significantly more economical.Hey Blog
Bare Metal Cloud (e.g., CoreWeave, Equinix Metal): These providers aim to bridge the gap, offering the raw performance and control closer to dedicated hardware but with cloud-like provisioning and OpEx models. They are particularly appealing for several use cases:
- Foundational Layer: Serving as automated hardware for building private clouds or running specific orchestration layers (like VMWare, OpenStack, Kubernetes).
- High-Performance Needs: Addressing sustained, predictable performance requirements often best met by dedicated, single-tenant hardware without a virtualization layer (common in HPC, Gaming, AI/Big Data, Finance).
- Security & Isolation: Meeting strict trust, privacy, or regulatory mandates that necessitate dedicated, isolated environments rather than shared multi-tenant cloud resources.
- Specialized Requirements: Supporting applications needing specific hardware features (GPUs, accelerators, encryption offload) or ultra-low latency not readily available or performant in standard virtualized environments (e.g., video transcoding, AR/VR, Telco workloads, AI/ML training/inference).

Conclusion: Context is Key

The choice between cloud, datacenter, or a hybrid approach is not universally fixed but depends heavily on an organization's specific technical requirements, business goals, workload characteristics, budget, risk tolerance, and in-house expertise. A critical evaluation of the trade-offs, informed by real-world data and strategic planning, is essential. Often, a hybrid or multi-cloud strategy emerges as the most practical solution, leveraging the best of both worlds.

Disclaimer

This blog does not examine CoreWeave’s valuation, financial performance, or specific business metrics. Rather, CoreWeave serves as a real-world example to facilitate a broader discussion on bare metal infrastructure versus cloud services. The emphasis is on technical and strategic aspects rather than financial details.

Flatfile + DBeaver + SQL = Productivity

Pragmatic Programmer — Tue, 26 May 2020 00:21:38 +0000

Flat files come in different shapes and sizes. Excel is powerful to analyze and manipulate data. It can get overwhelming for complex analysis. If you want to run SQL queries on large flat files, typically, you import the data into a PostgreSQL/SQLite/MySQL or database of your preference. Another useful tool for quick analysis is using DBeaver, a popular database developer tool. We can use DBeaver's CSV connection and custom shell functions to be more productive.

Github Repository Link

Usecases

query filter/group by or run simple SQL operation on a CSV or any delimited file
Don't want to create a new DBeaver connection for every file/folder

Solution

create a folder that can be used for flat files
create child folders CSV, pipe, TSV .... so independent connections can be created for different file types in DBeaver. Here is my folder structure

├── data
│   ├── csv
│   │   └── dataset_csv_dat.csv
│   └── pipe
│       └── test_pipe_delimited_dat.csv

One Time Setup

create DBeaver connection for csv and set the path to data/csv
create DBeaver connection for pipe or any delimited file type, set the path to data/pipe(or the format of your choice). Update the separator in "Driver Properties."
Add this shell function to ~/.zshrc or ~/.bash_profile. This function takes two parameters parameter 1 is the filetype (match the child folders) and the second parameter is file path. When executed the function copies the file to the child folder (parameter one) and renames the file with a .csv extension

#usage setdb pipe foo.dat or setdb bar.csv
#open CSV/TSV/PIPE delimited file in DBeaver
#set your DIRECTORY to folder where you wan to root directory where you want to store csv/tsv
# ARgument 1 is csv/tsv/pipe you also should create a folder under the db_root for csv/pipe or what ever delimiter
function setdb(){
    db_root=flatfile_dbeaver/data
    #Take file basename
    orig_filename="$(basename $2)"
    #replace . with _
    filename=${orig_filename//"."/"_"}
    #copy file to csv/tsv/pipe folder under dbroot based on $1 paramter
    eval "cp $2 $db_root/$1/$filename.csv"
}

Usage for a csv file

Let's say we get a CSV file foo.csv. Run the below setdb command. The function copies the foo.csv as foo_csv.csv to data/csv

> setdb csv foo.csv

Refresh the CSV file connection in DBeaver the new file will show as a table under the CSV connection

Usage for a pipe-delimited file

Let's say we get a pipe-delimited file bar.txt Run the below setdb command, The function copies the bar.txt as bar_txt.csv to flatfile_dbeaver/data/pipe. To keep it simple for the DBeaver connection we use .csv you can change the extension the connection looks for in the Driver Properties and modify the setdb function accordingly

> setdb pipe bar.txt

Refresh the PIPE file connection in DBeaver the new file will show as a new table under the PIPE connection

Thank You!!

brew redis on mac

Pragmatic Programmer — Mon, 25 May 2020 22:59:53 +0000

Redis is a powerful in-memory datastore widely used for caching, pub/sub messaging, and more. This guide provides quick commands and tips for installing, managing, and using Redis on macOS.

Quick Tips

Default Port: Redis runs on port 6379 by default.
Logs Location: Check logs for debugging in /usr/local/var/log/redis.log.
Configuration File: The default configuration file is located at /usr/local/etc/redis.conf.
Access Control: Use the ACL Guide to configure users and permissions.
Stop Redis Safely: Always stop Redis using brew services stop redis or redis-cli shutdown to avoid data loss.
Redis CLI Help: Run redis-cli --help to see all available commands.

Useful Commands

Connect to Redis

redis-cli -h <host> -p <port>

Ping Redis

Check if Redis is running:

redis-cli ping
# Output: PONG

List Users

redis-cli ACL LIST

Monitor Commands

Log all commands received by Redis in real-time:

> redis-cli monitor
OK
1590445706.871636 [0 127.0.0.1:52583] "ping"
1590445716.910679 [0 127.0.0.1:52642] "flushall"
1590445814.170701 [0 127.0.0.1:53107] "incr" "visitor"
1590445893.336228 [0 127.0.0.1:53483] "publish" "channel" "hi"
1590445914.672421 [0 127.0.0.1:53591] "subscribe" "channel1"
1590445925.539757 [0 127.0.0.1:53639] "publish" "channel" "hey"

View Continuous Stats

> redis-cli --stat
------- data ------ --------------------- load -------------------- - child -
keys       mem      clients blocked requests            connections          
1          1.02M    1       0       0 (+0)              1           
1          1.02M    1       0       1 (+0)              1           
1          1.02M    1       0       2 (+1)              1           
1          1.02M    1       0       3 (+1)              1           
1          1.02M    1       0       4 (+1)              1

Flush All Data

Clear all keys in the current database:

redis-cli flushall

Increment a Key

redis-cli incr <key>

Publish a Message

Send a message to a channel:

redis-cli publish <channel> <message>

Installation

Install Redis via Homebrew

The easiest way to install Redis on macOS is using Homebrew:

brew install redis

Starting and Stopping Redis

Start Redis as a Foreground Process

Run the Redis server in the foreground:

 > redis-server

15594:C 25 May 2020 18:08:37.005 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
15594:C 25 May 2020 18:08:37.005 # Redis version=6.0.3, bits=64, commit=00000000, modified=0, pid=15594, just started
15594:C 25 May 2020 18:08:37.005 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
15594:M 25 May 2020 18:08:37.006 * Increased maximum number of open files to 10032 (it was originally set to 8192).
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 6.0.3 (00000000/0) 64 bit
  .-`` .-```
{% endraw %}
.
{% raw %}
  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 15594
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

15594:M 25 May 2020 18:08:37.007 # Server initialized
15594:M 25 May 2020 18:08:37.008 * Ready to accept connections

To exit: Press Ctrl + C.

Start/Stop Redis as a Background Service

Use Homebrew services to manage Redis as a background service:

brew services start redis   # Start Redis
brew services stop redis    # Stop Redis
brew services restart redis # Restart Redis

Check Running Services

List all services managed by Homebrew:

brew services list

Configuration

Edit Redis Configuration

To customize Redis settings, edit the configuration file:

/usr/local/etc/redis.conf

After making changes, restart Redis:

  brew services restart redis

For more details on configuration, see the Redis Configuration Guide.

Useful Aliases

Add these aliases to your ~/.zshrc or ~/.bash_profile for quick Redis management:

alias redis-start="brew services start redis"
alias redis-stop="brew services stop redis"
alias redis-restart="brew services restart redis"
alias redis-monitor="redis-cli monitor"

Redis is now ready to supercharge your development workflow! 🚀 For more commands and advanced usage, check the Redis CLI Documentation.