But despite how central the terminal is to developer workflows, AI assistance there has remained shallow: autocomplete a command here, explain an error there.

That changes when you combine GitHub Copilot CLI with MCP (Model Context Protocol) servers. Instead of an AI that reacts to isolated prompts, you get a terminal that understands your project context, queries live data sources, and chains tool calls autonomously – what the industry is starting to call an agentic workflow.

In this tutorial, you'll learn exactly how to wire these two systems together, step by step. By the end, your terminal will be able to do things like understand your Git history before suggesting a fix, query your running Docker containers before writing a compose patch, or pull live API schemas before generating a request.

Table of Contents

• Prerequisites

• What is GitHub Copilot CLI?

• What is the Model Context Protocol?

• How MCP Servers Work in a Terminal Context

• Step 1 – Install and Configure GitHub Copilot CLI

• Step 2 – Set Up Your First MCP Server

• Step 3 – Wire Copilot CLI to Your MCP Server

• Step 4 – Build a Real Agentic Workflow

• Step 5 – Extend with Multiple MCP Servers

• Debugging Common Issues

• Conclusion

Prerequisites

Before you start, make sure you have the following:

• Node.js v18 or later (node --version)

• npm v9 or later

• A GitHub account with Copilot enabled. The free tier (available to all GitHub users) is sufficient to follow this tutorial. Pro, Business, and Enterprise plans unlock higher usage limits but aren't required.

• GitHub CLI (gh) installed. We'll use it to authenticate.

• Basic familiarity with the terminal and JSON configuration files

• (Optional) Docker installed if you want to follow the Docker MCP example in Step 5

You don't need prior experience with MCP or agentic AI systems, as this guide builds that understanding from the ground up.

What is GitHub Copilot CLI?

GitHub Copilot CLI is the terminal-native interface to GitHub's Copilot AI. Unlike the IDE plugin (which assists with code completion), Copilot CLI is designed specifically for shell workflows. It exposes three main commands:

• gh copilot suggest proposes a shell command based on a natural language description

• gh copilot explain explains what a given command does

• gh copilot alias generates shell aliases for Copilot subcommands

Here's a quick example of suggest in action:

gh copilot suggest "find all files modified in the last 24 hours and larger than 1MB"

Copilot will return something like:

find . -mtime -1 -size +1M

It will also ask if you want to copy it, run it directly, or revise the request. This interactive loop is already useful – but by itself, Copilot CLI has no awareness of your project context. It doesn't know your repo structure, your running services, or your deployment environment. That's where MCP comes in.

What is the Model Context Protocol?

The Model Context Protocol (MCP) is an open standard introduced by Anthropic in late 2024. Its goal is straightforward: give AI models a standardized way to connect to external tools, data sources, and services.

Think of MCP as a universal adapter layer between an AI model and the real world. Without MCP, each AI integration is custom-built: one plugin for GitHub, another for Postgres, another for Slack, all with incompatible interfaces. MCP defines a single protocol that any tool can implement, and any compatible AI client can consume.

An MCP server exposes tools (functions the AI can call), resources (data the AI can read), and prompts (reusable instruction templates). The AI client in our case, a Copilot-powered terminal discovers these capabilities at runtime and uses them autonomously to complete a task.

A few notable MCP servers that are already production-ready:

The full registry lives at github.com/modelcontextprotocol/servers.

How MCP Servers Work in a Terminal Context

Before we get hands-on, it's worth understanding the communication model.

MCP servers run as local processes. They communicate with the AI client over stdio (standard input/output) or over an HTTP/SSE transport. The client sends JSON-RPC messages to the server, and the server responds with structured data.

Here's the simplified flow:

The key word here is grounded. Without MCP, Copilot responds based purely on its training data and your prompt. With MCP, it can call git log --oneline -20 before answering your question about recent regressions and its answer is based on your actual code history, not a generalized assumption.

Step 1 – Install and Configure GitHub Copilot CLI

If you haven't already, install the GitHub CLI:

# macOS
brew install gh

# Ubuntu/Debian
sudo apt install gh

# Windows (via winget)
winget install --id GitHub.cli

Then authenticate:

gh auth login

Follow the interactive prompts. Select GitHub.com, then HTTPS, and authenticate via browser when prompted.

Now install the Copilot CLI extension:

gh extension install github/gh-copilot

Verify the installation:

gh copilot --version

You should see output like gh-copilot version 1.x.x.

Optional but recommended: set up shell aliases. This makes the workflow much faster. For bash or zsh:

# Add to your ~/.bashrc or ~/.zshrc
eval "$(gh copilot alias -- bash)"   # for bash
eval "$(gh copilot alias -- zsh)"    # for zsh

After reloading your shell (source ~/.bashrc), you can use ghcs as shorthand for gh copilot suggest and ghce for gh copilot explain.

Step 2 – Set Up Your First MCP Server

We'll start with server-git. It's the most immediately useful for a development workflow and has zero external dependencies.

Install it globally via npm:

npm install -g @modelcontextprotocol/server-git

Test that it runs:

mcp-server-git --version

This server exposes the following tools to any compatible MCP client:

• git_log retrieve commit history with filters

• git_diff diff between branches or commits

• git_status current working tree status

• git_show inspect a specific commit

• git_blame annotate file lines with commit info

• git_branch list or switch branches

Now create a configuration file. MCP clients look for a file called mcp.json to discover available servers. Create it in your project root or in a global config directory:

mkdir -p ~/.config/mcp
touch ~/.config/mcp/mcp.json

Add the following content:

{
  "mcpServers": {
    "git": {
      "command": "mcp-server-git",
      "args": ["--repository", "."],
      "transport": "stdio"
    }
  }
}

A few notes on this config:

• command is the binary to run. Make sure it's on your $PATH.

• args passes --repository . so the server scopes itself to the current working directory.

• transport: "stdio" means communication happens over standard input/output the simplest and most stable option for local servers.

Step 3 – Wire Copilot CLI to Your MCP Server

This is where the two systems connect. GitHub Copilot CLI supports MCP via its --mcp-config flag (available from version 1.3+). You point it at your mcp.json, and Copilot will automatically initialize the declared servers before processing your prompt.

Here's the basic invocation:

gh copilot suggest --mcp-config ~/.config/mcp/mcp.json "why did the build break in the last commit?"

When you run this inside a Git repository, Copilot CLI will:

1. Start the mcp-server-git process

2. Call git_log to retrieve recent commits

3. Call git_diff on the most recent commit

4. Synthesize an answer based on the actual diff output

Try it yourself on a repo with a recent failing commit. The difference in response quality compared to a plain gh copilot suggest is immediately obvious.

Tip: avoid retyping the flag every time. Add a shell function to your .bashrc/.zshrc:

function aterm() {
  gh copilot suggest --mcp-config ~/.config/mcp/mcp.json "$@"
}

Now you just type:

aterm "what changed between main and feature/auth?"

And you're running a fully context-aware, MCP-powered query from a single short command. This function name aterm for agentic terminal is what we'll use throughout the rest of this tutorial.

Step 4 – Build a Real Agentic Workflow

Let's move beyond individual queries and build a workflow that chains multiple tool calls to complete a real developer task: diagnosing a regression.

Imagine you pushed a feature branch and your CI pipeline failed. You don't know exactly which change caused it. Here's how your agentic terminal handles it:

Query 1: understand what changed

aterm "summarize all commits on feature/auth that aren't on main yet"

Copilot calls git_log with branch filters, then returns a structured summary of commits unique to your branch. No copy-pasting SHAs manually.

Query 2: isolate the diff

aterm "show me everything that changed in the auth middleware between main and feature/auth"

This triggers git_diff scoped to the path containing your middleware. Copilot returns the diff with an explanation of what each change does.

Query 3: find the likely culprit

aterm "which of those changes could cause a JWT validation failure?"

At this point, Copilot has the diff in its context window from the previous tool calls. It reasons over the actual code changes not generic knowledge about JWT and pinpoints the likely issue.

Query 4: generate the fix

aterm "write the corrected version of that validation function"

Copilot generates a targeted fix based on the specific code it retrieved via MCP. You get a patch you can directly apply, not a generic code template.

This four-step sequence – understand, isolate, reason, fix – is a complete agentic loop. Each step is grounded in live repository data retrieved through MCP tools. The AI is not hallucinating context. Instead, it's reading your actual codebase.

Step 5 – Extend with Multiple MCP Servers

One MCP server is useful. Multiple MCP servers working together is where the workflow becomes genuinely powerful. Let's add two more: server-filesystem and server-docker.

Install the additional servers:

npm install -g @modelcontextprotocol/server-filesystem
npm install -g @modelcontextprotocol/server-docker

Update your mcp.json:

{
  "mcpServers": {
    "git": {
      "command": "mcp-server-git",
      "args": ["--repository", "."],
      "transport": "stdio"
    },
    "filesystem": {
      "command": "mcp-server-filesystem",
      "args": ["--root", "."],
      "transport": "stdio"
    },
    "docker": {
      "command": "mcp-server-docker",
      "transport": "stdio"
    }
  }
}

With all three servers active, your terminal can now answer cross-domain questions:

aterm "my Express app container keeps restarting, check the logs and compare with what the healthcheck in my Dockerfile expects"

To answer this, Copilot will:

1. Call docker_logs (server-docker) to pull the container's recent stderr output

2. Call read_file (server-filesystem) to read your Dockerfile

3. Parse the HEALTHCHECK instruction

4. Cross-reference the log errors with the health endpoint path

5. Return a diagnosis explaining the mismatch and suggest the fix

This is an agentic workflow: the model autonomously decides which tools to call, in what order, and synthesizes the results into a coherent answer. You didn't tell it to read the Dockerfile. It inferred that was necessary based on your question.

A note on security: When running server-filesystem, always scope it to a specific directory using --root. Never point it at / or your home directory. Similarly, server-docker has access to your Docker socket run it only in trusted environments.

Debugging Common Issues

mcp-server-git: command not found

The npm global bin directory isn't on your $PATH. Fix:

export PATH="\(PATH:\)(npm bin -g)"
# or for newer npm versions:
export PATH="\(PATH:\)(npm prefix -g)/bin"

Add this line to your .bashrc/.zshrc to persist it.

Copilot CLI doesn't seem to be using MCP tools

Check your Copilot CLI version:

gh copilot --version

MCP support requires version 1.3 or later. Update with:

gh extension upgrade copilot

Also verify your mcp.json is valid JSON a trailing comma or missing bracket will silently prevent server initialization.

MCP server starts but returns no data

Run the server manually to check for errors:

mcp-server-git --repository .

If it exits immediately, check that you're running the command inside a valid Git repository. For server-docker, make sure the Docker daemon is running and your user has access to the Docker socket:

sudo usermod -aG docker $USER
# Then log out and back in

Responses are slow with multiple servers

Each MCP server is a separate subprocess. Spawning several at once adds startup latency, especially on slower machines. Two optimizations:

1. Only declare the servers you actually need for a given project in your mcp.json

2. Use project-specific config files instead of one global config:

# project A (backend)
aterm --mcp-config ./mcp-backend.json "..."

# project B (infra)
aterm --mcp-config ./mcp-infra.json "..."

Conclusion

You've just built an agentic terminal workflow from scratch. Here's a quick recap of what you did:

• Installed and configured GitHub Copilot CLI with shell aliases for fast access

• Set up MCP servers (server-git, server-filesystem, server-docker) and wired them through a mcp.json config

• Created a shell function (aterm) that transparently passes your MCP config to every Copilot query

• Built a multi-step agentic loop for diagnosing regressions using live Git data

• Extended the setup with cross-domain tool orchestration across Git, filesystem, and Docker

The architecture you've built here is not a demo – it's a production-ready pattern. You can extend it with any MCP-compatible server: server-postgres for database-aware queries, server-github for issue and PR context, or custom MCP servers you write yourself for your internal APIs.

The terminal has always been the most powerful surface in a developer's environment. With Copilot CLI and MCP, it's finally becoming an intelligent one.

In this article, you will learn how to use uv—an extremely fast Python package manager.

Prerequisites

To get the most out of this tutorial, you will need to:

• Know how to execute commands in your terminal,

• Be familiar with basic Python development/scripting.

Table of Contents

• Prerequisites

• Why Should You Use uv?

• How to Install uv

• How to Set up a Project with uv

• Commonly Used uv Commands

  • How to Add a Dependency

  • How to Remove a Dependency

  • How to Run Python Code

  • How to Move Your Project

  • How to Add and Run Tools

  • How to Run Tools Without Adding Them to Your Project

  • How to Manage Multiple Python Versions

  • How to Migrate from pip to uv

• Conclusion

Why Should You Use uv?

uv is a free and open-source Python project management tool. Written in Rust, uv is fast and easy-to-use. It has become a standard package manager for modern Python development. You can also use it to manage your virtual environments, making it a good alternative for pip and venv.

Speed tests have shown that uv is faster than other popular package managers when it comes to installing dependencies.

How to Install uv

To install uv, simply execute the following command in your terminal:

For Linux/macOS:

curl -LsSf https://astral.sh/uv/install.sh | sh

For Windows:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

How to Set up a Project with uv

To start a new project with uv, run the following command:

uv init freecodecamp-project

This creates the folder /freecodecamp-project in your working directory with the following structure:

├── .gitignore # hidden text file that lists files to be ignored by git
├── .python-version # hidden text file that keeps record of your Python's version number
├── README.md
├── main.py
└── pyproject.toml

README.md is a markdown file, which you can use to communicate information about your project (just as a repository README file on GitHub). pyproject.toml is the configuration file for your project. You can edit it to change your project’s name, version and description. It also keeps track of dependencies you add to project. Last but not least, main.py is where you put your Python code.

Commonly Used uv Commands

Before you can run any uv commands, move your terminal into your project folder:

cd freecodecamp-project

How to Add a Dependency

To add a dependency (for example, NumPy), run:

uv add numpy
# or if you need a specific version
uv add 'numpy==2.3.0'

This automatically adds a virtual environment and a .lock file with a new entry:

├── .venv # hidden folder inside of which your required packages will be installed
└── uv.lock

The .lock file keeps record of the exact versions of your dependencies and their required packages. You should never modify it directly.

How to Remove a Dependency

To remove a dependency, run:

uv remove numpy

This will also remove the corresponding entry from the .lock file.

How to Run Python Code

To run your Python script, execute:

uv run main.py

This will run the code inside the created virtual environment with the installed dependencies in one step! That is, you don’t need to explicitly activate the virtual environment and then run your code.

How to Move Your Project

Sometimes you may want to move your project to another machine. Maybe you want to share it with colleagues, or set it up on a production server. Getting to run your code on another machine has never been easier than with uv. You can simply copy your project folder to the destination environment and run the following command in the destination terminal:

uv sync --locked

This installs the exact versions of your project dependencies!

How to Add and Run Tools

Sometimes you may need tools like ruff, a Python linter (code formatter), which you can add just like any other dependency to your project:

uv add ruff

To run an installed tool, execute:

uv run ruff check

How to Run Tools Without Adding Them to Your Project

Sometimes you may not want to add tools to your dependencies. For example, because you just want to make one-off checks. uv has got you covered with tool run. Simply run:

uv tool run ruff check
# or equivalently 
uvx ruff check

This will run the tool in an isolated environment independent.

How to Manage Multiple Python Versions

If your system has Python installed, uv will use it. Otherwise, it will automatically install the latest Python version when you execute Python code or create a virtual environment with uv. However, you can also use it to manage multiple Python versions:

# install the latest Python version
uv python install
# install multiple Python versions
uv python install 3.11 3.12
# list all installed Python versions
uv python list
# set the version to be used in the current project (.python-version)
uv python pin 3.11

How to Migrate from pip to uv

uv works as drop-in replacement for pip, meaning that you can use common pip commands with uv. Let’s say you received a requirements.txt file. To install the listed dependencies, you can run:

uv pip install -r requirements.txt

Conclusion

You just learned how to use uv! Before uv, managing dependencies, virtual environments and Python versions had been notoriously cumbersome. As an ML engineer at MLjobs.io, I can safely say that uv has been a game changer. Check out uv's documentation to learn more.

OpenCode, an open-source project, takes a different path. It brings an AI assistant directly into your terminal, letting you write, debug, and refactor code using natural language. All this without ever leaving the command line.

It combines the power of large language models with real-world developer workflows, so you can build software faster, with fewer distractions.

Table of Contents

• What is OpenCode?

• Why Use OpenCode?

• How OpenCode Works

• The Power of Context

• Privacy and Control

• Real-World Use Cases

• Community and Ecosystem

• The Future of AI-Powered Development

• Conclusion

What is OpenCode?

OpenCode is an open-source AI coding assistant that works right inside your terminal. It’s built for developers who prefer command-line speed but still want the intelligence of modern AI models.

You can think of it as having ChatGPT or Claude built into your local development environment, except it’s fully open and under your control.

Imagine typing a command like opencode fix error in main.go, and the AI instantly reads your code, finds the problem, and suggests a clean fix. That’s the magic of OpenCode.

The project is hosted at github.com/sst/opencode and has quickly become one of the most popular open-source AI tools for developers. As of October 2025, it has more than 26,000 stars on GitHub, proving that developers are hungry for coding tools that blend automation and simplicity.

Why Use OpenCode?

Most AI coding assistants work inside editors like VS Code or JetBrains. OpenCode, on the other hand, lives in your terminal. This means it can work with any language, any editor, and any environment.

You can use it while building a backend in Go, a frontend in React, or even while managing infrastructure scripts.

OpenCode uses your project context to understand your code deeply. It scans through your files, recognizes dependencies, and maintains context across multiple commands. This allows it to perform complex operations like:

• Refactoring multiple files in one go

• Adding new features based on natural language instructions

• Explaining errors and suggesting fixes

• Reviewing your code before you commit

All of this happens without needing to upload your code to the cloud. Everything stays local, which is a major advantage for teams handling private or sensitive codebases.

How OpenCode Works

OpenCode connects your local files, git history, and LLMs together. When you run a command like opencode explain this function, it gathers context from the files you’re working on, passes that to an AI model, and shows the response directly in your terminal.

The setup is simple. You can install OpenCode using a single command:

curl -fsSL https://opencode.ai/install | bash

Once installed, you can start using it by running:

opencode

The tool will open an interactive terminal interface where you can chat, run tasks, and even let the AI make edits automatically. It supports multiple model providers, including OpenAI, Anthropic, and local models like Ollama.

Behind the scenes, OpenCode uses a plugin-like architecture that makes it easy to extend. Developers can write “actions” or “skills” that teach the AI how to perform domain-specific tasks — like generating Kubernetes manifests, writing API routes, or setting up unit tests.

Once Opencode is installed, go to the project repository and type opencode . Then type /init for Opencode to analyze your repository and created agents.md file.

You can then start asking questions like “What does this repository do?”. Here is a sample output from my portfolio website.

You can use the the OpenCode documentation to learn more tips and tricks to work with OpenCode.

The Power of Context

One of OpenCode’s biggest strengths is how it handles context. Traditional chatbots lose track of what you’re working on after a few turns. OpenCode doesn’t.

OpenCode remembers your codebase, understands imports, and keeps track of related files. This allows it to work more like a real developer assistant.

Let’s say you tell it: “Add authentication to my Express.js app.”

OpenCode will scan your project, identify where routes are defined, create middleware for login, and even suggest where to store tokens securely. It’s this blend of contextual awareness and natural language understanding that makes OpenCode feel more like a teammate than a tool.

Privacy and Control

A major reason developers love OpenCode is control. Unlike cloud-based assistants, OpenCode doesn’t send your code to remote servers by default.

You choose the model provider and what data gets shared. If you run a local model, your entire workflow stays private.

This is especially important for companies with strict data rules. With OpenCode, teams can integrate AI safely into their workflows without breaking compliance or risking leaks.

The tool also integrates with version control systems like Git. Every change the AI suggests can be previewed before committing. You can accept, reject, or modify them just like a pull request. This ensures transparency and keeps human developers in charge.

Real-World Use Cases

Developers are using OpenCode in many creative ways. Backend engineers use it to generate API routes. Frontend teams use it to fix TypeScript errors. DevOps engineers rely on it to generate Terraform scripts and Dockerfiles.

Even researchers and students find it useful for exploring new codebases. By simply asking questions like “What does this repository do?” or “Where is the entry point?”, they can get clear, AI-driven summaries of complex projects.

The flexibility of OpenCode means it can fit almost any workflow. It doesn’t replace your tools , it enhances them. Whether you’re using Vim, VS Code, or JetBrains IDEs, OpenCode works alongside your setup.

Community and Ecosystem

OpenCode is not just a tool, it’s a growing community. The project’s GitHub discussions and Discord are full of contributors sharing workflows, plugins, and even model configuration tips.

The maintainers, part of the SST team, are known for building tools that make cloud and AI development simpler. They continue to release frequent updates and listen closely to community feedback.

Recent updates have added features like persistent sessions, better error recovery, and support for local models. The roadmap includes plans for even deeper IDE integration and team collaboration features.

The Future of AI-Powered Development

As AI coding agents mature, the line between writing code and describing what you want will continue to blur. Tools like OpenCode show us what that future might look like , one where developers spend less time fighting syntax and more time building ideas.

Imagine a day when you start a new project by typing: “Create a REST API for a todo app with user authentication and SQLite support.”

And within seconds, your project structure, database, and routes are ready and reviewed by your AI assistant, tested, and documented.

That’s the vision OpenCode is moving toward: AI tools that don’t just generate code, but understand context, handle complexity, and let humans stay in control.

Conclusion

OpenCode represents a turning point in how developers interact with AI. It’s open-source, private, and deeply integrated into the terminal, making it both powerful and flexible. While other assistants are built around specific IDEs or cloud services, OpenCode keeps developers at the center.

With its growing community, smart architecture, and commitment to privacy, OpenCode isn’t just another coding assistant. It’s a glimpse into the future of AI-driven software development, a future where your terminal becomes the smartest part of your workflow.

Hope you enjoyed this article. Signup for my free AI newsletter TuringTalks.ai for more hands-on tutorials on AI. You can also find visit my website.

In this tutorial, you’ll to learn what the GitHub CLI is, how to install and set it up, and how to use it for everyday tasks such as creating repositories, managing issues and pull requests, working with GitHub Actions, and automating tasks using custom aliases. You’ll learn how to replace some functionalities on GitHub’s web interface with quick commands in your terminal.

Here’s what we’ll cover:

• Overview of GitHub CLI

• Key Features

• Benefits of Using GitHub CLI

• Installation and Setup

• Authenticating with a GitHub Account

• Navigating the GitHub CLI

• Managing Repositories

• Working with Pull Requests and Issues

• Pushing and Pulling Changes

• Working with GitHub Actions

• Managing Gists

• Releases and Tags

• Custom Scripts and Aliases

• Troubleshooting

• Conclusion

Overview of GitHub CLI

You can use the GitHub CLI to bridge the gap between GitHub's web interface and your local environment. You can perform various tasks such as creating issues, managing repositories, or even checking the status of your GitHub Actions workflows using the CLI. Using the CLI, you can perform almost all the tasks that you might complete on the GitHub website.

Key Features of GitHub CLI

• Repository management: Easily create, clone, view, and manage repositories.

• Pull requests and issues: Manage pull requests and issues directly from the terminal, including creating, merging, and listing them.

• GitHub Actions: Interact with workflows and manage workflow runs.

• Authentication: Provides a secure way to authenticate with your GitHub account, supporting SSH keys, tokens, and OAuth.

• Custom scripting: Lets you create custom scripts and aliases to automate repetitive tasks and streamline development processes.

Benefits of Using GitHub CLI

Suppose you’re working on a project, and you need to create a new issue on GitHub. Normally, you would switch to your browser, log in to GitHub, navigate to the repository, click on the “Issues” tab, and then click “New Issue.” With GitHub CLI, you can do all of this by typing a single command, without ever leaving your terminal. This makes your workflow faster and saves time.

Installation and Setup

To install GitHub CLI on Windows, you can use the winget package manager. Winget is a command-line tool that allows you to install software easily.

Installing GitHub CLI on Windows, macOS, and Linux

Windows:

Run the command given below:

winget install --id GitHub.cli

• winget install: Tells Windows to install a new software package.

• --id GitHub.cli: Specifies the exact package ID for GitHub CLI.

After running this command, GitHub CLI will be installed on your Windows system.

macOS:

You can use Homebrew to install GitHub CLI on macOS. Open your terminal and run:

brew install gh

Linux:

On Linux, you can use your package manager. For example, on Ubuntu, you can run:

sudo apt install gh

Authenticating with a GitHub Account

After installing GitHub CLI, the next step is to authenticate it with your GitHub account.

Run Authentication Command:

Type gh auth login in the terminal and press Enter.

gh auth login

You’ll then be prompted to select an authentication method. The recommended option is to authenticate via a web browser.

If you select the browser method, GitHub CLI will open a link in your default browser, where you can log in to GitHub.

Complete Authentication:

After logging in, the browser will confirm that the GitHub CLI is connected to your account.

You can verify the authentication status by running:

gh auth status

Navigating the GitHub CLI

The GitHub CLI is easy to navigate, and its command structure is intuitive.

Command Structure and Syntax

GitHub CLI commands follow a simple and straightforward pattern:

gh [command] [subcommand] [flags]

• Command: The main action you want to perform (for example, repo, issue, pr).

• Subcommand: A specific task within the command (for example, create, list, view).

• Flags: Optional parameters that modify the command's behavior (for example, --title, --body).

Commonly Used Commands and Flags

Here are some common GitHub CLI commands:

• Creating a repository: gh repo create

• Listing issues: gh issue list

• Creating a pull request: gh pr create

• Viewing a repository's details: gh repo view

To see all available commands and options, you can always run:

gh help

How to Manage Repositories with the GitHub CLI

Let’s go through examples of some of the commands you’ll use the most often.

Creating and Cloning Repositories

To create a new GitHub repository directly from the terminal, just use the following command:

gh repo create my-repo-name

To clone an existing repository, use the following command:

gh repo clone owner/repo-name

Managing Branches and Pull Requests

GitHub CLI allows you to handle issues and pull requests (PRs) without leaving the terminal.

Switching branches or creating pull requests is simple. To create a new branch:

git checkout -b new-branch-name

Then, to create a pull request:

gh pr create --title "Your PR Title" --body "Description of your PR"

Pushing and Pulling Changes

Push your changes to GitHub with this command:

git push origin branch-name

And pull the latest changes with:

git pull

Working with GitHub Actions

GitHub CLI also supports GitHub Actions, allowing you to manage workflows directly from your terminal.

You can manually trigger workflows using the following:

gh workflow run workflow-name

And you can monitor the status of workflows with:

gh run list

To see detailed logs of a workflow, run this:

gh run view run-id --log

Cloning and Forking Repositories

Cloning and forking are essential tasks when working on projects from other repositories.

To clone a repository, use this command:

gh repo clone <repository-name>

To fork a repository, do this:

gh repo fork <repository-url>

Example:

Here’s what it would look like:

gh repo clone example-repo

gh repo fork https://github.com/username/repository-name

How to Work with GitHub Actions

Using the GitHub CLI, you can also manage GitHub Actions, which are automated tasks you can run in response to certain events in your repository.

Triggering and Monitoring Workflows

You can trigger a workflow manually like this:

gh workflow run <workflow-name>

And you can monitor workflow runs with this:

gh run list

Managing Workflow Runs and Logs

If you want to check the details of a specific workflow run, you can view logs directly from the CLI:

gh run view <run-id> --log

You can also use GitHub CLI commands to enhance your Continuous Integration/Continuous Deployment (CI/CD) pipelines, ensuring smooth automation and better control over our workflows.

How to Update the GitHub CLI

To make sure that you’re using the latest version of GitHub CLI with all the latest features and fixes, you can update it using winget.

winget upgrade --id GitHub.cli

• winget upgrade: Checks for updates for the specified package.

• --id GitHub.cli: Identifies the GitHub CLI package for the upgrade.

Advanced GitHub CLI Features and Integrations

The GitHub CLI is not only useful for performing basic tasks. You can also perform some advanced operations with its help.

How to Manage Gists with the GitHub CLI

Gists are a simple way to share snippets of code. You can create, list, and manage your Gists right from the CLI. Here’s how you can create a gist:

gh gist create my-code-snippet.py

To list your gists:

gh gist list

Interacting with Releases and Tags

To manage releases and tags, GitHub CLI provides commands to create, list, and delete releases. Here’s an example of creating a release:

gh release create v1.0.0

How to Extend the GitHub CLI with Custom Scripts and Aliases

You can write your own scripts and integrate them into GitHub CLI, or create aliases for commands you use frequently to save time. Aliases let you create shortcuts for commands that you use often. For example, the command given below creates an alias prlist that will show all pull requests, regardless of their state:

gh alias set prlist "pr list --state all"

In the same manner, you can create a shortcut co to quickly check out a pull request branch without typing the full command each time. The command is given below:

gh alias set co "pr checkout"

Troubleshooting Common Issues

If you face any issues, you can troubleshoot by checking the command syntax, ensuring your GitHub CLI is up to date, or consulting the documentation using the command:

gh help <command>

Conclusion

GitHub CLI is an excellent tool that helps developers work directly from the terminal. It lets you manage repositories, handle pull requests and issues, trigger and monitor GitHub Actions, and even work with Gists.

You can save time and improve productivity as developers using this powerful tool. Keep exploring its new features and stay updated with the latest version.

In this article, we’ll go through a collection of CLI / TUI tools that have been widely adopted in the developer community, spanning various categories such as version control, system utilities, text editors, and more. I wanted to give you a diverse selection that caters to different needs and workflows.

For each tool, I’ll include an overview, highlighting its key features and use cases, along with clear and concise installation instructions for various operating systems, ensuring you can quickly get up and running with these valuable command-line companions.

Table of Contents

• Kubernetes Tools

• Container Tools

• File and Text Tools

• Git Tools

• Development Tools

• Networking Tools

• Workstation Tools

Kubernetes Tools

k9s — Kubernetes CLI To Manage Your Clusters In Style

K9s is a must-have tool for anyone working with Kubernetes. Its intuitive terminal-based UI, real-time monitoring capabilities, and powerful command options make it a standout in the world of Kubernetes management tools.

The K9s project is designed to continually watch Kubernetes cluster for changes and offer subsequent commands to interact with observed resources. This makes it easier to manage applications, especially in a complex, multi-cluster environment. The project’s aim is to make Kubernetes management more accessible and less daunting, especially for those who are not Kubernetes experts.

Just launch k9s in your terminal and start exploring the Kubernetes resources with ease.

To install K9s:

# via Homebrew for macOS
brew install derailed/k9s/k9s

# via snap for Linux
snap install k9s --devmode

# via Chocolatey for Windows
choco install k9s

# via go install
go install github.com/derailed/k9s@latest

kubectx — switch between contexts (clusters) on kubectl faster.

Kubectx is the most popular tool for switching Kubernetes contexts, but it has the fewest features! It displays all the contexts in your Kubernetes config as a selectable list and lets you pick one. That’s it!

This project comes with 2 tools:

• kubectx is a tool that helps you switch between contexts (clusters) on kubectl faster.

• kubens is a tool to switch between Kubernetes namespaces (and configure them for kubectl) easily.

These tools make it very easy to switch between Kubernetes clusters and namespaces if you work with many of them daily. Here you can see it in action:

To install kubectx:

# via Homebrew for macOS
brew install kubectx

# via apt for Debian
sudo apt install kubectx

# via pacman for Arch Linux
sudo pacman -S kubectx

# via Chocolatey for Windows
choco install kubens kubectx

kubescape — Kubernetes security platform for your IDE, CI/CD pipelines, and clusters.

I hope you take the security of your Kubernetes clusters seriously. If so, kubescape is really great for testing if your Kubernetes cluster is deployed securely according to multiple frameworks.

Kubescape can scan clusters, YAML files, and Helm charts and detects the misconfigurations according to multiple sources.

I usually use it in my CI/CD to scan for vulnerabilities automatically when changing Kubernetes manifests or Helm templates.

To install kubescape:

# via Homebrew for macOS
brew install kubescape

# via apt for Debian
sudo add-apt-repository ppa:kubescape/kubescape
sudo apt update
sudo apt install kubescape

# via Chocolatey for Windows
choco install kubescape

Container Tools

ctop — A top-like interface for container metrics.

ctop is basically a better version of docker stats. It provides a concise and condensed overview of real-time metrics for multiple containers. It comes with built-in support for Docker and runC, and connectors for other container and cluster systems are planned for future releases.

Using ctop is simple. Once you have the tool open, you’ll see all of your currently active containers listed.

To install ctop:

# via Homebrew for macOS
brew install ctop

# via pacman for Arch Linux
sudo pacman -S ctop

# via scoop for Windows
scoop install ctop

lazydocker — A simple terminal UI for both docker and docker-compose.

While Docker's command-line interface is powerful, sometimes you might want a more visual approach without the overhead of a full GUI. This is especially true when managing Docker containers on a headless Linux server where installing a web-based GUI might be undesirable.

Lazydocker was created by Jesse Duffield to help make managing docker containers a bit easier. Simply put, Lazydocker is a terminal UI (written in Golang) for the docker and docker-compose commands.

To install lazydocker:

# via Homebrew for macOS
brew install lazydocker

# via Chocolatey for Windows
choco install lazydocker

# via go install
go install github.com/jesseduffield/lazydocker@latest

dive — A tool for exploring each layer in a Docker image.

A Docker image is made up of layers, and with every layer you add on, more space will be taken up by the image. Therefore, the more layers in the image, the more space the image will require.

That’s where dive shines, it helps you explore your Docker image and layer contents. It can also help you find ways to shrink the size of your Docker/OCI image.

To install dive:

# via Homebrew for macOS
brew install dive

# via pacman for Arch Linux
pacman -S dive

# via go install
go get github.com/wagoodman/dive

File and Text Tools

jq — Command-line JSON processor.

You may be aware of this one already as it’s well known in the developer community.

Unfortunately, shells such as Bash can’t interpret and work with JSON directly. That’s where you can use jq as a command-line JSON processor that’s similar to sed, awk, grep, and so on for JSON data. It’s written in portable C and doesn’t have any runtime dependencies. This lets you slice, filter, map, and transform structured data with ease.

To install jq, you can download the latest releases from the GitHub release page.

bat — A cat(1) clone with wings.

This is the most used CLI on my machine currently. A few years ago it was cat, which is great but doesn’t provide syntax highlighting, or Git integration

Bat’s syntax highlighting supports many programming and markup languages, helping you make your code more readable directly in the terminal. Git integration lets you see modifications in relation to the index, highlighting the lines you’ve added or changed.

Simply run bat filename and enjoy its output.

To install bat:

# via Homebrew for macOS
brew install bat

# via apt for Debian
sudo apt install bat

# via pacman for Arch Linux
pacman -S bat

# via Chocolatey for Windows
choco install bat

ripgrep — Recursively search directories for a regex pattern while respecting your gitignore.

ripgrep is definitely becoming a popular alternative (if not the most popular) to the grep command. Even some editors like Visual Studio Code are using ripgrep to power their search offerings.

The major selling point is its default behavior for recursive search and speed.

I now rarely use grep on my personal machine, as ripgrep is much faster.

To install ripgrep:

# via Homebrew for macOS
brew install ripgrep

# via apt for Debian
sudo apt-get install ripgrep

# via pacman for Arch Linux
pacman -S ripgrep

# via Chocolatey for Windows
choco install ripgrep

Git Tools

lazygit — Simple terminal UI for git commands.

lazygit is another great terminal UI for Git commands developed by Jesse Duffield using Go.

I don’t mind using the Git CLI directly for simple things, but it is famously verbose for more advanced use cases. I am just too lazy to memorize longer commands.

And lazigit has made me a more productive Git user than ever.

To install lazygit:

# via Homebrew for macOS
brew install jesseduffield/lazygit/lazygit

# via pacman for Arch Linux
pacman -S lazygit

# via scoop for Windows
scoop install lazygit

Development Tools

ATAC — A simple API client (Postman-like) in your terminal.

ATAC stands for Arguably a Terminal API Client. It’s based on popular clients like Postman, Insomnia, and Bruno, but it runs inside your terminal without needing any particular graphical environment.

It works best for developers who need an offline, cross-platform API client right at their fingertips (terminal).

To install ATAC:

# via Homebrew for macOS
brew tap julien-cpsn/atac
brew install atac

# via pacman for Arch Linux
pacman -S atac

k6 — A modern load testing tool, using Go and JavaScript.

I’ve used many load-testing tools in my career, such as vegeta or even ab in the past. But now I mostly use k6s as it has everything I need and has a great GUI and TUI.

Why it works well for me:

• k6 has really good documentation

• Many integrations available: Swagger, JMeter scripts, and so on.

• Results reporting is quite good

To install k6:

# via Homebrew for macOS
brew install k6

# via apt for Debian
sudo apt-get install k6

# via Chocolatey for Windows
choco install k6

httpie — modern, user-friendly command-line HTTP client for the API era.

Don’t get me wrong, curl is great, but not very human-friendly.

HTTPie has a simple and expressive syntax, supports JSON and form data, handles authentication and headers, and displays colorized and formatted output.

To install httpie:

# via Homebrew for macOS
brew install httpie

# via apt for Debian
sudo apt install httpie

# via pacman for Arch Linux
pacman -Syu httpie

# via Chocolatey for Windows
choco install httpie

asciinema — Terminal session recorder.

I call it a terminal YouTube :)

asciinema is a great tool when you want to share your terminal sessions with someone else, instead of recording heavy videos.

I use it often when I develop some CLI tools and want to share the demo of how they work (on GitHub, for example).

To install asciinema:

# via Homebrew for macOS
brew install asciinema

# via apt for Debian
sudo apt install asciinema

# via pacman for Arch Linux
sudo pacman -S asciinema

Networking

doggo — A command-line DNS client.

It's totally inspired by dog which is written in Rust.

In the past I would use dig to inspect the DNS, but its output is often verbose and difficult to parse visually.

doggo addresses these shortcomings by offering two key improvements:

• doggo provides the JSON output support for easy scripting and parsing.

• doggo offers a human-readable output format that uses color-coding and a tabular layout to present DNS information clearly and concisely.

To install doggo:

# via Homebrew for macOS
brew install doggo

# via scoop for Windows
scoop install doggo

# via go install
go install github.com/mr-karan/doggo/cmd/doggo@latest

gping — Ping, but with a graph.

The well-known ping command is not the most interesting to look at, and interpreting its output in a useful way can be difficult.

gping gives a plot of the ping latency to a host, and the most useful feature is the ability to run concurrent pings to multiple hosts and plot all of them on the same graph.

To install gping:

# via Homebrew for macOS
brew install gping

# via Chocolatey for Windows
choco install gping

# via apt for Debian
apt install gping

Workstation

tmux — A terminal multiplexer.

Why is tmux such a big deal?

You may have run into situations where you need to view multiple terminal consoles at the same time. For example, you may have a few servers running (for example, web, database, debugger) and you might want to monitor all the output coming from these servers in real-time to validate behavior or run commands.

Before tmux, you might have just opened a few different tabs in the terminal and switched between them to see the output.

Thankfully, there’s an easier way — tmux.

In a nutshell, here are some of its most popular features:

• Window/Pane management

• Session management with persistence

• Sharable sessions with other users

• Scriptable configurations

To install tmux:

# via Homebrew for macOS
brew install tmux

# via apt for Debian
apt install tmux

# via pacman for Arch Linux
pacman -S tmux

zellij — A terminal workspace with batteries included.

Since I listed tmux here, it also makes sense to include a new competitor, Zellij, which has been gaining traction in the developer community. Both have their own unique features and purposes.

Compared to traditional terminal multiplexers, zellij offers a more user-friendly interface, modern design elements, built-in layout systems, and a plugin system, making it easier for newcomers to get started.

I still like tmux. It has a special place in my heart because it has served a great purpose for years. But zellij is another good option.

To install zellij:

# via Homebrew for macOS
brew install zellij

# via apt for Debian
apt install zellij

# via pacman for Arch Linux
pacman -S zellij

btop — A monitor of resources.

I can’t live without btop, and it’s installed on all my machines via my personal dotfiles. I rarely use now built-in OS GUIs to check the resource utilization on my host machine, because btop can do it much better.

I use to to quickly explore what uses the most memory, monitor and kill some processes, and more.

To install btop:

# via Homebrew for macOS
brew install btop

# via snap for Debian
sudo snap install btop

Conclusion

These CLIs/TUIs should work well in any modern terminal. I personally use Ghostty currently and it works great, but other popular options like iTerm2, Kitty, and the default terminal applications on macOS and Linux should also provide a seamless experience. The key is to ensure your terminal supports features like 256-color palettes and UTF-8 encoding for optimal display of these tools.

There’s a huge amount of CLIs/TUIs out there, and I couldn’t list them all (though I tried to list some of the best). This selection represents a starting point for exploring the rich ecosystem of command-line tools available to developers. I encourage you to explore further, discover new tools that fit your specific needs, and contribute back to the community by sharing your findings.

Explore more articles on packagemain.tech

This article will show more advanced usage of the jQuery Terminal library. If you want something more basic, you can check this article: How to create interactive terminal like website with JavaScript that is written for more entry level programmers. You can also read it (or skim it) first before you begin reading this one.

Table of Contents

• What is the terminal and its history?

• What is jQuery Terminal?

• Base html file

• How to Initialize the Terminal

• Welcome message

• Line Gaps

• How to Add Colors to ASCII Art

  • Terminal Formatting

  • How to Use the Lolcat Library

  • Rainbow ASCII Art Greetings

  • How to Make the Greeting Text White

• How to Make Your First Command

• Default Commands

• How to Make Help Commands Executable

• Syntax Highlighting

• Tab Completion

• How to Add Shell Commands

• How to Improve Completion

• Typing Animation Command

• Credits Command

• Prefilled Commands

• Sharing Link to Terminal Session

• Working Terminal Portfolio Demo

• Adding Executables to Home Directory

• What Next?

• Share what you’ve created

What is the terminal and its history?

Terminals have a long history. It started as an upgrade from punch cards. Computers back in the day used teletypes, which was just a keyboard and a printer. You'd type on the keyboard, and the keystrokes would be sent to the computer (usually mainframe) and the output got printed on a printer.

Later on, the teletypes were replaced with terminals. A terminal was like the dump computer we see today. It was a CRT Monitor with a keyboard. So instead of getting the output on the printer, it would be displayed on the monitor.

Today we still use this type of interface (the Command Line) to talk with computers.

The command line is a terminal emulator and is a big part of Unix systems, like GNU/Linux or MacOS. On Windows, you have PowerShell or cmd.exe file that allows you to type commands and get responses in the form of text. You can also install GNU/Linux system on Windows in the form of WSL. CLI interfaces are used mostly by power users, developers, and system administrators.

If you're new to the command line, you can read this article: Command Line for Beginners – How to Use the Terminal Like a Pro [Full Handbook].

What is jQuery Terminal?

jQuery Terminal is a JavaScript library. It's a plugin for the jQuery library. jQuery Terminal is more like a framework that has jQuery as its dependency. We'll mostly use JavaScript and very little jQuery in this article.

Let's create our terminal-based portfolio using jQuery Terminal.

Base HTML file

The first thing you need to do is to include jQuery and jQuery Terminal library in your project.

This is a basic HTML file:

<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/jquery.terminal/css/jquery.terminal.min.css"/>
</head>
<body>
<script src="https://cdn.jsdelivr.net/npm/jquery"></script>
<script src="https://cdn.jsdelivr.net/npm/jquery.terminal/js/jquery.terminal.min.js"></script>
<script src="my-terminal.js"></script>
</body>
</html>

Then inside the my-terminal.js file, we will write our code in JavaScript.

How to Initialize the Terminal

To create a basic terminal, you need to put in this code:

const commands = {};

const term = $('body').terminal(commands);

The string 'body' indicates the CSS selector where terminal should be created. Here we use 'body' so the terminal will be the only thing on the page. But it doesn't have to be full screen. You can create a website where the terminal is only part of the page, like in a window that looks like part of the Operating System.

The first argument to the terminal method is called an interpreter. It's a way to add your commands. An object is the simplest way to create them. See creating the interpreter to learn more.

If the terminal font is too small, you can make it a little bit bigger with CSS custom properties (also known as CSS variables):

:root {
    --size: 1.2;
}

Welcome Message

The first thing we need to do is to get rid of the default greeting message and replace it with nice-looking custom ASCII Art. We will use the Filget library written in JavaScript to do this.

There are a few Figlet libraries on npm. We will use a package named figlet.

The first thing you should do is pick the right font. Go to figlet playground and write the text you want for your greeting. We will use "Terminal Portfolio" and click "Test All". It should display your text with all the fonts. Scroll through the list and pick the font you like.

I picked a font "slant" that looks like this:

You can copy this text and put into a string, but you will have issues like with the backslash that needs to be escaped using quote characters.

const greetings = `  ______                    _             __   ____             __  ____      ___     
 /_  __/__  _________ ___  (_)___  ____ _/ /  / __ \\____  _____/ /_/ __/___  / (_)___ 
  / / / _ \\/ ___/ __ \`__ \\/ / __ \\/ __ \`/ /  / /_/ / __ \\/ ___/ __/ /_/ __ \\/ / / __ \\
 / / /  __/ /  / / / / / / / / / / /_/ / /  / ____/ /_/ / /  / /_/ __/ /_/ / / / /_/ /
/_/  \\___/_/  /_/ /_/ /_/_/_/ /_/\\__,_/_/  /_/    \\____/_/   \\__/_/  \\____/_/_/\\____/`

const term = $('body').terminal(commands, {
    greetings
});

NOTE: The second argument to the jQuery Terminal is an object with options – we used a single option greetings.

This doesn't look good and it's hard to modify. Also, if you create the greeting by hardcoding a string, it may get distorted on smaller screens. That's why we will use the figlet library in JavaScript.

First, we need to include the figlet library in HTML:

<script src="https://cdn.jsdelivr.net/npm/figlet/lib/figlet.js"></script>

To initialize the library in JavaScript, we need to load the fonts:

const font = 'Slant';

figlet.defaults({ fontPath: 'https://unpkg.com/figlet/fonts/' });
figlet.preloadFonts([font], ready);

This code will load the 'Slant' font and call the function ready when the font is loaded.

So we need to write this function:

function ready() {

}

Now we can do two things, we can put the initialization of jQuery Terminal inside that function:

let term;

function ready() {
   term =  $('body').terminal(commands, {
      greetings
   });
}

With this, we can use the greeting option. But we can also use the echo method to render the greeting, and when initializing the terminal we will put null or false as a greetings to disable the default one:

const term = $('body').terminal(commands, {
    greetings: false
});

function ready() {
   term.echo(greetings);
}

This will work better because the library will initialize the terminal immediately and will not need to wait for loading the fonts.

Note that we still need to define the greetings using figlet. To do this we can write this function:

function render(text) {
    const cols = term.cols();
    return figlet.textSync(text, {
        font: font,
        width: cols,
        whitespaceBreak: true
    });
}

This function uses the figlet::textSync() method to return a string and use terminal::cols(), to get the number of characters per line. With this, we can make our text responsive.

This function can be used inside ready.

function ready() {
   term.echo(render('Terminal Portfolio'));
}

This will create a string and pass it to the echo method. But this will be the same as with:

term.echo(greeting);

And our hard-coded greetings. So if you resize the terminal, the greetings can still get distorted. To make the text responsive, you need to echo a function. This function will be called on each re-render of the terminal, which will happen when you resize the page.

We can use the arrow function for this:

function ready() {
   term.echo(() => render('Terminal Portfolio'));
}

If you want to add some text below the ASCII art, you can do this by concatenating the string after render:

function ready() {
   term.echo(() => {
     const ascii = render('Terminal Portfolio');
     return `${ascii}\nWelcome to my Terminal Portfolio\n`;
   });
}

NOTE: If you run this code, you will notice that there is an empty line after the ASCII art. This is because the figlet library adds some spaces after the text.

To get rid of this, you can use string::replace() with a regular expression that will remove all spaces and newlines from the end.

We can't use string::trim(), because we don't want to remove the leading lines:

function render(text) {
    const cols = term.cols();
    return trim(figlet.textSync(text, {
        font: font,
        width: cols,
        whitespaceBreak: true
    }));
}

function trim(str) {
    return str.replace(/[\n\s]+$/, '');
}

You can also pause the terminal when it loads the fonts:

const term = $('body').terminal(commands, {
    greetings: false
});

term.pause();

function ready() {
   term.echo(() => render('Terminal Portfolio')).resume();
}

You can can chain terminal methods, the same as with jQuery.

Line Gaps

If the font you pick creates gaps between the lines, like in this image with font ANSI Shadow:

You can remove the gaps by adding the ansi option set to true. The option was added specifically to fix an issue with displaying ANSI Art.

term.echo(() => render('Terminal Portfolio'), { ansi: true });

The above ASCII Art will look like this:

How to Add Colors to ASCII Art

You can spice up your ASCII Art by using a library called lolcat. lolcat is a Linux command that can style text in the terminal with rainbow colors. There is also a library called isomorphic-lolcat, that you can use in JavaScript to make your ASCII Art in rainbow colors.

Terminal Formatting

To use the lolcat library, you first need to know how to change the colors of the terminal.

You can do this using low-level formatting that looks like this:

[[b;red;]some text]

The whole text is wrapped in brackets and the formatting of the text is in additional brackets, where each argument is separated by a semicolon. To learn more about the syntax, you can read the Wiki Article: Formatting and Syntax Highlighting.

Here, we'll only use a basic change of color. Instead of red, you can use CSS color names, hex color, or rgb().

How to Use the Lolcat Library

To use the library, we first need to include it in HTML:

<script src="https://cdn.jsdelivr.net/npm/isomorphic-lolcat"></script>

To format the string with colors, we can use this function:

function rainbow(string) {
    return lolcat.rainbow(function(char, color) {
        char = $.terminal.escape_brackets(char);
        return `[[;${hex(color)};]${char}]`;
    }, string).join('\n');
}

function hex(color) {
    return '#' + [color.red, color.green, color.blue].map(n => {
        return n.toString(16).padStart(2, '0');
    }).join('');
}

The lolcat.rainbow will call a function in every character from the input string, and pass color as an object with RGB values and the character.

Rainbow ASCII Art Greetings

To use this code, you need to wrap the call to render with rainbow:

function ready() {
   term.echo(() => {
     const ascii = rainbow(render('Terminal Portfolio'));
     return `${ascii}\nWelcome to my Terminal Portfolio\n`;
   }).resume();
}

You can also use two calls to echo, since only the Figlet message needs to be executed inside the function:

function ready() {
   term.echo(() => rainbow(render('Terminal Portfolio')))
       .echo('Welcome to my Terminal Portfolio\n').resume();
}

You'll notice that when you resize the window, the rainbow changes randomly. This is the default behavior of lolcat. To change it, you need to set the random seed.

function rand(max) {
    return Math.floor(Math.random() * (max + 1));
}

function ready() {
   const seed = rand(256);
   term.echo(() => rainbow(render('Terminal Portfolio'), seed))
       .echo('Welcome to my Terminal Portfolio\n').resume();
}

function rainbow(string, seed) {
    return lolcat.rainbow(function(char, color) {
        char = $.terminal.escape_brackets(char);
        return `[[;${hex(color)};]${char}]`;
    }, string, seed).join('\n');
}

The rand function returns a pseudo-random number from 0 to max value. Here we created a random value from 0 to 256.

How to Make the Greeting Text White

As we showed previously, you can make the text white with terminal formatting. You can use:

• [[;white;]Welcome to my Terminal Portfolio]

• [[;#fff;]Welcome to my Terminal Portfolio]

• [[;rgb(255,255,255);]Welcome to my Terminal Portfolio]

Moreover, if you include additional file XML formatting, you can use XML-like syntax. That makes formatting much easier.

<script src="https://cdn.jsdelivr.net/npm/jquery.terminal/js/xml_formatting.js"></script>

After including the above file in HTML, you can use CSS named colors as XML tags:

<white>Welcome to my Terminal Portfolio</white>

The XML formatting supports more tags like links and images. See Extension XML Formatter for more info.

NOTE: XML formatter is a function added to $.terminal.defaults.formatters, which transforms the input XML-like text into terminal formatting. You can add the same to your own formatters.

How to Make Your First Command

After the greeting, we can write our first command. It will be helpful and will work with any commands we add later.

const commanns = {
    help() {

    }
};

This will be our help command where we'll add a list of commands available to our terminal portfolio. We will use Intl.ListFormat, which creates a list of elements with and before the last element.

const formatter = new Intl.ListFormat('en', {
  style: 'long',
  type: 'conjunction',
});

To create a list, we need to use formatter.format() and pass an array of commands. To get that array we can use Object.keys():

const commands = {
    help() {
        term.echo(`List of available commands: ${help}`);
    }
};

const command_list = Object.keys(commands);
const help = formatter.format(command_list);

When you type help you should see:

List of available commands: help

You also need to add the echo command:

const commands = {
    help() {
        term.echo(`List of available commands: ${help}`);
    },
    echo(...args) {
        term.echo(args.join(' '));
    }
};

Now the help command works:

List of available commands: help and echo

But if you try to execute 'echo hello' you will get an error:

[Arity] Wrong number of arguments. The function 'echo' expects 0 got 1!

By default, jQuery Terminal checks the number of arguments and the number of parameters the function accepts. The problem is that the rest operator makes all arguments optional and the length function property is 0. To fix the issue we need to disable the Arity check with an option:

const term = $('body').terminal(commands, {
    greetings: false,
    checkArity: false
});

Now the echo commands should work.

Default Commands

By default, the jQuery Terminal has two default commands:

• clear: this command clears everything on the terminal.

• exit: this command exits from nested interpreters.

You can disable them by passing the name to the option and setting it to false. Since we won't use nested interpreters, we can disable exit:

const term = $('body').terminal(commands, {
    greetings: false,
    checkArity: false,
    exit: false
});

But clear can be useful. So we can add it to the list of commands:

const command_list = ['clear'].concat(Object.keys(commands));

How to Make Help Commands Executable

We can make the UX better to allow clicking on the command and execute it just like when the user types it.

We will need a few things to do this. First, we need to add formatting to each command and add an HTML class attribute. We can also make the command white so it's more visible.

const command_list = Object.keys(commands);
const formatted_list = command_list.map(cmd => {
    return `<white class="command">${cmd}</white>`;
});
const help = formatter.format(formatted_list);

Next is to add affordance. To indicate that the user can click the command, we need to change the cursor in CSS:

.command {
    cursor: pointer;
}

The last step is to execute the command when the user clicks the command. We need to add an event handler with jQuery (jQuery Terminal dependency) or we can use the native browser addEventListener. Here we use jQuery:

term.on('click', '.command', function() {
   const command = $(this).text();
   term.exec(command);
});

terminal::exec() is a way to execute a command programmatically, just like user would type it and press enter.

You can test it by typing help and clicking help again.

Clicking echo will print an empty line. We can fix it by checking if the array of arguments is not empty, before executing terminal::echo():

const commands = {
    echo(...args) {
        if (args.length > 0) {
            term.echo(args.join(' '));
        }
    }
};

Now clicking on echo will only show the executed command.

NOTE: If for any reason you don't want to show the prompt and the command that has been executed, you can silence the exec by passing true as the second argument.

term.exec('help', true);

Syntax Highlighting

As we discussed earlier, we can use custom syntax highlighting of our shell by pushing a function into $.terminal.defaults.formatters.We can also use the $.terminal.new_formatter helper function.

Let's make our commands white as we type them. The formatter can be an array (of regex and replacement), or a function. We have a fixed number of commands and we only want to make those that are on the list white. We can do this by adding a regular expression:

const any_command_re = new RegExp(`^\s*(${command_list.join('|')})`);

This regular expression will check if, at the beginning of the string, there is an optional whitespace and one of the commands. Right now the regex will look like this: /^\s*(help|echo)/. This is how to create new formatter:

$.terminal.new_formatter([any_command_re, '<white>$1</white>']);

If you would like to make command arguments in different colors, you'll need a function, where you will use String::replace().

const re = new RegExp(`^\s*(${command_list.join('|')}) (.*)`);

$.terminal.new_formatter(function(string) {
    return string.replace(re, function(_, command, args) {
        return `<white>${command}</white> <aqua>${args}</aqua>`;
    });
});

This is just an example of using String::replace. If you have just one replacement, you can use an array. This will be the same:

const re = new RegExp(`^\s*(${command_list.join('|')})(\s?.*)`);

$.terminal.new_formatter([re, function(_, command, args) {
    return `<white>${command}</white><aqua>${args}</aqua>`;
}]);

NOTE: If you add the class <white class="command"> to the formatter, you will be able to click on the typed command to execute it again.

Tab Completion

Another feature we can add is to complete the command when you press the tab key. This is super easy – we only need to add the completion option set to true:

const term = $('body').terminal(commands, {
    greetings: false,
    checkArity: false,
    exit: false,
    completion: true
});

Now when you type h and press tab, it will complete the command help for you.

How to Add Shell Commands

Now we can add the most important commands that allow us to navigate through the portfolio. We will implement directories as the main entry point so the user will need to type the ls command to see a list of things, cd into that directory, and ls again to see the contents.

const directories = {
    education: [
        '',
        '<white>education</white>',

        '* <a href="https://en.wikipedia.org/wiki/Kielce_University_of_Technology">Kielce University of Technology</a> <yellow>"Computer Science"</yellow> 2002-2007 / 2011-2014',
        '* <a href="https://pl.wikipedia.org/wiki/Szko%C5%82a_policealna">Post-secondary</a> Electronic School <yellow>"Computer Systems"</yellow> 2000-2002',
        '* Electronic <a href="https://en.wikipedia.org/wiki/Technikum_(Polish_education)">Technikum</a> with major <yellow>"RTV"</yellow> 1995-2000',
        ''
    ],
    projects: [
        '',
        '<white>Open Source projects</white>',
        [
            ['jQuery Terminal',
             'https://terminal.jcubic.pl',
             'library that adds terminal interface to websites'
            ],
            ['LIPS Scheme',
             'https://lips.js.org',
             'Scheme implementation in JavaScript'
            ],
            ['Sysend.js',
             'https://jcu.bi/sysend',
             'Communication between open tabs'
            ],
            ['Wayne',
             'https://jcu.bi/wayne',
             'Pure in browser HTTP requests'
            ],
        ].map(([name, url, description = '']) => {
            return `* <a href="${url}">${name}</a> &mdash; <white>${description}</white>`;
        }),
        ''
    ].flat(),
    skills: [
        '',
        '<white>languages</white>',

        [
            'JavaScript',
            'TypeScript',
            'Python',
            'SQL',
            'PHP',
            'Bash'
        ].map(lang => `* <yellow>${lang}</yellow>`),
        '',
        '<white>libraries</white>',
        [
            'React.js',
            'Redux',
            'Jest',
        ].map(lib => `* <green>${lib}</green>`),
        '',
        '<white>tools</white>',
        [
            'Docker',
            'git',
            'GNU/Linux'
        ].map(lib => `* <blue>${lib}</blue>`),
        ''
    ].flat()
};

This is our basic structure. You can edit it and add your own information. First, we will add a cd command that changes the directory.

const root = '~';
let cwd = root;

const commands = {
    cd(dir = null) {
        if (dir === null || (dir === '..' && cwd !== root)) {
            cwd = root;
        } else if (dir.startsWith('~/') && dirs.includes(dir.substring(2))) {
            cwd = dir;
        } else if (dir.startsWith('../') && cwd !== root &&
                   dirs.includes(dir.substring(3))) {
            cwd = root + '/' + dir.substring(3);
        } else if (dirs.includes(dir)) {
            cwd = root + '/' + dir;
        } else {
            this.error('Wrong directory');
        }
    }
};

This will handle all the cases of changing the directory. Next is to add a prompt.

To see what directory we are in, we need to add a custom prompt. We can create a function as a prompt option:

const user = 'guest';
const server = 'freecodecamp.org';

function prompt() {
    return `<green>${user}@${server}</green>:<blue>${cwd}</blue>$ `;
}

And use it as an option:

const term = $('body').terminal(commands, {
    greetings: false,
    checkArity: false,
    completion: true,
    exit: false,
    prompt
});

The green color don't look very good, so we can use a color from Ubuntu to make the terminal look more real. We can overwrite the default XML color tags like this:

$.terminal.xml_formatter.tags.green = () => {
    return `[[;#44D544;]`;
};

Next is the ls command.

function print_home() {
     term.echo(dirs.map(dir => {
         return `<blue class="directory">${dir}</blue>`;
     }).join('\n'));
}

const commands = {
    ls(dir = null) {
        if (dir) {
            if (dir.match(/^~\/?$/)) {
                // ls ~ or ls ~/
                print_home();
            } else if (dir.startsWith('~/')) {
                const path = dir.substring(2);
                const dirs = path.split('/');
                if (dirs.length > 1) {
                    this.error('Invalid directory');
                } else {
                    const dir = dirs[0];
                    this.echo(directories[dir].join('\n'));
                }
            } else if (cwd === root) {
                if (dir in directories) {
                    this.echo(directories[dir].join('\n'));
                } else {
                    this.error('Invalid directory');
                }
            } else if (dir === '..') {
                print_home();
            } else {
                this.error('Invalid directory');
            }
        } else if (cwd === root) {
            print_home();
        } else {
            const dir = cwd.substring(2);
            this.echo(directories[dir].join('\n'));
        }
    }
};

Similar to the green we had before, the blue color is not that great. So we can use the color from Ubuntu again. To do this, we need to use the same custom XML tags for the color blue:

$.terminal.xml_formatter.tags.blue = (attrs) => {
    return `[[;#55F;;${attrs.class}]`;
};

We added the HTML class for a reason. Let's change directory when the user clicks the directory. Just like we did with commands, we can invoke the cd command the same way as as a user would type it.

term.on('click', '.directory', function() {
    const dir = $(this).text();
    term.exec(`cd ~/${dir}`);
});

NOTE: if you have long command and want to get the text for that command, it's better to use: $(this).data('text'). When the single formatting is wrapped (when text is longer than the width of the terminal) the .text() will no longer have full text, but the full text is always in the data-text HTML attribute.

We also need to update our CSS to change the cursor:

.command, .directory {
    cursor: pointer;
}

How to Improve Completion

Our completion is not perfect as it only completes the commands. If you'd like to have completion that also handles directories, you need to use a function:

const term = $('body').terminal(commands, {
    greetings: false,
    checkArity: false,
    completion(string) {
        // in every function we can use `this` to reference term object
        const cmd = this.get_command();
        // we process the command to extract the command name
        // and the rest of the command (the arguments as one string)
        const { name, rest } = $.terminal.parse_command(cmd);
        if (['cd', 'ls'].includes(name)) {
            if (rest.startsWith('~/')) {
                return dirs.map(dir => `~/${dir}`);
            }
            if (rest.startsWith('../') && cwd != root) {
                return dirs.map(dir => `../${dir}`);
            }
            if (cwd === root) {
                return dirs;
            }
        }
        return Object.keys(commands);
    },
    prompt
});

NOTE: The string argument was left as documentation. It can be used if you only want to complete a single word.

Typing Animation Command

Another command that we will add is an animated joke. We will print random jokes using an API that looks like the user typing.

We will use the Joke API for this purpose.

The API returns JSON with two types of responses: twopart and a single. This is the code that prints the text on the terminal:

// we use programming jokes so it fit better
// developer portfolio
const url = 'https://v2.jokeapi.dev/joke/Programming';
const commands = {
    async joke() {
        const res = await fetch(url);
        const data = await res.json();
        if (data.type == 'twopart') {
            // as said before in every function, passed directly
            // to the terminal, you can use `this` object
            // to reference terminal instance
            this.echo(`Q: ${data.setup}`);
            this.echo(`A: ${data.delivery}`);
        } else if (data.type === 'single') {
            this.echo(data.joke);
        }
    },
}

To add typing animation, you need to add an option to the echo method:

this.echo(data.joke, { delay: 50, typing: true });

There is one caveat: if you have a sequence of typing animations, you need to await for the previous one to finish (the echo will return a promise when animating). When creating such animation you can wrap your code with animation method:

// we use programming jokes so it fits better
// developer portfolio
const url = 'https://v2.jokeapi.dev/joke/Programming';
const commands = {
    async joke() {
        const res = await fetch(url);
        const data = await res.json();
        if (data.type == 'twopart') {
            // this method allow to create sequence of animations
            this.animation(async () => {
                // as said before in every function, passed 
                // directly to terminal, you can use `this` object
                // to reference terminal instance
                // and since we use arrow function we reference
                // this from joke function/command
                await this.echo(`Q: ${data.setup}`, {
                    delay: 50,
                    typing: true
                });
                await this.echo(`A: ${data.delivery}`, {
                    delay: 50,
                    typing: true
                });
            });
        } else if (data.type === 'single') {
            this.echo(data.joke, {
                delay: 50,
                typing: true
            });
        }
    }
};

You can read more about typing animation in this article: Typing Animation.

Credits Command

The last command we will add is a credits command where we will list the JavaScript libraries we used:

const commands = {
    credits() {
        return [
            '',
            '<white>Used libraries:</white>',
            '* <a href="https://terminal.jcubic.pl">jQuery Terminal</a>',
            '* <a href="https://github.com/patorjk/figlet.js/">Figlet.js</a>',
            '* <a href="https://github.com/jcubic/isomorphic-lolcat">Isomorphic Lolcat</a>',
            '* <a href="https://jokeapi.dev/">Joke API</a>',
            ''
        ].join('\n');
    }
};

This is an example of another way to print something on the terminal – if you return something from a function it will be printed. You can also return a Promise, so you can send an AJAX request to the server and print the results.

Prefilled Commands

You can make it easier for users to know what to do with the terminal, especially if they are not that familiar with Unix. You can do this by executing example commands:

term.exec(command)

You can also use animation with exec:

term.exec(command, { typing: true, delay: 50 });

Sharing Link to Terminal Session

Another cool thing that I will show you is recording commands in the URL. You can create whole terminal session and save it in a URL hash. To start recoding a session you need to execute the following:

term.history_state(true);

When you execute the command echo x, it should create a URL hash that looks like this: #[[0,1,"echo%20x"]].

To stop recording, you can use:

term.history_state(false);

You can write this into a command record start | stop, so it will be easier to record sessions.

The last thing to do to restore the session is to use the option execHash: true.

const term = $('body').terminal(commands, {
    /* rest of the options */
    execHash: true
});

When you do this and refresh the page, while having the URL hash with the session, it should replay the session and you should see same output as you did when you recorded it.

If you want the exec to be animated you can use this option:

const term = $('body').terminal(commands, {
    /* rest of the options */
    execHash: true,
    execAnimation: true
});

To share the link, it’s better to use a URL shortener like TinyURL. Make sure you test the shortened URL to see if it works.

How to Add Executables to the Home Directory

Another thing you can do to improve the portfolio is to help your visitor learn what commands they can use, by introducing executable when running ls. They will look like binaries on the Linux system.

// not every command needs to be binary
// we picked those three that works more like real programs
const files = [
    'joke',
    'credits',
    'record'
];

function print_home() {
     term.echo(dirs.map(dir => {
         return `<blue class="directory">${dir}</blue>`;
     }).join('\n'));
     term.echo(files.map(file => {
         return `<green class="command">${file}</green>`;
     }).join('\n'));
}

With this, you will be able to click the command and execute it. So your visitors will know that they can run joke command without the need to type help command. For this to work, we need one last change, adding class to the green XML tag:

$.terminal.xml_formatter.tags.green = (attrs) => {
    return `[[;#44D544;;${attrs.class}]`;
};

Working Terminal Portfolio Demo

Here is a fully working Demo of our Interactive Terminal Portfolio Website.

What Next?

You can add a lot of commands to this portfolio. The only limitation is your imagination.

You can check these examples for inspiration:

• CodePen Collection with jQuery Terminal Demos.

• Retro (Vintage) Terminal CodePen Demo.

• jQuery Terminal Examples Page.

• Terminal 404 Error Page.

• Fake GNU/Linux Terminal.

If you have an idea that is not listed here, you can ask on StackOverflow with jquery-terminal tag. If you have something more time consuming, you can also ask for paid support.

Share what you’ve created

If you create a cool terminal portfolio, you can share it and tag me on Twitter. I would love to take a look. Especially if you create something more than what’s included in the tutorial. You can also share on a terminal chat on my website (it’s a similar terminal portfolio, but with chat).

Two of these powerful features are piping and redirection. These features enable you to redirect the output and input of commands to and from other commands and files.

In this article, you'll learn what piping and redirection in Linux mean, followed by a deep dive into how to use these features yourself.

Prerequisites

To fully understand this guide, you'll need to at least have:

• Basic understanding of the Linux operating system.
• Basic experience working with the Linux command line.
• Access to a Linux command line to try out the commands.

Take a look at this Linux command line tutorial if you're new or need a refresher.

What is Piping in Linux?

Before we dive into the how, what does piping even mean? Piping is the act of directing the output of one Linux command as an input to another command. You can direct the standard output or standard error from one command to another using piping.

A simple example of piping is when you take the output of one command and use it as an input to another command. The pipe (|) metacharacter is used to achieve this.

If you're new to the concept of metacharacters, this is just a fancy name for characters with special meaning in the command line. There are other metacharacters in Linux aside from pipe (|). Common examples include less than (<), greater than (>), and ampersand (&), to name a few.

The Basics of Piping

The basic syntax of using the pipe command is as follows:

command1 | command2 | command3 | ... | commandN

In the syntax above, the terminal will execute the commands from left to right. It will start with command1, and then the output will be input to command2. Outputs of command2 will then be used as inputs of command3 and so on. The good thing about piping is that you can chain as many commands as you'd like.

Piping Examples

Below are several examples of using the pipe command to perform various tasks.

1. Counting the number of files and directories

ls -l | wc -l

In the example above, the first section lists all the files and directories in the current directory using the ls command. The additional -l option tells the ls command to list the contents in a long list format.

The output of the ls -l command is then piped to the second section. The wc -l command counts the number of lines from the output of the ls -l command in the first section and prints the result to the terminal.

2. Sorting a list of files and directories

ls | sort

In the command above, the ls command will output the lists of the files and directories in the current directory. The list is then piped to the sort command, which sorts them alphabetically and prints the result to the terminal.

3. Sort and display unique words from a file

cat words.txt | sort -r | uniq

The third example includes three separate commands connected by two pipes. The first command outputs the contents of the words.txt file, which contains a list of words.

The output is piped to the sort -r command, which sorts the words in reverse alphabetical order. Finally, the sorted words are piped to the uniq command, which removes duplicates and outputs the unique sorted words.

Why and When Should You Apply Command Piping Linux?

Piping takes more than just knowing the syntax. The syntax is pretty simple. To effectively use piping, you should understand its essence.

The purpose of piping is to help you chain commands, using the output of one as the input of another.

Piping is not meant to be a way to chain unrelated commands that you want to be executed sequentially. If you need to do that, write your commands in the terminal and separate them with semicolon (;) using the following syntax:

command1 ; command2 ; ... ; commandN

What Is Redirection in Linux?

Redirection is the act of dictating where the inputs or outputs of your commands go. By default, commands receive data from standard input and then output the results in standard output.

One of the main areas where redirection proves useful is when working with commands and files. You can, for example, redirect the output of a command to a file instead of printing the output in the terminal. Alternatively, you can declare a certain file as an input to a command.

Like piping, Linux provides special characters to perform redirection. Here are important file-redirection characters in Linux and what they do:

• > – directs the output of a command to a given file.
• < – directs the contents of a given file to a command.
• >> – directs the output of a command to a given file. Appends the output if the file exists and has content.
• 2> – directs error messages from a command to a given file.
• 2>> – directs an error message from a command to a given file. Appends the error message if the file exists and has content.
• &> – directs standard output and error to a given file.
• &>> – directs standard output and error to a given file. Appends to the file if it exists and has contents.

Let's look at each file-redirection character in-depth.

1. Output Redirection With >

The > symbol enables you to redirect the output of a command to a certain file. Using the symbol, you can redirect the output to any existing file. If it doesn't exist, the output redirection character will automatically create a new one.

However, you should be careful when writing to an existing file because its contents will be overwritten without a warning.

You can perform output redirection using the following syntax:

command > file

The output of running command will be written to the file instead of the standard output (or, in other words, printed to the terminal). Here's an example of how you can do output redirection:

ls -a > contents.txt

In the command above, the list of items in the current directory (including dotfiles, directories, and files) will be written to the contents.txt file. You won't see any output in the terminal due to the redirection.

2. Output Redirection With >>

>> lets you redirect the output of a command to a file. But, unlike using a single greater than character (>), >> will append the output if you try to write to an existing file (instead of overwriting its contents). If the file doesn't exist, it will create a new one.

The syntax is as follows:

command >> file

Here's an example of using output redirection with >> to perform the same action as before:

ls -a >> contents.txt

3. Input Redirection With <

The < character in the command line lets you redirect the input to a command from a file instead of the keyboard. The syntax of input redirection using < is as follows:

command < file

Here's an example of using input redirection:

wc -w < files.txt

In the example above, we're passing files.txt as the input to the wc -w command, which counts the number of words in the file. But you don't need to use the input redirection character in many scenarios because it's the default behavior. For instance, the command above is similar to the following:

wc -w files.txt

4. Error Redirection With 2> and 2>>

When working on the command line, you may run into errors. For instance, if you want to execute a file without appropriate permissions. Instead of letting the terminal throw an error by printing it, you can use the error redirection character to dictate where the error message should go.

A good place to redirect errors is a file dedicated to storing errors. Here's a simple example of a command trying to access the list of files in a directory that doesn't exist:

ls nonexistent 2> error.txt

In the example above, the terminal will throw an error since there's no file named nonexistent. But instead of printing it to the console, it will be stored in the error.txt file due to the error redirection character. However, the file will have nothing if there's no error.

If you must append an error to an existing file instead of overwriting its contents, use 2>> instead of 2>.

5. Output and Error Redirection With &> and &>>

Instead of choosing whether to redirect standard output or standard errors to a file, &> allows you to redirect both simultaneously. You can think of &> as a shorthand for combining the output redirection (>) and error redirection (2>) characters.

The syntax of using &> is as follows:

command &> output.txt

The error or output of the command is written to the output.txt file. Here's an example:

ls sample &> output.txt

In the command above, if the sample directory is not available or is available but you don't have read permissions, an appropriate error will be written in the output.txt file. But if it exists and you have read permissions, its contents will be output in the output.txt file.

Using &>> allows you to append the output to the file if it exists and has contents.

How to Combine Piping and Redirection to Unleash the Power of the Command Line

Using piping and redirection in combination can let you perform complex operations without heavy lifting. By learning how to combine the two, you can create complex commands to perform various actions with less typing.

Take the following command as an example:

ls | grep ".txt" > text_files.txt

The ls command lists the contents of the current directory. The output is piped to the grep command to filter text files. Finally, the output of the grep command is redirected to the text_files.txt file.

This simple yet powerful example shows that when it comes to piping and redirection, the only limit is your mind.

Conclusion

In this tutorial, you learned the basics of piping and redirection in Linux. We covered the basics together with examples of how you can use the two.

The two features in isolation can be powerful, but you can go further by combining them in your commands, as shown in the last section.

As developers, we spend a substantial amount of time executing commands on the terminal. Whether it's navigating through directories, running scripts, changing Node.js versions, or version control commands, manually typing every command is a time consuming task.

For those who struggle to remember commands or their associated flags, this can become even more tedious.

Worry not! There's a simple yet powerful solution to this problem. It's called terminal aliases.

The alias Command

The alias command allows you to create shortcuts for existing commands, making them easier to remember and quicker to execute. When you define an alias, you are creating a new label for an existing command.

Syntax of alias Command

The syntax is straightforward: you can assign a command to a label like you'd assign a value to a variable in most programming languages.

alias alias_name='long command'

Let's dissect this command to understand it better:

• alias: The terminal command that enables defining an alias.
• alias_name: This is the name or the label you are assigning to the command. Basically, you will type this in the terminal instead of the full command.
• 'long command': This is the command that you want to add an alias to. Make sure that you are wrapping the command with single quotes (') as almost all commands contain spaces or special characters.

Predefined Aliases

There are some predefined aliases already set within terminals. And there is a high chance that you were using them without even knowing.

Such aliases are defined within the system (/etc/bash.bashrc) or user specific (~/.bsahrc) shell configuration files.

You can find a list of all predefined aliases by executing the alias command without any options or flags.

alias

How to Create an Alias that Persists Across Sessions

By default, aliases only persist in the current session. That means, if you close the terminal, the alias will be erased and you cannot use it afterwards.

To tackle this, you must define the alias in the shell's configuration file. Shell is an interpreter that resides inside a terminal and establishes an interface between you and the operating system. Hence, accessing the correct shell as well as modifying the correct configuration file is very important.

Here are the configuration files for the three most commonly used shell applications:

1. Bash: ~/.bashrc
2. Zsh: ~/.zshrc
3. Fish: ~/.config/fish/config.fish

Let's try adding a new alias to Bash.

echo "alias nrd='npm run dev'" >> ~/.bashrc

Let's dissect this command:

• echo: A terminal command that lets you write content within the terminal command.
• "alias ...": This is the content we talked about in the previous point. It's an alias command that adds nrd as an alias for the npm run dev command.
• >>: Tells the terminal to append the content on the left (alias command) to the file on the right. In our case, we are storing it in the bash configuration file.
• ~/.bashrc: This is the file to which the content from the echo command will be added.

Don't forget to replace ~/.bashrc with your shell's configuration file.

How to Create a Dynamic Alias

Oftentimes, you need to use repetitive commands but with some little changes based on what you want. The best example of this is Git commands. In this case, you can add a substitute to your command which would be replaced by the dynamic option/parameter while executing it in the terminal.

alias gpll='git pull --rebase origin ${branch}'

While executing the command, you need to replace ${branch} with the branch you want to pull changes from. This is how you would do it to pull changes from the main branch:

gpll main

You can also add multiple substitutes to your alias. Just make sure you are writing the alias with the correct order of actual values:

alias gpll='git pull --rebase ${remote} ${branch}

While executing the command, you need to replace ${remote} and ${branch} with appropriate values, like the following:

gpll origin main

How to Create an Alias for Multiple Commands

There are cases where you need to use multiple commands sequentially. You can create an alias for that as well. Separate each command by && which executes the command on the right after the command on the left is executed.

gpsh='git pull --rebase && git push'

How to Delete an Alias

If you want to delete an alias from the current session, you can use the unalias command. This command takes only one argument — the alias name.

unalias my-alias-name

However, if you want to delete an alias saved in the configuration file, you need to delete it from the file itself. You can use a simple text editor like Nano to do this.

nano ~/.bashrc

Scroll down to the bottom to find all of your aliases and delete the ones you don't want anymore.

When you're done, you can exit the editor after saving. This is the place where I can introduce a meme about not being able to exit terminal-based text editors. But with Nano, it's very simple:

1. Press ctrl+x if you are on Linux and ^+x if you are on Mac.
2. Press Y to confirm changes
3. Hit Enter or return based on your operating system to save the file.

See? Nothing difficult :)

Caveats

There are two important things that you must remember while creating an alias.

Aliases are shell-restricted

Aliases are specific to the shell you are using. An alias created in one shell won't work in another shell.

You must create a new alias if you want to use it in a different session. There is no workaround to this caveat. One trick you can do is to manually save the alias to the config files of all the shells you use.

Aliases are session bound by default

Aliases are only available in the current session. If you open a new terminal window or log out, the alias will not be available.

Hence, it's recommended to always save an alias to a configuration file so you use it anytime you want.

TL;DR

• alias command adds shortcuts to a command or series of commands. alias shortcut='existing valid command.
• Save an alias to the shell's config file so it is persisted across sessions. Every shell has a unique config file. echo "nrd='npm run dev'" >> ~/.bashrc.
• Create a dynamic alias by substituting the dynamic value with a placeholder. The placeholder must be wrapped by ${}. alias gp='git pull origin ${branch} should be executed as gp main in the terminal.
• Add multiple commands to an alias by joining them with &&.
• Delete an alias by manually erasing it from the config file.

Wrapping up

I hope this blog helps you optimize your time and boosts your developer productivity. If it did, don't forget to share this with your peers so they can improve their efficiency as well.

What other techniques do you use to work efficiently? I would love to know more about it. I am most active on Twitter and Peerlist, if you want to say hi!

Until then, happy scripting! 👨‍💻

Zsh shell offers four configuration files with no discernible differences. Particularly, ~/.zshrc and ~/.zprofile appear to be identical, leaving us wondering which one to use.

In this article, you'll learn the difference and a simple guideline for your shell configuration.

Why Do you Need Configuration?

For programming on a Mac, the Terminal application is an essential tool in your development environment. The Terminal is a command-line interface (CLI) that allows you to interact with the operating system and run commands.

The Terminal or console gives you access to the Unix command line, or shell.

Zsh, also known as Z shell, is a program that runs in the Terminal, interprets Unix commands, and interacts with the operating system. Zsh is the default shell program on MacOS.

Before you get started with programming on the Mac, you'll need to configure the shell. There are optional and convenient settings, such as aliases for hard-to-remember commands and a custom prompt that can display the directory you're in, among other things.

There are also some critical environment variables that make programs available or alter shell behavior. The EDITOR environment variable, for example, can set your preferred text editor. Oftentimes, when installing a programming language or software utilities, you need to set the PATH environment variable..

Where to Start

Zsh configuration files are kept in the user's home directory and are named with a dot as the first character to keep them hidden by default.

Zsh recognizes four different configuration files in the user's home directory: ~/.zshenv, ~/.zprofile, ~/.zshrc, and ~/.zlogin.

This is where Zsh configuration becomes puzzling, even for experienced developers. Tutorials rarely explain the differences, especially between the zprofile and zshrc files, leaving curious developers scratching their heads and blindly following instructions.

How is the Shell Used?

To understand the differences among Zsh configuration files, consider various shell uses, which can be classified as interactive or non-interactive, login or non-login sessions.

1. On macOS, each new terminal session is treated as a login shell, so opening any terminal window starts an interactive login session. Also, a system administrator who connects to a remote server via SSH initiates an interactive login session.
2. If a terminal window is already open and you run the command zsh to start a subshell, it will be interactive and non-login. Beginners rarely use subshells.
3. Automated shell scripts run without login or any user prompting. These are non-interactive and non-login.
4. Few people ever encounter a non-interactive login shell session. It requires starting a script with a special flag or piping output of a command into an SSH connection.

How do the Configuration Files Work?

These use cases necessitate different shell configurations, which explains why Zsh supports four different configuration files. Here's how the configuration files are used:

• ~/.zshenv: This is loaded universally for all types of shell sessions (interactive or non-interactive, login or non-login). It is the only configuration file that gets loaded for non-interactive and non-login scripts like cron jobs. However, macOS overrides this for PATH settings for interactive shells.
• ~/.zprofile: Loaded for login shells (both interactive and the rare non-interactive sessions). MacOS uses this to set up the shell for any new terminal window. Subshells that start within the terminal window inherit settings but don't load ~/.zprofile again.
• ~/.zshrc: Loaded only for interactive shell sessions. It is loaded whenever you open a new terminal window or launch a subshell from a terminal window.
• ~/.zlogin: Only used for login shell configurations, loaded after .zprofile. This is loaded whenever you open a new terminal window.

How to Use Each File

With that in mind, let's consider which configuration files you should use.

• ~/.zshenv: It is universally loaded, so you could use it to configure the shell for automated processes like cron jobs. However, it is best to explicitly set up environmental variables for automated processes in scripts and leave nothing to chance. As a beginner, you will not use this configuration file. In fact, few experienced macOS developers use it.
• ~/.zprofile: Homebrew recommends setting the PATH variable here. There's a reason PATH should be set in ~/.zprofile and not the universal ~/.zshenvfile: the macOS runs a utility path_helper (from /etc/zprofile) that sets the PATH order before ~/.zprofile is loaded.
• ~/.zshrc: This is the configuration file that most developers use. Use it to set aliases and a custom prompt for the terminal window. You can also use it to set the PATH (which many people do) but ~/.zprofile is preferred.
• ~/.zlogin: This is rarely used. Only important in managing the order of initialization tasks for login shells in complex environments. It can be used to display messages or system data.

How to Avoid Complications

These configurations may appear complicated. It made sense in the early days of computing to start time-consuming processes at login and not have them repeat when a new terminal was launched.

MacOS now launches any new terminal window as a login shell, loading both ~/.zprofile and ~/.zshrc files without concern for the shell startup time. So why not use one Zsh configuration file? A bow to history, plus configuration customization for the experts.

The key advantage of the ~/.zprofile file (versus ~/.zshenv) is that it sets environment variables such as PATH without override from macOS. The ~/.zshrc file could be used for the same but, by convention and design, is intended for customizing the look and feel of the interactive terminal.

Keep It Simple

If you're looking for simple guidelines, here's the current best practice.

• Use ~/.zprofile to set the PATH and EDITOR environment variables.
• Use ~/.zshrc for aliases and a custom prompt, tweaking the appearance and behavior of the terminal.
• If you write automated shell scripts, check and set environment variables in the script.

More Information

I've written other guides that go into detail about the following:

• Mac Terminal
• Shell Configuration
• Mac PATH.

If you're just getting started, you'll need to know How to Open Mac Terminal and Install Xcode Command Line Tools.

Configuring the Zsh shell is a critical step in preparing your Mac development environment. With your development environment set up, you'll be prepared for any tutorial you'll find on freeCodeCamp.

In this article, you'll learn how to exit a Python program in the terminal using the following methods:

• The exit() and quit() functions in Windows and macOS (and other Unix-based systems – we'll use macOS to represent them).
• The Ctrl + Z command in Windows.
• The Ctrl + D command in macOS.

How to Run a Python Program in the Terminal

To run Python in the terminal, you have to open your terminal and run the python command.

Note that the Python command will only work in your terminal if you have Python installed on your computer.

After running the command, you should have something like this in the terminal:

C:\Users\USER>python
Python 3.10.8 (main, Nov  6 2022, 23:27:16)  [GCC 12.2.0 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.

Python command in the terminal

I am using Command Prompt for Windows but this should work the same way if you're using macOS or Linux.

Now you can run Python code in the terminal:

>>> print("Welcome to Py in the terminal!")
Welcome to Py in the terminal!

How to Exit a Python Program in the Terminal Using the exit() and quit() Functions

You can use the exit() and quit() functions to exit a Python program in Windows and macOS.

>>> print("Welcome to Py in the terminal!")
Welcome to Py in the terminal!
>>> exit()

C:\Users\USER>

exit() command in Python terminal

In the example above, we printed "Welcome to Py in the terminal!" before exiting the terminal using the exit() function.

After the function is executed, you'll be able to use the terminal the regular way (with the Python environment).

The process is the same for the quit() function:

>>> print("Welcome to Py in the terminal!")
Welcome to Py in the terminal!
>>> quit()

C:\Users\USER>

exit() command in Python terminal

How to Exit a Python Program in the Terminal Using the Ctrl + Command

You can exit a Python program running in a Windows terminal using the Ctrl + Z command:

>>> print("Welcome to Py in the terminal!")
Welcome to Py in the terminal!
>>> ^Z


C:\Users\USER>

ctrl + z command to exit Python terminal in Windows

Similarly, you can use the Ctrl + D command in macOS.

Summary

In this article, we talked about running a Python program in the terminal.

We saw how to run Python in the terminal using the Python command.

We also saw how to exit a Python program in the terminal using a couple different methods.

The exit() and quit() functions can exit a Python program in the terminal for both Windows and macOS.

Alternatively, you can use the Ctrl + Z command to exit a Python program in the terminal in Windows and Ctrl + D in macOS.

Happy coding! You can learn more about Python on my blog.

Well, this article will show you how those print functions/methods actually work. You'll also learn the differences between the println and the print methods.

In Java, methods work like functions in other programming languages. But since Java developers typically prefer the term "Function", I am going to use that terminology as well for all of my Java-related articles.

If you want to print something in the terminal, you need to use one of the print methods. There are actually three different print methods in Java. They are the print, printf, and println methods. We'll see how each of them works now.

How to Use the print Method in Java

This is the most generic print method in Java, but developers only use it if they do not want to get any new line characters after printing the statement inside it. For example:

System.out.print("Fahim");
System.out.print("Bin Amin");

The output would be like below:

FahimBin Amin

I have not specified any newline character explicitly here, so it will not generate any new line explicitly. So, we will not get any new lines after printing the first statement.

If you do not know what escape sequences are and how they actually work, I have prepared this video for you. Make sure to watch it if you need a refresher.

🎥 Video Tutorial

If you want to add any spaces between the two statements even though you want to print them on the same line, then you can simply add a trailing space in the first statement or a leading space in the second statement.

System.out.print("Fahim ");
System.out.print("Bin Amin");

The output will be:

Fahim Bin Amin

So, the print method is the most basic print method that doesn't add any specific thing other than simply printing the statement inside the method.

How to Use the printf Method in Java

You use the printf method to organize a statement differently. For example:

double value = 5.984;
System.out.println(value);
System.out.printf("%.2f" , value);

The output is 5.98 because we have specified that we want to print exactly 2 digits after the radix (.) point. In those cases, we use the printf method.

How to Use the println Method in Java

This method is the most widely used print method in Java. Whenever we want to print a newline after printing the statement inside of the method, we use this println method.

If you are using the "Extensions for Java" extension in the Visual Studio Code or if you are using the well known IntelliJ IDEA IDE, then you can get the full println method ( System.out.println("") ) in the editor by simply using the shortcut "sout".

Now, it is time for an example:

System.out.println("Fahim");
System.out.println("Bin Amin");

The output is:

Fahim
Bin Amin

As I used the println methods in both statements, each statement provides a newline character after printing the statement inside of it. So, after printing Fahim, I am getting a new line – in that new line, I am getting Bin Amin.

🎥 Video Tutorial

You can watch the video I made for you to help you understand these print methods better:

Conclusion

Thanks for reading this entire article. I hope this helps you get started on your Java programming journey.

You can follow me on:

• GitHub: FahimFBA
• LinkedIn: fahimfba
• Twitter: Fahim_FBA
• YouTube: Code With FahimFBA
• Website: https://fahimbinamin.com/

If you want to support me, then you can also buy me a coffee!

Cover: Photo by Tracy Adams on Unsplash

The terminal has a lot of utility commands, but most people are unaware of many of them.

I've seen people using Microsoft Word or Google to check the spelling of a word. But this utility command is a handy alternative tool for developers to check their spelling. The fact that it comes pre-installed with the terminal is an added advantage.

How to Use the Linux Spell Check Command

ispell and aspell are the 2 commands you can use to check the spelling of a word. Out of these 2, ispell is the old spellchecker from GNU which has a limited capability to read different kinds of encoded files.

aspell is an interactive spell checker which checks the spelling via standard input or by reading through the file. It checks spelling on UTF-8 encoded files. It can read and check the spelling on markdown files, too.

aspell has a lot of options. Running --help with the command shows the list of all the available options.

aspell --help

aspell --help command output

If you encounter errors while running the above command, it means that you don't have it installed. Run the following command to install aspell in your machine:

sudo apt install aspell

How to Check the Spelling of Words One-by-one Interactively?

Pass the -a flag with the aspell command to open it in interactive mode.

aspell -a

aspell -a command to open aspell in interactive mode

In this mode, you can enter the words with possible incorrect spelling one by one and you will get a list of words with the correct spelling that are the closest to the entered word.

Here's an example screenshot:

Correct word suggestions from aspell command

From the above screenshot, you can see that aspell suggests multiple words for each incorrectly-spelled word I entered.

The close alternatives for the word sampee are sample, simper, sampler. Similarly, you can see the suggestions for other words too (waier, calendrr, moble, bqttle).

This can be quite handy for developers since they can quickly switch to the terminal and find the correct spelling of a word during their development. The fact that it does not require the internet is an added advantage.

How to Check the Spelling of Words from a File

Using the terminal to check the spelling of words from a file is the best alternative approach if you don't have internet access. Grammarly and Google Docs will best assist you with a good internet connection.

You can write the passage in a text file and pass the file path as an argument to the -c flag in the aspell command. This accepts an HTML or Markdown file too.

aspell -c <filename>

I've created a file named computer.txt and added the below content:

Content of computer.txt file

I've made some spelling mistakes in the middle. You might be able to spot them easily. Some of them are macine instead of machine, intrenet instead of internet, etc.

Let's ask aspell to find the spelling mistakes in this passage.

aspell -c computer.txt

Once you run the above command, you'll be shown a screen similar to the following screenshot:

aspell command to find spelling mistakes in a file

This means that aspell has figured out some spelling mistakes in our passage. It will highlight the misspelled words one-by-one with the appropriate alternative correctly spelled words at the bottom.

There will be 10 options shown with a row number. You can choose the correctly spelled word by entering the corresponding row number.

For example, in the above screenshot, the word "macine" is highlighted and the right replacement for this misspelled word is "machine", which is the 1st option. So, I press 1.

Immediately after I press 1, the correction was made and aspell moves to the next misspelled word.

aspell command corrects and moves to the next misspelled word in the file

In addition to the 10 options, aspell shows 8 different options. You can choose one of the them if you did not find the right word from the above 10 alternate options.

Let's understand each option you can use with aspell:

The above table describes the action for each character in the aspell check command.

Once you're done with correcting the spelling of all the misspelled words, the file will be automatically saved by aspell.

In addition to that, a new file will be created with the name .bak, which is a backup of the same file without applying spell check.

How to Ignore Creating a New File While Correcting Spelling in a File

This is quite simple and can be easily achieved by passing a flag with the aspell command. The flag is --dont-backup.

Let's look at an example command:

aspell check --dont-backup computer.txt

Ignore creating a backup file by passing --dont-backup flag

From the above screenshot, you can see that I've removed the existing computer.txt.bak file and run the spell check by passing the --dont-backup flag. No more .bak file has been created after I complete the spell check.

You may also notice one more change from the previous example and the above command. That is check and -c. In my previous command, I used -c, but in the above command, I used check to pass the file name.

You can either use -c or check to pass the file name. Both of them do the same job.

Can You Check the Spelling on Other Files?

Absolutely yes. aspell checks for spelling by reading Markdown and HTML files, too. You have to pass the mode of the file as a separate argument ( --mode ).

Here's the syntax,

aspell check --mode=<mode_type> file_name

The supported modes are none, url, email, markdown, html, tex, texinfo, and nroff.

Let's see a quick example of fixing the spelling mistakes on a markdown file.

aspell check --dont-backup --mode=markdown spellcheck.md

Running aspell with the markdown file

It opened a similar interface, but it understood the markdown format and highlighted only the misspelled word.

I want to bring one important item to your attention. You can find a misspelled word (blok) in the middle of the backtick (...) block. The content inside this block will not be evaluated by the aspell command. So, you'll not be able to spot and correct the misspelled words inside the block.

Similarly, you can evaluate the spelling in the HTML files by changing the mode to html.

Conclusion

In this article, you have learned to check spelling using your Linux Terminal. I hope you enjoy reading it.

Subscribe to my newsletter by visiting my site and also have a look at the consolidated list of all my blogs.

( ( 11 + 97 ) + ( 2 * 63 ) - ( 7 / 93 ) * ( 8 - 25 ) / ( 9 * 64 ) ) * ( ( 64 / 34 ) + ( 94 - 20 ) - ( 23 + 98 ) * ( 199 * 928 ) / ( 92 * 26 ) ) * ( ( ( 2 * 1 ) / 2 ) - 1 )

Kudos to you if you solved it on your own. I'm sure you'll be angry with me, though, after discovering that the result of this long expression just evaluated to zero.

So what if you used your browser to find the answer? How long would that take?

Searching this expression on Google took less than a second to get the answer (using a 500MBPS connection) along with 5,21,00,000 results.

Search results by Google for the given expression

Yahoo gave us the answer in less than 500 ms along with 1,480,000,000 search results.

Search results by Yahoo for the given expression

Bing didn't even return anything.

But my terminal and system calculator were almost instant in finding the answer (took < 10 ms).

Using the terminal is one of the quickest ways to evaluate a mathematical expression. But many developers are unaware that you can solve mathematical expressions using your terminal.

In this article, you'll learn how to solve math problems in the Linux terminal.

How to Evaluate a Mathematical Expression in the Linux Terminal

You can use the expr command to evaluate mathematical expression in your terminal. Basic mathematical operations such as addition, subtraction, multiplication, division and modulus all work using the expr command.

Let's have a quick look at each of these operations:

expr 12 + 8   # Addition

expr 20 - 10  # Subtraction

expr 5 \* 2   # Multiplication

expr 8 \/ 4   # Division

expr 5 \% 3   # Modulus

Using the expr terminal command to find answers to arithmetic operations

Running each of those commands in the terminal evaluates and returns the answer of that expression (as you can verify in the attached screenshot).

You might be thinking, "Why is there a backward slash () for the last 3 operations (Multiplication, Division, and Modulus)?"

A backward slash in programming is basically used to escape characters. Let's take the example of the Multiplication symbol (). "" is used in regular expressions which basically means to include all files and folders.

Here's a quick example:

cp ./* ../backup/

Running the above command will copy all the files and folders in the current directory to the backup directory.

Similarly, each symbol has their own meaning. Using a backward slash () will escape its regular usage pattern. This is the reason that most symbols are prefixed with a backward slash.

But, you may wonder, is this all this command can do?

The answer is no. I've shared a sample of the expressions, but we could use any others and get the results in a fraction of a second.

How to Evaluate a Logical Expression in the Terminal

In addition to finding the results of a mathematical expression, you can use this command to evaluate a logical expression.

Logical expressions containing <, <=, >, >=, =, != can be evaluated with this command.

Let's have a quick look at how it works:

expr 2 \< 1

expr 29320 \> 23820

expr 29320 \>= 29320

expr 29320 \< 29320

expr 29320 \<= 29320

expr 293202 \= 293203

expr 293202 \!= 293203

Evaluate logical expressions with expr command

The command returns "1" if the expression evaluates to true and "0" if it evaluates to false.

From the above commands you can notice that all the logical operators are escaped with a backward slash ().

What Do the Special Logical Operators Do?

I read your mind. You're thinking, "I know about logical operators. What are the special logical operators?".

Well, the special logical operators are:

• AND (&)
• OR (|)

From a programming perspective, the AND operator evaluates to true if both sides of the operator evaluates to true. The OR operator evaluates to true if either of the sides evaluates to true.

Here's the table for your reference. Some people may be familiar with 1 and 0. For those people, replace FALSE with 0 and TRUE with 1.

But they have a completely different usage with the expr command. Let's have a quick look at it.

The expr command works similar to the above table. But there's an exception for a particular case. This command will never return 1 if an expression evaluates to true – instead it returns an argument.

Evaluating expr ARG1 | ARG2 returns ARG1 if ARG1 is neither null nor 0, otherwise it'll return ARG2. On the other hand, evaluating expr ARG1 & ARG2 returns ARG1 if neither of the arguments are null or 0 . It returns 0 otherwise.

Let's examine few examples with the logical OR operator:

expr 1 \| 2     # Returns first argument (1)

expr 0 \| 2     # Returns second argument (2) as first argument is 0

expr "" \| 2    # Returns second argument (2) as first argument is null 
                  (Empty string [""] is considered as null in terminal)

expr 100 \| 78    # Returns first argument 100

expr "" \| ""   # Returns 0 as both arguments are null ("")

Evaluating logical OR expressions with expr command

The above screenshot represents operations with logical OR operator (|). Reading that you may still have a couple of questions:

What's the purpose of using empty double quotes ("") in the expression?

Empty double quotes represent a null value in bash. So, as said earlier, if the first argument is null, the second argument is returned.

What if both the arguments are null?

When evaluating both arguments with null values, both the Logical OR and AND operators return 0.

Let's examine a few examples with the logical AND operator:

expr 1 \& 2     # Returns first argument (1)

expr 1 \& 0     # Returns 0 as one (second) argument is 0

expr 0 \& 1     # Returns 0 as one (first) argument is 0

expr "" \& 1    # Returns 0 as one (first) argument is null ("")

expr 1 \& ""    # Returns 0 as one (second) argument is null ("")

expr "" \| ""   # Returns 0 as both arguments are null ("")

Evaluating logical AND expressions with expr command

How to Perform String Operations with the expr Command

The expr command is not limited to mathematical and logical operations. It can perform string operations, too.

Pattern Matching with Regex

The expr command can verify if a text matches with a regex pattern. It returns the matched pattern of the text if it exists or else returns an empty line.

The syntax to verify the regex is:

expr STRING : REGEXP

or

expr match STRING REGEXP

expr command evaluates regex pattern match with the given text

You can achieve this either by using the match keyword or by using a semicolon (:) between the string and the regex pattern.

Alternatively, you can use the semicolon to find the number of characters matching between the two texts.

Here's an example:

expr Remember : Remo    # Returns 0

expr Remember : Rem     # Returns 3

expr command to find the number of characters matching the given text

Find the length of a text

You can use the expr length command to find the length of the given text.

expr length Linux

expr length "Learning Linux is fun"

expr length command showing the number of characters in the given text

You can enter the text directly after the expr length command if it does not have any spaces. If the text has spaces, enclose them within double quotes (""), or else you'll get an error.

Find a character in a text

You can find a particular character from a given text using the expr index command. It returns the place where the character exists.

expr index STRING CHAR

expr index to find a character from a text

Remember that the expr index command performs a case-sensitive search and returns the first matching index of a character from the text.

Extract a substring from a string

Extracting a substring from a string is simple using expr command. Entering the string, start index, and number of characters to be clipped after the start index will return the expected substring.

expr substr Carpenter 4 3      # Returns pen

expr substr command to find a substring from a string

Conclusion

In this article, you have learnt the use cases of the expr command.

If you enjoyed my tutorial, you can subscribe to my newsletter on my personal site to receive more such insightful articles straight to your inbox. You'll also find a consolidated list of all my blog posts.

In this article, you will learn a command that has exceptional benefits.

For example, say you want to take a look at your calendar to plan a vacation. What are a few ways you can open the calendar? Well, there's Google/Outlook, your system desktop calendar, your mobile phone calendar, and more.

But did you know that you can get a calendar just by typing three letters? In this article, I'll teach you this helpful three-letter command and share some fun experiences of using date with my team.

How to Query Your Terminal for the Date

I remember I was busy working one day. I asked one of my colleagues sitting next to me, "Do you know the date of next week Friday?" Then I realized that he was wearing headphones and appeared to be deeply concentrating on his code.

I didn't want to disturb him further, and I was about to ask my other colleague sitting right opposite me.

"November 25", the colleague whom I thought couldn't hear me replied.

I was amazed – how'd he know that fast?

"Oh, man! I thought you were coding. How did you get the date?" I asked him, surprised.

"I was querying the terminal to find the answer to the question you asked me", he replied, showing his terminal window.

The terminal window had the following command:

dd "next week Friday"

I didn't understand what he'd done, so I as.

"Well, Linux by default supports the date command to display today's date and to set the current date and time in our system. It also provides a way to find a date in the future and past as simply as we speak. date is the command to do all stuff related to date and time", he replied.

I was more confused about the dd command and I asked him to clarify how it worked.

"But if date is the command, what's dd? Is that part of the date command?"

He explained that dd is not associated with the date command. Rather, it was just a shortcut command (I'll be writing about this in my future tutorials) that he created. dd abbreviates to date --date="<given_date>".

So, the actual command is this:

date --date="next week Friday"

I ran the same in my terminal and was amazed to see the output.

Linux terminal command to find the date of the given day

This was cool and I thanked him for his super helpful explanation. On further research, I found that this command was able to answer most of my queries. I felt like I was interacting with an AI system.

I'm posting a few of my queries here:

Query terminal for a future or past date

How to Get Specific Info About a Date in Linux

Up until now, we have been trying to find a particular day with our query. But, what if you want to find some info about a date? After a bit more research, I found that you can find the day of the week of a date using the same command.

The following command displays the day of the week of August 1, 2015:

date --date="2015-08-01"
date --date="08/01/2015"

Terminal command to find the day of a date

How to Find Information About a List of Dates in Linux

My coworker had a list of dates. He needed a script that displayed each date with the day. He'd gotten stuck trying to figure it out, and asked for my help.

He was clear on his problem. But he has gone wrong with the steps he took to achieve it. On further discussion, I found that he searched the following items sequentially in Google.

• How to open a file in read mode?
• How to read line by line?
• How to parse the date in the file?
• Finally, How to find the day of that date?

In the middle of this discussion, I remembered that you can do this quickly with the super powerful date command. The fact is that the date command does all the above actions – our job is just to give the path of the file.

Terminal command to parse dates from a file

The fact that it can read and parse the date given in any format is an added advantage. From the above screenshot, you will be able to understand how simple it is to solve my coworker's problem.

Remembering the quote from Unfiltered: No Shame, No Regrets, Just Me by Lily Collins

Asking for help is never a sign of weakness. It's one of the bravest things you can do. And it can save your life.

How the Date Command Works with File Operations

If you've read my previous tutorial on getting started with Linux, you may remember that with the stat command we can get some info about the file such as its size, date created, last date modified, and so on.

Well, did you know you can find the last modified time of a file using the date command?

Yes – by adding the -r flag with the date command and the file path, you can find the last modified time of the file. It looks like this:

date -r install_git.sh

Terminal command showing the last modified time of a file

There is another place where this date command might be more familiar. You use it to create a file with a timestamp. For example, system administrators often use it to see system and server logs. I've also heard that people in stock trading also rely on creating files with timestamps.

Here's a quick example of creating a file with date and time:

vi file-$(date "+%Y-%m-%d_%I:%M:%S").txt

Terminal command to create a file with date and time

For first time users, it might be tough to understand the above command.

Let's break this command down to understand it better:

• vi is my text editor
• file-$(date "+%Y-%m-%d_%I:%M:%S").txt is the name of the file

Let's bisect the date command in the file name further:

• date "<some_format>" prints the date in the specified format
• %Y is the current year
• %m is the current month
• %d is today's date
• %I is hours
• %M is minutes
• %S is seconds

How to Find the Date and Time in a Different Time Zone

One of my other team members raised this interesting question.

It's possible to find the date and time in another time zone with the date command. But, it's not so user-friendly. You need to remember the full name of the timezone to get the date and time. But, it works out of the box.

I'm in India and we follow Indian Standard Time (IST). I can use the below command to find the time in New York.

TZ='America/New_York' date

Terminal command showing New York time

The below screenshot shows you the time comparison across different time zones such as Singapore, America, and India.

Terminal command showing time across different timezone

What is the Three-Letter Command to Get Your Calendar?

Are you waiting to know the 3 letter command to view the terminal?

It is the cal command.

Terminal command to display the calendar

Here's a bonus tip for you.

You can view the calendar of any year by just adding the year next to the cal command.

Terminal command showing 2022 calendar year

Terminal command showing 2023 calendar year

If you wish to learn more about the cal command you can reach out to me on social media.

Note: date and cal come pre-installed in many Linux distributions. If you encounter the date: command not found error while running the date command, you just need to install the coreutils package by running the following command:

sudo apt install coreutils

Conclusion

In this tutorial, I shared my experience of using the date command in Linux. I hope you enjoyed reading this article.

To have more insightful blogs delivered to your inbox, subscribe to my newsletter here.

People also suggested that I should get used to using the keyboard and terminal over a mouse to enjoy the ultimate power of Linux.

So I started learning various terminal commands and keyboard shortcuts. The fact that I could type pretty fast was a cherry on the cake.

In this article, I'll walk you through the experiences I had learning to handle file and folder operations in Linux.

Prerequisites

Before starting to use terminal, you need to get familiar with two commands. They'll come in handy for whatever operations you're trying to do.

They are the cd and ls commands.

• **cd** is a command that lets you navigate to a path or a different folder in terminal
• **ls** is a command that lets you list all the files and folders in a directory

How I Started Learning Some Basic Linux Commands

I love downloading and reading files and books from the internet. But I used to have a bad habit of downloading all the files into the Downloads folder.

One day I was in a hurry to search a document, because I had to give a presentation. But opening and searching through the long list of files in my Downloads folder was really frustrating for me as it had 1000+ files.

I wanted to find a shortcut to identify the file. The only clue I had was that it's a PDF document. So, I planned to copy all the PDF files to another temporary folder.

How to copy only PDF files from one folder to another

cp is the command to copy the files. Thankfully the Linux terminal supports regex almost everywhere. So, my work became quite simple. Here's the code to copy the pdf files into another folder:

cp <file(s)_to_copy> <destination_folder>

How to copy only the pdf files from one folder to another?

From the above screenshot, you may be confused about the mkdir Temp_PDF_Files command. You use the mkdir command to create a new directory.

Some of you might also be confused with _./_*.pdf in the cp command. Basically, in the programming world we call this a Regex. Regex stands for Regular Expression, and we use them to filter items by matching patterns. In our case, it's the files ending with the .pdf extension

After running the command, there were fewer than 50 PDF files. I was able to find the file in couple of minutes.

So as you can see, it's always advisable to categorize your downloaded files.

Cool, I was done with my presentation. But, I wanted the file to be named properly, so that I could find it more quickly in the future.

How to rename a file in Linux

I Googled to learn how to do this, but I was amazed to see the same answer everywhere, which I felt was not right. It was the mv command, which I ideally used to move a file/directory from one path to another.

After digging down further, I found that it was the same mv command to rename the file.

mv <existing_file_name> <new_file_name>

How to rename a file in Linux?

I finished renaming the file. But, I didn't want the temporary folder which I'd created to copy all the PDF files.

How to delete a folder completely in Linux (including it's files and sub-folders)

Before getting into this, I copied the renamed file to a safe place which I could remember easily in the future. I was bit nervous as I was about to delete the entire folder. I usually get this feeling whenever I delete anything.

You can delete files and folders with rm -rf command which I'd used many times before.

rm -rf <folder_name>

How to delete a folder completely in Linux?

But be careful as it's a dangerous command. It won't ask for any confirmation before deleting the folder. Recovering a folder deleted with this command is almost impossible.

How to Create and Read Files in Linux

People usually get stressed out when they're late, and this is worse for important meetings or online classes. This happened to me – and it led me to a great experience of learning about handling file operations via the terminal.

It was a bright morning and my online class had already started – and I was delayed by 2 minutes. I wanted to start taking notes, but I had put my notebook and pen somewhere the night before and couldn't remember exactly where.

The very next thing that came to my mind was to open Google Docs. But that site would take some time to load.

"Why don't I create a text file on my machine and start taking notes? ", was the question that hit my mind next.

How to create a file in Linux

I remembered that one of my friends told me that you can use the touch command to create a file instantly. But, I hadn't tried that out yet. So I did:

touch notes.txt

touch - Linux command to create a file

But... But... But...

This command creates a file and does not open this file in edit mode so you can start taking notes. This is where you can use your favorite text editor to open a file.

vim and nano are the two well-known text editors available in Linux.

vim is an advanced and powerful text editor you can use to perform complex file operations and it's what many Linux System Administrators use.

nano, on the other hand, is a simple text editor which you can use to perform simple file operations.

I was using nano, so I ran the command nano notes.txt. This opens up the text file in edit mode instantly. I started taking notes from the session.

Finally, I reached the end of class, but I didn't know to save the file. I didn't dare try any commands before getting a backup of my notes. So, I picked up my mobile and took a snap of my notes.

After a quick Google search, I found that the command was "CTRL + X" to save the file (which will prompt Yes / No to save the file, and hitting "Y" and pressing "Enter" will save it).

After saving the file, I was curious to check if I had saved it correctly.

How to read the contents of a file in Linux

After doing a Google search, I found that there are multiple ways to read a file. cat, head, and tail are a few commands you can use to read a file, and they each have their own use cases.

• The **cat** command displays the entire contents of the file
• The **head** command displays the few lines at the top of the file usually used to check if you're about to open the correct file
• And the **tail** command displays the bottom few lines of the file usually used to read logs from any process.

Here's an example of the cat command:

cat notes.txt

Reading contents on my notes file with cat command

And here's the output of the **head** and **tail** commands:

Output of head command displaying top few lines of notes file

Output of tail command displaying last few lines of notes file

How to read the contents of a file with line numbers in Linux

One day, one of my colleagues asked me, "Hey! Do you know how to display the contents of a file with their line numbers in the terminal? "

I hadn't came across any such commands explicitly available for this. I knew I could write a script that reads the file line by line, and then print them on the console by pre-pending line numbers for each line.

He wanted to explore that option.

We both started to work our way through this problem. Interestingly, in the middle, we found a single and straightforward command.

Yes – I'm talking about the nl command. You use it like this:

nl notes.txt

nl command shows contents of file with line numbers

That's amazing, isn't it? As you can see from the code above, the nl command shows the contents of the file with line numbers.

Linux Commands I Learned from My Team

My team and I used to sit together and work as a group. We would ask questions about any random technical stuff and tried to explore solutions for any issues that came up. So I wanted to quickly summarize some of the things I learned from my colleagues here.

Most of them revolve around a lot of file utility commands available in Linux which most people are unaware of. During our development time, we come across multiple scenarios that had to do with handling files.

My colleague Naras asked this question:

What's a command to find the properties of a file?

Well, the stat command displays the properties of the file such as name, size, permissions, created by the user, created and updated date and time, and so on. It looks like this:

stat - Terminal command to display the properties of the file

Is there a command to find number of words in a file?

It was an awesome question from Udhaya.

Yes. But, not just words – you can also count lines and bytes using the wc command.

wc command displays number of lines, words and bytes of a file

The above displayed file has 23 lines and 121 words. Its size is 809 bytes.

Can you find the type of the document with a command?

Few weeks back, I encountered an extraordinary question from Kumar:

"Most documents are created with their extension. But recently I found that some PDF documents are not created with .pdf extension. Do we have a command to find the type of document? "

Yes we do. The file command displays the type of the document, like this:

file notes.txt

file command displaying the type of notes.txt file

To answer his question, here's the proof showing the type as PDF document before and after removing the extension from the file name:

file command displaying file type without the extension

How can I find the occurrences of a word in a file?

My colleague Divad asked if we could find all the lines where a particular word was available in a file.

And I realized that this was possible with the grep command.

So what's grep?

**grep** stands for Global search for Regular Expression and Print out. It's basically a searching tool which matches with a Regex pattern and prints them.

grep -i "Linux" notes.txt

**grep** command displays lines containing Linux from notes.txt file

The **-i** flag indicates to perform case insensitive search. To perform case sensitive search, remove the -i flag from the command.

What if I want to find all the lines that don't contain a particular word?

Raman raised the question, "What if I want to find all the lines that does not contain the given word?"

It's possible using the same grep command but by applying the -v argument, like this:

grep -v "Linux" notes.txt

**grep -v** command displays lines not containing the word Linux from the notes.txt file

As you can see, by discussing our questions and working things out together, we learned a lot.

Conclusion

In this article, I've shared my experience using Linux when I was a beginner. I hope you enjoyed reading this article.

You can connect with me here.

You can follow me on Instagram, Twitter, LinkedIn and Medium.