Terminalis in the Logistics Tech Industry

Terminal

terminal

Dubai’s Prime Minister and Vice President Sheikh Mohammed bin Rashid Al Maktoum said on Sunday that the new <strong>terminal</strong> would be five times the size of the current Dubai International Airport and handle up to 260 million passengers annually.

Dubai announces $35bn construction of world’s largest airport terminal | Aviation News | Al Jazeera

The Problem: “cd” & “ls” Suck 👎 Using command to change the directory and to preview files in the current directory may work sometimes, but it’s frustrating to have to use this workflow all the time whenever you want to go somewhere. cd ls The Solution I will give you 3 solutions not just one to make your life easier in terminal and jump easily between files. “Give me six hours to chop down a tree, and I will spend the first four sharpening the axe.” — Abraham Lincoln Let’s Sharpen Our Axe 🪓 You’re gonna need some to follow with me: perquisites Zsh Tmux Zoxide LF Fzf Solution 1: Zoxide zoxide is a smarter cd command This one is pretty cool; here’s what it does: It remembers all directories you visit and organizes them by most frequent. All you need is to type some letters from the name des => Desktop It jumps immediately there (super super cool) Step 1: Install It With Homebrew Brew install zoxide. Step 2: Initialize in ~/.zshrc open your ~/.zshrc file, and add this to initialize it eval "$(zoxide init zsh)" source ~/.zshrc to apply the changes source ~/.zshrc Step 3: Use Zoxide Instead of “cd” First, you need to visit the directories you want to jump to, so can identify it and fuzzy find it. zoxide Type + any letters you remember from the directory. z z desk// cd ~/Desktop Solution 2: LF Manager lf (as in "list files") is a terminal file manager written in Go with a heavy inspiration from ranger file manager Let me tell you a secret; this is my favorite one 🤫 if you’re like me, using Vim navigation keys hjkl After you get used to it, you suddenly want to use them everywhere. does exactly that; it works like columns view in Finder but with Vim. LF But don’t get me wrong; it still works with regular “Arrow” keys as well. Step 1: Install It With Homebrew Brew install lf. Step 2: Change the Directory on Quit “ it’s funny, but for some reason, it didn’t change the directory on quit” It’s like the main point, right !! 🥲 So, let’s fix this with a small function working as a wrapper to lf. It just saves the last directory path in the temp file, then cd to it. Add this function to your ~/.zshrc lf Wrapper function lf { local tmp=$(mktemp) command lf -last-dir-path="$tmp" "$@" cd "$(cat "$tmp")" rm -r "$tmp" } Step 3: Customize Your “lfrc” File It’s the LF config file to customize it; I like to keep it minimal. few UI interface configurations shortcuts to jump to my frequent main directories with a small cheatsheet for favorite LF shortcuts you’re gonna find it at ( if you can’t find it, create it ) ~/.config/lf/lfrc | |/ ) __ _ | | | / | | | () | | | | | | || _/ | ___ ___ _ __ / ( / _ | ' | |/ ` | | | | | ( | | ( | */|| ||| |*|, | | UI Set hidden # show hidden files set icons # show icons for files/directories set relativenumber # show files/directories relative numbers Jump Shortcuts map gh cd ~ # use 'gh' to go home directory map gp cd ~/personal/ # use 'gp' to go personal directory map gw cd ~/work/ # use 'gw' to go work directory map gt cd ~/tools/ # use 'gt' to go tools directory map gd cd ~/Downloads/ # use 'gd' to go downloads directory map gv cd /Volumes/ # use 'gv' to go volumes for (external drives) map gb cd ~/brainExt # use 'gb' to go obsidian BrainExt vault Fav Shortcuts hjkl/gg/G # Vim-like Navigation (move) space/v/u # select/invert/unselect (select) y/d/p/c # yank/delete/paste/clear (change) i/e/l # open with less/default-editor/default-app (open) change your default editor in ~/.zshrc To make sure that when you use shortcut, it always opens with it. e Then verify that your default editor changed: echo $EDITOR export EDITOR=vi # change default editor to vim Step 4: Cool Tmux Keybinding Imagine this scenario: you’re working on a file in Tmux, then do a quick shortcut open in new window to open any file from the same directory 🚀 lf Let’s go do exactly that, in ~/.tmux.conf But first, make sure that zsh is our default shell for the tmux conf Set the Default Shell to zsh set-option -g default-shell /bin/zsh this smart keybinding opens a new window with the name “Files.” ctrl+f The new window starts from the same path as well as your current window. And finally, it opens directly there ( use q to quit ) lf ctrl+f => lf (q) bind -n C-f new-window -n "files" -c "#{pane_current_path}" "zsh -ic 'lf; zsh'" Don’t forget to source ~/.tmux.conf tmux source-file ~/.tmux.conf Solution 3: Tmux-fzf Script For this one, we don’t just use another utility. We build our own tmux manager script to fuzzy find all our project files in specific directories and jump. 🦘 Step 1: Organize Your Project Files in Specific Directories For example ~/personal ~/work ~/tools Step 2: Build “Tmux Manager” Bash Script Create a new file with the name in the tools directory. tmux_manager.sh Change this file into an executable: chmod +x tmux_manager.sh This script lists all projects in those directories to fuzzy find. Finally, open the selected project as (or create it if not found) Tmux Session #!/usr/bin/env bash _ __ ___ _ ___ __| | | | /_\ | | | ' ` _ | | | \ / / | || | | | | | || |> <| | | ,/ use fuzzy finder to get my working directories paths session=$(find ~ ~/personal ~/work/ ~/tools -mindepth 1 -maxdepth 1 -type d | fzf) get last part as a name & replace any (.) with (_) session_name=$(basename "$session" | tr . _) if the session doesn't already exist, create it. if ! tmux has-session -t "$session_name" 2> /dev/null; then # remove err msg to null tmux new-session -s "$session_name" -c "$session" -d fi switch to the session by name tmux switch-client -t "$session_name" Step 3: Create an Alias to Our “Tmux Manager” Script open ~/.zshrc, to add our new Alias Don’t forget to source it 😉 source ~/.zshrc alias tm="~/tools/tmux_manager.sh" Step 4: Cooool tmux keybinding for “Tmux Manager” The same trick we did before with lf. A quick shortcut will run our tmux manager script alias. ctrl+t It will open in a new tmux window; a big list of all projects. Your selected project will open in its own Tmux session. Tell me that this isn’t cool ?! 🙃 bind -n C-t new-window -n "tmux" "zsh -ic 'tm; zsh'" don’t forget to source ~/.tmux.conf tmux source-file ~/.tmux.conf Let’s Be Friends on Twitter 👋 https://twitter.com/belalsamyyy

A Blazing Fast File Management for Terminal ⚡️

is a Python project that aims to provide a simple yet efficient timer for terminal users, particularly targeting the geek community. This project allows users to set timers directly from their command line interface, making it convenient for those who spend a significant amount of time working in the terminal! The main objective of is to offer a minimalistic and distraction-free timer experience. It provides a clean and straightforward interface, ensuring that users can focus solely on tracking time without any unnecessary clutter or distractions. MyTimer MyTimer GitHub Repo Installation Source Code Download or Version 0.9 Latest Source pip install . PyPI Check Python Packaging User Guide pip install mytimer==0.9 Demo Usage ⚠️ You can use or to run this program mytimer python -m mytimer Version mytimer --version Basic ⚠️ Press to exit Ctrl + C mytimer Time Limit mytimer --minute=7 --second=30 mytimer --hour=2 --minute=20 Timer Mode ⚠️ The default mode is count-up mytimer --minute=7 --second=30 --countdown mytimer --minute=7 --second=30 --countup Alarm ⚠️ This mode may not be supported on all systems mytimer --minute=7 --second=30 --alarm Alarm Repeat ⚠️ The default value is 1 mytimer --minute=7 --second=30 --alarm --alarm-repeat=5 Tone ⚠️ The default tone is 1 mytimer --minute=7 --second=30 --alarm --tone=2 Tones List Face mytimer --minute=7 --second=30 --face=3 Faces List Program mytimer --program=black-tea Programs List Message mytimer --minute=7 --second=30 --message="Test message" Show your support Give a ⭐️ if helped you! this project

Introducing MyTimer: A Geeky Timer for Terminal Enthusiasts

Tired of reopening terminal windows every time you come back to a VSCode project? You can pick up right where you left off without having to re-run setup commands and reopen programs by using Tmux sessions. Read on to find out how. Introducing Tmux Tmux (Terminal Multiplexer) is basically a window manager for your terminal. It has two main functionalities: Splitting the terminal into multiple windows and panes. Storing your terminal sessions in a server process, allowing you to reattach to the session even after closing your terminal instance. Tmux is super powerful and has many use cases. For example, you can protecting your remote ssh terminal sessions from being nuked when dealing with a flaky connection. If you’re not already familiar with this tool, I recommend to get started. Ham Vocke’s “Quick and Easy Guide to tmux” Instructions for setting up Tmux in VSCode To start persisting your terminal sessions using Tmux in VSCode: Step 1: Make sure you have Tmux installed If you’re using macOS, you can use Homebrew by running the following command in your terminal: brew install tmux For Ubuntu or WSL users, you can install it by executing: sudo apt-get install tmux If you’re using any other linux distro I’m sure you probably already know what you’re doing Step 2: Add a new terminal profile Open VSCode settings with Cmd+Shift+P (macOS) or Ctrl+Shift+P (Windows/Linux) Search for . This will open the file. Open User Settings (JSON) settings.json Under or , add: terminal.integrated.profiles.osx terminal.integrated.profiles.linux "terminal.integrated.profiles.osx": {
  //...existing profiles...
  "tmux-shell": {
    "path": "tmux",
    "args": ["new-session", "-A", "-s", "vscode:${workspaceFolder}"]
  }
} This runs on terminal startup, connecting to existing sessions named after the workspace folder. This way, if you’ve already created a terminal for this project, you’ll connect back to it automatically! tmux new-session Step 3: Set Tmux as the Default Terminal Profile Finally, to make the newly created Tmux profile the default for your system, add or modify the following line in the file: settings.json "terminal.integrated.defaultProfile.osx": "tmux-shell" Now, every time you open VSCode terminal, Tmux will startup automatically, allowing you to pick up exactly where you left off last time. Conclusion We’ve gone over how to integrate Tmux into VSCode’s integrated terminal. You can now use Tmux’s powerful session and window management easily inside VSCode! Also published . here

Tmux & VSCode — Persist Terminals for Productivity and Profit

As developers, we spend a lot of our time in the terminal. Most of the developers I talked to use several tools in their console... yes, the console, that itchy thing that will only display letters and numbers. This tool is more powerful than you think. And there are very many nice handy tools to use. This post outlines my list of tools that every developer must have or has heard about ;). So let's get started! Utils - Auto-correct miss-typed commands thefuck is one of those utilities you won't be able to live without once you've tried it. Whenever you mis-type a command and get an error, just run and it'll auto-correct it. Use up/down to choose a correction, or just run to just execute the most likely immediately. thefuck fuck fuck --yeah - Community-maintained docs ) tldr (better man is a huge collection of community-maintained man pages. Unlike traditional man pages, they're summarized, contain useful usage examples and nicely colourized for easy reading tldr - Count lines of code ) scc (better cloc gives you a breakdown of number of lines of code written in each language for a specific directory. It also shows some fun stats, like estimated cost to develop and complexity info. It's incredibly fast, very accurate and has support for a wide range of languages scc - Listing Files ) exa (better ls is a modern Rust-based replacement for the command, for listing files. It can display file-type icons, colors, file/folder info and has several output formats - tree, grid or list exa ls - Disk Usage ) duf (better df is great for showing info about mounted disks and checking free space. It produces a clear and colorful output, and includes options for sorting and customizing results. duf - Download Utility ) aria2 (better wget is a lightweight, multi-protocol, resuming download utility for HTTP/HTTPS, FTP, SFTP, BitTorrent and Metalink, with support for controlling via an RPC interface. It's incredibly , and has tons of . There's also - a nice web interface companion. aria2 feature rich options ziahamza/webui-aria2 - Reading Files ) bat (better cat is a clone of with syntax highlighting and git integration. Written in Rust, it's very performant, and has several options for customizing output and theming. There's support for automatic piping and file concatenation bat cat - File Comparisons ) diff-so-fancy (better diff gives you better looking diffs for comparing strings, files, directories and git changes. The change highlighting makes spotting changes much easier, and you can customize the output layout and colors diff-so-fancy - Watch for changes entr lets you run an arbitrary command whenever file changes. You can pass a file, directory, symlink or regex to specify which files it should watch. It's really useful for automatically rebuilding projects, reacting to logs, automated testing, etc. Unlike similar projects, it uses kqueue(2) or inotify(7) to avoid polling, and improve performance entr - Reading + writing metadata exiftool ExifTool is handy utility for reading, writing, stripping and creating meta information for a wide variety of file types. Never accidentally leak your location when sharing a photo again! - Duplicate file finder fdupes is used for identifying and/or deleting duplicate files within specified directories. It's useful for freeing up disk space when you've got two or more identical files jdupes - Fuzzy file finder ) fzf (better find is an extremely powerful, and easy to use fuzzy file finder and filtering tool. It lets you search for a string or pattern across files. fzf also has available for most shells and IDEs, for showing instant results while searching. This by Alexey Samoshkin highlights some of it's use cases. fzf plugins post - Command benchmarking hyperfine makes it easy to accurately benchmark and compare arbitrary commands or scripts. It takes care of warm-up runs, clearing the cache for accurate results and preventing interference from other programs. It can also export results as raw data and generate charts. hyperfine - Process viewer procs (better ps) is an easy to navigate process viewer, it has colored highlighting, makes sorting and searching for processes easy, has tree view and updates in real-time procs - Search within files ) ripgrep (better grep is a line-oriented search tool that recursively searches the current directory for a regex pattern. It can ignore the contents of and skip binary files. It's able to search within compressed archives, or only search specific extension, and understands files using various encoding methods ripgrep .gitignore - Fast, incremental file transfer rsync lets you copy large files locally or to or from remote hosts or external drives. It can be used to keep files across multiple locations synced, and is perfect for creating, updating and restoring backups rsync - Find and replace ) sd (better sed is an easy, fast and intuitive find and replace tool, based on string literals. It can be executed on a file, an entire directory, or any piped text sd - Directory hierarchy ) tre (better tree outputs a tree stye list of files for your current or a specified directory, with colors. When running with the option, it numbers each item, and creates a temporary alias that you can use to quickly jump to that location tre -e CLI Monitoring and Performance Apps - Bandwidth utilization monitor bandwhich Show bandwidth usage, connection information, outgoing hosts and DNS queries in real-time - Container metrics and monitoring ctop Like , but for monitoring resource usage for running (Docker and runC) containers. It shows real-time CPU, memory and network bandwidth as well as the name, status and ID of each container. There's also a built-in log viewer, and options to manage (stop, start, exec, etc) containers top - Resource monitoring ) bpytop (better htop is a fast, interactive, visual resource monitor. It shows top running processes, recent CPU, mem, disk and network history. From the interface you can navigate, sort and search - there's also support for custom color themes bpytop - Resource monitor + web and API glances is another resource monitor, but with a different feature set. It includes a fully responsive web view, a REST API and historical monitoring. It's easily extendable, and can be integrated with other services glances - Interactive ping tool ) gping (better ping can run ping tests on multiple hosts, while showing results in real-time graph. It can also be used to monitor execution time, when used with the flag gping --cmd - Disk usage analyzer and monitor ) dua-cli (better du let's you interactively view used and available disk space for each mounted drive, and makes freeing up storage easy dua-cli - Command line speed test utility speedtest-cli just runs an internet speed test, via speedtest.net - but straight from the terminal :) speedtest-cli - DNS lookup client ) dog (better dig is an easy-to-use DNS lookup client, with support for DoT and DoH, nicely coloured outputs and the option to emit JSON dog CLI Productivity Apps Surf the web, play music, check emails, manage calendars, read the news and more, all without leaving the terminal! - CLI web browser browsh is a fully interactive, real-time, and modern text-based browser rendered to TTYs and browsers. It supports both mouse and keyboard navigation, and is surprisingly feature rich for a purely terminal based application. It also mitigates battery drain issues that plague modern browsers, and with support for MoSH, you can experience faster load times due to reduced bandwidth browsh - Bookmark manager buku is a terminal-based bookmark manager, with tons of configuration, storage and usage options. There's also an optional and , for accessing your bookmarks outside of the terminal buku web UI browser plugin - Music browser / player cmus is terminal music player, controlled with keyboard shortcuts. It has support for a wide range of audio formats and codecs, and allows organising tracks into playlists and applying playback settings cmus - Track crypto prices cointop show current crypto prices, and track the price history of your portfolio. Supports price alerts, historical charts, currency conversion, fuzzy searching, and much more. You can try the demo via the web at , or by running cointop cointop.sh ssh cointop.sh - Search the web from the terminal ddgr is like , but for DuckDuckGo. It's fast, clean and easy, with support for instant answers, search completion, search bangs, and advanced search. It respects your privacy by default, and also has HTTPS proxy support, and works with Tor ddgr googler - Code editor ) micro (better nano is an easy to use, fast and extendable code editor with mouse support. Since it's packaged into a single binary, installation is as simple as micro curl https://getmic.ro | bash - Calendar client khal is a terminal calendar app, which shows upcoming events, month and agenda views. You can sync it with any CalDAV calendar, and add, edit and remove events directly khal - Email client mutt is a classic, a terminal based mail client for sending, reading and managing emails. It supports all mainstream email protocols and mailbox formats, allows for attachments, BCC/CC, threads, mailing lists and delivery status notifications mut - RSS / ATOM news reader newsboat is an RSS feed reader and aggregator, for reading the news, blogs and following updates directly from the terminal newsboat - Todo + task management taskwarrior is a CLI task management/ todo app. It's both simple and unobtrusive, but also incredibly powerful and scalable, with advanced organisation and query features built in. There's also a lot (700+!) of extra for extending it's functionality and integrating with third-party services task plugins - Terminal UI for Reddit tuir is a great one if you want to look like you're working, while actually browsing Reddit! It's got intuitive keybindings, custom themes, and can render images and multi-media content too. There's also for hacker news tuir haxor CLI Dev Suits - HTTP / API testing testing client httpie is a HTTP client, for testing, debugging and using APIs. It supports everything you'd expect - HTTPS, proxies, authentication, custom headers, persistent sessions, JSON parsing. Usage is simple with an expressive syntax and colourized output. Like other HTTP clients (Postman, Hopscotch, Insomnia, etc) HTTPie also includes a web UI httpie - Full Docker management app lazydocker is a Docker management app, that lets you view all containers and images, manage their state, read logs, check resource usage, restart/ rebuild, analyse layers, prune unused containers, images and volumes, and so much more. It saves you from needing remember, type and chain multiple Docker commands. lazydocker - Full Git management app lazygit is a visual git client, on the command line. Easily add, commit and puch files, resolve conflicts, compare diffs, manage logs, and do complex operations like squashes and rewinds. There's keybindings for everything, colors, and it's easily configurable and extenable lazygit CLI External Sercvices - Reverse proxy for sharing localhost ngrok safely* exposes your localhost to the internet behind a unique URL. This lets you share what you're working on with you're remote colleagues, in real-time. Usage is , but it's also got a lot of advanced features for things like authentication, webhooks, firewalls, traffic inspection, custom/ wildcard domains and much more ngrok very simple - Fast file sharing transfer.sh makes uploading and sharing files really easy, directly from the command line. It's free, supports encryption, gives you a unique URL, and can also be self-hosted.I've written a Bash helper function to make usage a bit easier, you can or try it out by running transfer find it here bash <(curl -L -s https://alicia.url.lol/transfer) - Deploy a site in seconds surge is a free static hosting provider, that you can deploy to directly from the terminal in a single command, just run from within your directory! It supports custom domains, auto SSL certs, pushState support, cross-origin resource support - and it's free! surge surge dist - Check the weather wttr.in is a service that displays the weather in a format that's digestible in the command line. Just run or to try it out. There's URL parameters to customise what data is returned, as well as the format wttr.in curl wttr.in curl wttr.in/London CLI Fun - Have an ASCII cow say your message cowsay is a configurable talking cow. It's based off the by Tony Monroe cowsay original - Output text as big ASCII art text figlet outputs text as ASCII art figlet - Make console output raibow colored lolcat makes any text passed to it rainbow coloured lolcat - Show system data and ditstro info neofetch prints distro and system info (so you can flex that you use Arch btw on r/unixporn) neofetch As an example, I'm using , , and to create a custom time-based MOTD shown to the user when they first log in. It greets them by their name, shows server info and time, date, weather and IP. . cowsay figlet lolcat neofetch Here's the source code Conclusion I think there is at least one interesting tool for you and your productivity enlisted in this list. Hope you enjoy! Also published . here

Unleashing the Power of the Terminal: Essential Tools Every Developer Should Know

In this article, the exciting realm of making terminal applications smarter is delved into by integrating ChatGPT, a cutting-edge language model developed by OpenAI. The focus is on exploring how ChatGPT and other LLM models such as WizardCoder, MPT can revolutionize the user experience by enabling natural language interactions, thus opening up new possibilities for enhanced productivity and efficiency. To access the project directly, please click the provided . link Large Language models have revolutionized the field of natural language processing, empowering developers and researchers to build intelligent applications. In this article, we explores how these models bring intelligence to terminal applications. Three different models were used for this purpose. ChatGPT, MPT and WizardCoder. ChatGPT, developed by OpenAI, is a state-of-the-art language model designed for generating human-like text responses. It excels in engaging in interactive and dynamic conversations with users. From providing detailed answers to answering questions, ChatGPT showcases the power of language models in natural language understanding and generation. MPT is a multilingual variant of the popular Transformer model. It has been trained on a vast corpus of text from different languages, enabling it to understand and generate text in multiple languages. MPT enables cross-lingual applications, machine translation, and language understanding tasks, bridging communication gaps across diverse linguistic communities. WizardCoder is an innovative language model specifically designed for code generation and programming assistance. It understands programming languages and can generate code snippets based on user prompts. With WizardCoder, developers can leverage the power of language models to speed up their coding tasks, explore code suggestions, and gain insights into best coding practices. GPTerm This project focuses on the conversion of plain text into shell commands using ChatGPT and open-source language models. While some models yielded satisfactory results, others fell short of expectations. The primary terminal application used in this study is iTerm, although the project is anticipated to be compatible with other terminal applications as well, even though specific tests have not been conducted. The project is divided into two main parts. In the first part, the user can manually enter and execute shell commands within the current plugin without closing it. The second part involves the translation of given plain text into shell commands, which are then presented to the user. If desired, the user has the flexibility to modify or remove certain sections of the generated command without executing it. Both sections function in a similar manner. To differentiate between manual input of shell commands and obtaining shell commands from plain text, a dot (.) must be placed at the beginning of the plain text. This allows the application to determine the user’s intention accurately. The project aims to serve as a convenient tool for users who need quick reminders or clarification regarding shell commands they may have forgotten or become confused about. It also provides suggestions for alternative and more efficient commands than the ones they intend to write. Users can also verify the correctness of their commands, all without the need for extensive internet searches. This project involves conducting experiments with three different models to explore their performance and obtain varying results. The initial focus was on the ChatGPT model, which yielded the most successful and reliable outcomes. Since generating shell commands often involves small-word scripts, the number of tokens remains low, resulting in cost-effectiveness. As a result, ChatGPT is a suitable choice. However, tests were also conducted with other models. In addition to ChatGPT, the WizardCoder and MPT models were also utilized, focusing on CPU performance by employing quantized models. However, it is recommended to conduct tests with the original states of the models, as higher success rates are anticipated in such scenarios. The MPT model correctly interpreting some commands while providing incorrect answers in other cases. It was also observed that there were instances where the response was non-responsive. Given that no customized model based on code exists, this behavior can be considered natural. Based on observations, the WizardCoder model outperforms the MPT model. Although it may appear slightly less advanced compared to ChatGPT, it still offers acceptable results for those interested in utilizing open-source models. It is important to note that while results obtained from ChatGPT are delivered in a highly structured JSON format, other open-source models may occasionally produce noisy responses to questions. Below, you will find the results obtained from open-source models. 1-
{
  "command": "mkdir creator && cp /new/hua/* creator/"
}
```<|im_end|>

2-
~~~json
        {
            "command": "ls -l /storage | grep pdf | sort -r"
        }
        ~~~
3-
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n    
    {"command": "cd storage && touch ny.py"     }' In particular, when working with open-source models, occasional instances of noisy results, as depicted above, may arise. To solve this problem, a regular expression (regex) approach has been implemented to effectively remove any noise from such outcomes. In future iterations, the regex pattern will be refined to encompass all possible error cases. However, for the current implementation, the pattern has been tailored to address the most prevalent sources of noise, considering the constraints of time. However, in the current implementation, the pattern has been adjusted to effectively handle the main sources of noise, taking into account the time limitations. Usage To begin with, it is recommended to work within an environment. In this project, the conda environment “py1” (sample conda env name) is utilized for development. Then; pip3 install gpterm-tool You can run the provided above command for installation purposes. Once installed, it can be utilized by using the ‘gpterm’ keyword on iTerm or any other terminal application. Run with ChatGPT model (Highly Recommended) gpterm -k <openai_api_key> Run with MPT model gpterm -m mpt -p <quantized_mpt_model_path> Run with WizardCoder model gpterm -m wizardcoder -p <quantized_wizardcoder_model_path> As the models used have a large number of parameters and are executed on the CPU, the processing speed of the results may be slower. The project was developed on an M1 MacBook Pro, and no tests with GPU implementation have been performed yet. Hence, for professional use, it is recommended to opt for the ChatGPT model. For swift access and usage of this program, you have the option to include an alias in the zshrc file. This allows for convenient and rapid execution of the program. My conda env name is py1. alias gt='conda activate py1 && gpterm -k <openai_api_key>' Following that, the program can be easily launched via the terminal by simply entering the “gp” keyword. You can see the answers given by ChatGPT and WizardCoder models to the same questions below. ChatGPT vs WizardCoder ChatGPT name_ai ---> . go in storage folder and sort only pdf files reversely

>>> cd storage && ls -r *.pdf

name_ai ---> . Create a folder named sample_1 and create a txt file for each number starting from 1 to 10 in it and assign that number as the name

>>> mkdir sample_1 && for i in {1..10}; do touch sample_1/$i.txt; done

name_ai ---> . Create a file named nw_1 with .txt extension and add all the numbers from 1 to 10 in it

>>> touch nw_1.txt; echo {1..10} >> nw_1.txt WizardCoder name_ai ---> . go in storage folder and sort only pdf files reversely

>>> ls -l storage | grep pdf | sort -r

name_ai ---> . Create a folder named sample_1 and create a txt file for each number starting from 1 to 10 in it and assign that number as the name

>>> mkdir sample_1 && cd sample_1 \\ Wrong one here !

name_ai ---> . Create a file named nw_1 with .txt extension and add all the numbers from 1 to 10 in it

>>> touch nw_1.txt && echo '1 2 3 4 5 6 7 8 9 10' >> nw_1.txt ChatGPT provides highly accurate responses. In the WizardCoder model, it successfully generated the correct command in two out of the three requests, although it did produce an incorrect command in one request.As mentioned previously, chatgpt is highly recommended for professional applications. Nevertheless, by retraining the WizardCoder model using the commands that are frequently used, its effectiveness can be enhanced. Project Repo : https://github.com/ademakdogan/GPTerm Github : https://github.com/ademakdogan Linkedin : https://www.linkedin.com/in/adem-akdoğan-948334177/ References Radford, A., Wu, J., Child, R., Luan, D., Amodei, D., & Sutskever, I. (2019). Language models are unsupervised multitask learners. arXiv preprint arXiv:1911.02116. Yin, P., Deng, L., Li, J., & Zettlemoyer, L. (2021). Model Programming Transformer. arXiv preprint arXiv:2105.14947. Brown, T. B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., & Amodei, D. (2020). Language models are few-shot learners. arXiv preprint arXiv:2005.14165. Luo, Z., Xu, C., Zhao, P., Sun, Q., Geng, X., Hu, W., … & Jiang, D. (2023). WizardCoder: Empowering Code Large Language Models with Evol-Instruct. arXiv preprint arXiv:2306.08568. Gu, J., Li, Z., Zhang, H., Wang, H., Liu, S., Wu, Q., … & Sun, X. (2021). Llama: Language Model Pre-training Without Masking. arXiv preprint arXiv:2102.10219.

GPTerm: Creating Intelligent Terminal Apps with ChatGPT and LLM Models

Let's learn about via these 42 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Terminal /Learn Repo 1. 10+ Things I Love About Linux Linux is growing and evolving even after 30 years since its birth, but the core ideas behind it remain the same, which opens the doors to new horizons. 2. How to Make your Rails App Work with the Mac M1 Chip [SOLVED] Get your rails app running from terminal using the following steps on MacBook M1 Chip. 3. Dashboards, monitoring and alerting — right from your terminal !!! As a backend developer, I always need to monitor something. State machine in the database, records count, message queue lag, custom application metrics, system performance, progress of my deployment scripts. Tons of stuff! 4. You Can Track Stock Market Data From Your Terminal As a developer, I love working with the terminal. The plain, simple, and in my opinion the best way to interact with the computer (also it makes you look geeky) 5. Introducing the Terminal Reader App by HackerNoon This is a web application with the intention of providing a different way of reading. Yes, you will be reading in a terminal-like application. 6. 6 Essential Linux Terminal Commands Everyone Should Know Linux is one of the best-known and most used operating systems in the world. Here are 6 essential commands which can make you better at using Linux systems. 7. How To Create Reusable Bash Scripts Bash is a language that is quite useful for automation no matter what language you write in. Bash can do so many powerful system level tasks. Even if you are on windows these days you are likely to come accross bash inside a cloud VM, Continuous Integration, or even inside of docker. 8. Creating a Terminal Emulator in React How to create a terminal emulator in React and Typescript 9. POSIX: An Untold Story Tapping the keys while sitting in front of black terminal, traversing the huge logs and sipping from a cup of coffee. 10. Git Commands That Every Developer Must Know Git, an open source distributed version control system has been helping developers over a decade now. It is a great tool for tracking source code changes during software development. However, there are a lot of git commands, and this article lists the most important ones that will help your team get work done efficiently. 11. How to Run Multiple Terminal Commands in ONE, Like a Boss Buck is a free, open-source and lightweight CLI tool used by developers to group multiple terminal commands into one. 12. React Ink for CLI: A Gentle Introduction React Ink is a library that brings the power of React to designing Command-Line Interfaces. 13. Using a Script to Send Desktop Notifications from Your Linux Terminal Send visual feedback and reminders from scripts, using notify-send and at commands on Linux.  Also how to get MacOS to do it as well, through some jury-rigging. 14. How to Install and run Swift on a Linux Machine How to install and run Swift on Linux 15. Why You Should Convert Your Images To WebP WebP lets you compress your images as efficiently as possible, reducing the size of your web page while preserving quality. You can convert from the terminal 16. Warp: The Terminal For the Modern Developers Today, I’m proud to officially introduce Warp, a from-first-principles reinvention of the terminal to make it work better for developers and teams. 17. Setting up a Development Workflow in the Windows Terminal For decades, Windows users have been made fun of by the Linux community for the lack of a cool terminal (among other things). Well, it's about time we fight! 18. What is the Difference between Telnet and SSH? Telnet and SSH are network protocols used to manage and access devices remotely. SSH is more secure and preferred because it encrypts data sent over the network 19. Pioneer Challenge: Overview The Terminal hasn't changed much since the 1980s. Every other aspect of your workflow is radically different. Especially in the last decade, we’ve seen companies transform industries with the advent of collaborative software: Figma (collaborative design), Github (collaborate code), G Suite (collaborative Word and Excel) and more. 20. Make Your Rust Code More Rustic By Breaking Some Rules Warp engineer and resident Rust expert @ChuckAPierce  writes about when to break the rules of Rust's infamous borrow checker. 21. Get the Most Out of Your Terminal: A Comprehensive Guide to WezTerm Configuration Alacritty, Kitty, Foot, and WezTerm can be challenging due to the lack of a Getting Started guide and limited examples. I'll walk you through my configuration, 22. 16 Commands For Every Use Case to Set Up React Apps in Seconds ⚡🚀 In this article, I have handpicked 16 commands to set up your React apps in seconds. 23. 9 Fun Command-Line Tools to Make Your Life Easier Command-Line Tools to Make Your Life Easier and More Fun 24. Poor Command-Line Hygiene? Consider Load-bearing the Shell History Can you use your command-line shell history as a second brain? Should you? Here are some ideas to help leverage the humble Ctrl-r key to supercharge your work. 25. How to Set Up an iPad for Machine Learning Development If you have an iPad and want to use it as a development tool, you only need to complete 5 steps before using it. In this guide, you'll learn how to: 26. Keeping SSH Connection Alive for Longer Durations SSH connection gets terminated if the server(or client, in some cases) is idle for a certain period of time. It can be fixed by a simple trick. 27. How to Set Up a World Where Dyeing Your Hair Terminal Green Shows Dedication to Your Job Step 1: Make #02550 your project’s primary color over a beer with a friend for no particular reason. 28. How to Enable Autocomplete (and AI) in your Terminal Here's how I enhance my terminal with autocomplete and Artificial Intelligence 29. Let's Build a Linux Shell [Part I] Since the early days of Unix, the shell has been part of the user's interface with the operating system. The first Unix shell (the Thompson shell) had very limited features, mainly I/O redirection and command pipelines. Later shells expanded on that early shell and added more and more capabilities, which gave us powerful features that include word expansion, history substitution, loops and conditional expressions, among many others. 30. The Problem With Promotion-Obsessed Cultures The problems with promo-culture 31. How To Install Bash On Windows 10 Microsoft recently joined hands with Canonical (the parent company of Ubuntu) to bring the entire userland into Windows, minus the Linux Kernel. So as a result, you, as a developer, get access to the whole range of Ubuntu command-line tools and utilities with bash shell integrated with Windows. Let’s look at how we can install Bash on Windows 10 and take full advantage of the new feature. 32. Real-time Scanning of Other Terminals with Strace Introduction 33. Working With Files In Python Most of us have had that one experience where we had a ton of dis-organized files in our machines. It happens. One minute, you're opening a large zip file, the next thing you know,  the files are everywhere in the directory, mixing with all your important files and randomly placed leaving you with the task of manually sorting what needs to go where. It's a real pain. To ease this process, we're going to delve into file management with python the smart way. 34. A Simple Sequential and Parallel Task List Runner for Terminal Taskz is a library for Node.js, a simple sequential and parallel task list runner for terminal. 35. Building A Linux Shell - Part II [A Step-by-Step Guide] In the first part of this tutorial, we've built a simple Linux shell that prints a prompt string, reads input, then echoes the input back to the screen. This isn't very much impressive now, is it? 36. Basic Commands That Will Help You Get Started With Terminal At first, the command line interface can be overwhelming: it’s an empty screen and a prompt. 37. How I Inspect & Manipulate Files from the Command Line 38. A Linux, Mac and UNIX Tutorial Of The Top 6 Cool Terminal Commands For Beginners In this tutorial, you'll learn the most common and useful commands that you can run in almost any UNIX-like environment, including Linux and Mac OS X. 39. Exploring the New GitHub CLI Github just released it’s own Command-Line Interface (CLI) so developers can now do everyday GitHub tasks from the terminal. Yay! This means no more squiggling around the UI. With this new CLI, you can now view, create, clone, or fork repositories, create, view, and edit gists, you can also work with pull requests and issues right from the terminal. 40. Building a Linux Shell [Part III] This is part III of a tutorial on how to build a Linux shell. You can read the first two parts of this tutorial from these links: part I, part II. 41. Building a Linux Shell [Part IV] This is part IV of a tutorial on how to build a Linux shell. You can read the previous parts of this tutorial from the following links: part I, part II, part III. 42. Building a Linux Shell [Part V] This is part V of a tutorial on how to build a Linux shell. You can read the previous parts of this tutorial from the following links: part I, part II, part III, part IV. Thank you for checking out the 42 most read stories about Terminal on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

42 Stories To Learn About Terminal

GPU terminals are all the rage these days. The competition between players like , , , , and is heating up, and there's still no clear winner. Although they don't have all the fancy features that classic terminals like or have, such as good support for bitmap fonts and ligatures, they can be faster at displaying and refreshing large amounts of information. And even though the average person (not a Counter Strike champion with a 240Hz monitor) is slow at processing all that information, the ability to optimize terminal performance can be a fun way to show off your nerdy side 🤓. Alacritty Kitty Foot Warp WezTerm iTerm2 Terminator I chose to change from to one of the powered alternatives... The question now is, which one should I choose? But first, I'll give an ultra-brief rundown on each one. iTerm2 Alacritty 💨 In my opinion, it's the slowest one, and its stability is questionable. It has a minimalistic style, with a simple UI that doesn't have tabs or panes and lacks font ligatures. Some people have reported that it crashes frequently. Also, the author is well-known for their meticulous attention to detail, which is why new features are added slowly. Despite its shortcomings, it still has 2.5 times more Github stars than our next option. Kitty 🐱 The Terminal offers more customization options and boasts a , with occasional spikes of , while Alacritty has a latency of 50ms. The Terminal has better font rendering and supports ligatures, although they may need to be set up. Unfortunately, Kitty is not available on Windows. latency of 35ms 7ms Foot 🦶 A lesser-known option in the area. Even though it doesn't have GPU support, I still wanted to mention it because it's known for its low resource usage. In my testing, it only used 13-19 MB of RAM. It has fast performance thanks to its clever design that minimizes input latency even without GPU rendering. So, the terminal is both high-performing and resource-efficient. The author and compares them to Alacritty. thoroughly explains the performance trade-offs Warp 🌀 A truly innovative and reinvented version of classic terminals that operates like a code editor, featuring AI command search powered by GPT-3. With a new stdin/stdout interaction workflow and many other exciting features, it's a game-changer for some hipster-like individuals (if you don’t afraid of telemetry). WezTerm 🤠 My favorite one. Although the cowboy emoji might suggest a connection to the Western genre, it has nothing to do with the terminal itself. The name is simply the author's name. Wez If you're looking for a terminal that's the same across Windows, Mac, and Linux, then WezTerm is the one for you. Built using Rust, just like Alacritty, so boasts high performance. It's loaded with many well-documented features and easily customizable using Lua configs, making it a favorite among Vim users. Despite being a relatively new release, its documentation is already top-notch, better than any other terminal. Base Configuration That being said, configuring WezTerm can be challenging due to the lack of a guide and limited examples. When you first install WezTerm, your file will be blank, leaving you in the dark about all the fantastic features the terminal offers. But don't worry! That's where this article comes in. I'll walk you through my configuration, explaining each line in detail and providing a complete example you can use or modify to fit your specific needs. Getting Started ~/.wezterm.lua Let's start by defining some global variables that we'll use later. The module provides access to WezTerm configuration and control in your config file. It's a good practice to put this line at the top of your config file. wezterm local wezterm = require 'wezterm' Now, let's add two more variables. The module manages the multiplexer layer, which is responsible for everything related to panes, tabs, windows, and workspaces, but not the terminal itself. And the module helps us bind keys to actions. Technically, is a specific enum constructor, while is a separate Lua module, but for now, it doesn't matter. wezterm.mux wezterm.action action mux local mux = wezterm.mux
local act = wezterm.action Let's go a bit further. The function triggers a after a specific occurs. As you can see, the event invokes . Simply saying, the function runs immediately after the terminal starts. It's pretty straightforward. wezterm.on callback event gui-startup function(cmd) Next, we create a new window using , which returns objects associated with that window. Although we may not utilize these returned values, it is necessary to capture them anyway. That's just how it works. If you need a more precise understanding, you can find definitions of available functions on the search page of WezTerm's website. mux.spawn_window Also, I like to maximize the window right away. wezterm.on('gui-startup', function()
 local tab, pane, window = mux.spawn_window({})
 window:gui_window():maximize()
end) The next substantial final part begins with a statement. return return {
 default_prog = { '/usr/local/bin/fish', '-l' }
 window_decorations = "RESIZE"
 ...

} Yes, in the WezTerm structure, we need the result of our configuration so that the rest of the configuration will be enclosed in 's brackets. return return With , we set our favorite shell. Mine is fish. The flag means running as if it started as a login shell. By setting to , we achieve a minimalist design by disabling the title bar and enabling the resizable borders. When we open WezTerm, we'll get a maximized window without a title bar, just the way we like it. default_prog -l window_decorations RESIZE Okay, got it. Let's have some fun with WezTerm's panes. You can change the background colors, but to avoid any health issues due to a lack of design skills, the only options available for adjustment are saturation and brightness. This is done by design in WezTerm, so you can easily see which pane you're currently on when you switch between them. inactive_pane_hsb = {
 saturation = 0.8
 brightness = 0.7
} Let's check out the desired outcome. The actual style will depend on the color scheme, so we're going to the next chunk of the configuration, called theme. is a good theme, but you can find to your taste on the official website. Don't need to install something. Just put the theme's name under . Hardcore 746 others color_scheme color_scheme = 'Hardcore'
font = wezterm.font('JetBrainsMono Nerd Font')
font_size = 14
line_height = 1.2 The font is a big deal for hackers. I like 'cause it's top-notch and free. I might like even more, but it's too pricey. JetBrainsMono Nerd Berkeley Mono The size I set to 14 depends on your monitor and personal preference. For me, the font is ideal when it's too small but not relatively small enough. The height follows the same rule, I think. But it's better to leave the height at 1 because the font designer won't be happy if you change it. The font was developed with its original height, and if you mess with it, you might mess up the thing creator intended. Moving next. use_dead_keys = false
scrollback_lines = 5000 You may not know about dead keys. If so, let me introduce you to . These keys can cause some problems in Vim editors and specific shell hotkeys. Secondly, the scrollback lines refer to the number of lines you want to keep in view per tab. I don't remember when I need to keep more than 5000 lines. Wikipedia Next, let's tweak the font size to avoid issues when using tiling window managers like Yabai (which I use). As for the second option, I'm not sure if I need to add something. adjust_window_size_when_changing_font_size = false
hide_tab_bar_if_only_one_tab = true Moving on, let's take control of the appearance of the tab bar. A unique font for tabs can break your eyes from the main font and make your setup look more professional and (maybe) designer-like. window_frame = {
 font = wezterm.font { family = 'Noto Sans', weight = 'Regular' },
} Hotkeys Configuration Now, let's dive into customizing our hotkeys. The command where our key customization start. By doing the following step, we're turning off all the default key assignments, so we'll have to set each binding explicitly. disable_default_key_bindings = true The leader key is a combination of keys that allows users to quickly access various features and commands in a software program using keyboard shortcuts. In VSCode, the default leader key is usually set to on Windows or Linux and on Mac. However, this can be customized to suit individual preferences. The way it works is that you first press the leader key and then press another key to trigger a specific function. This differs from hotkeys, which require you to press multiple keys simultaneously. Ctrl Cmd leader = { key = 'b', mods = 'CMD', timeout_milliseconds = 2000 } Although I set a leader key, I rarely use it because it makes you slower. Classical hotkeys work faster for me, so most of the configuration I will share later is about them. The following chunk is vast. Most of the values are taken from defaults. I’ll say only about the keys I changed. keys = {
  { key = 'l', mods = 'CMD|SHIFT', action = act.ActivateTabRelative(1) }
  { key = 'h', mods = 'CMD|SHIFT', action = act.ActivateTabRelative(-1) }
  { key = 'j', mods = 'CMD', action = act.ActivatePaneDirection 'Down', }
  { key = 'k', mods = 'CMD', action = act.ActivatePaneDirection 'Up', }
  { key = 'Enter', mods = 'CMD', action = act.ActivateCopyMode }
  { key = 'R', mods = 'SHIFT|CTRL', action = act.ReloadConfiguration }
  { key = '+', mods = 'CTRL', action = act.IncreaseFontSize }
  { key = '-', mods = 'CTRL', action = act.DecreaseFontSize }
  { key = '0', mods = 'CTRL', action = act.ResetFontSize }
  { key = 'C', mods = 'SHIFT|CTRL', action = act.CopyTo 'Clipboard' }
  { key = 'N', mods = 'SHIFT|CTRL', action = act.SpawnWindow }
  { key = 'U', mods = 'SHIFT|CTRL', action = act.CharSelect{ copy_on_select = true, copy_to =  'ClipboardAndPrimarySelection' } }
  { key = 'v', mods = 'CMD', action = act.PasteFrom 'Clipboard' }
  { key = 'PageUp', mods = 'CTRL', action = act.ActivateTabRelative(-1) }
  { key = 'PageDown', mods = 'CTRL', action = act.ActivateTabRelative(1) }
  { key = 'LeftArrow', mods = 'SHIFT|CTRL', action = act.ActivatePaneDirection 'Left' }
  { key = 'RightArrow', mods = 'SHIFT|CTRL', action = act.ActivatePaneDirection 'Right' }
  { key = 'UpArrow', mods = 'SHIFT|CTRL', action = act.ActivatePaneDirection 'Up' }
  { key = 'DownArrow', mods = 'SHIFT|CTRL', action = act.ActivatePaneDirection 'Down' }
  { key = 'f', mods = 'CMD', action = act.SplitVertical { domain = 'CurrentPaneDomain' }, }
  { key = 'd', mods = 'CMD', action = act.SplitHorizontal { domain = 'CurrentPaneDomain' }, }
  { key = 'h', mods = 'CMD', action = act.ActivatePaneDirection 'Left', }
  { key = 'l', mods = 'CMD', action = act.ActivatePaneDirection 'Right', }
  { key = 't', mods = 'CMD', action = act.SpawnTab 'CurrentPaneDomain' }
  { key = 'w', mods = 'CMD', action = act.CloseCurrentTab{ confirm = false } }
  { key = 'x', mods = 'CMD', action = act.CloseCurrentPane{ confirm = false } }
  { key = 'b', mods = 'LEADER|CTRL', action = act.SendString '\x02', }
  { key = 'Enter', mods = 'LEADER', action = act.ActivateCopyMode, }
  { key = 'p', mods = 'LEADER', action = act.PastePrimarySelection, }
  { key = 'k', mods = 'CTRL|ALT', action = act.Multiple
    {
      act.ClearScrollback 'ScrollbackAndViewport'
      act.SendKey { key = 'L', mods = 'CTRL' }
    }
  }
  { key = 'r', mods = 'LEADER', action = act.ActivateKeyTable { name = 'resize_pane', one_shot = false, }, }
} Switch Tabs Switching tabs in browsers has always been done with the + and + + hotkeys. That was until I learned Neovim, and I discovered a better way. Instead of using the traditional method, you can press + + to move to the right tab and + + to the left tab. This way of switching tabs is faster because it involves using both hands, making it easier to switch between tabs like a pro. It's a plus if you're a Neovim user and need to switch between tabs in both Neovim and WezTerm while working with your shell. And it becomes even better if you configure your browser (I use Chrome) with the same hotkeys, allowing you to switch tabs smoothly without moving your fingers much on the keyboard. Ctrl Tab Ctrl Shift Tab Ctrl Shift H Ctrl Shift L Spawn Tabs The tried and true method of using + to open a new tab and + to close it works seamlessly with browsers. Your muscle memory will thank you for using this familiar technique. Ctrl Tab Ctrl W Split Panes Quite easy. Similar to , but probably more accessible because you need always two fingers. Just + to split the pane vertically, and + to split horizontally. You can close the pane by + , however shell + work as well. iTerm2 Cmd F Cmd D Ctrl X Ctrl D Copying Text You can use the Enter key if you're lazy, but WezTerm is just as comfortable with a mouse. In that case, double-click (or highlight) the text, and it'll be copied right away without having to press + or anything similar. Ctrl C That's probably it! Just a heads up, you can set up keys for different sections like , , and more. I don't get into details since I mostly use the defaults. I hope this guide helped you take your WezTerm terminal configuration to the next level. copy_mode search_mode

Get the Most Out of Your Terminal: A Comprehensive Guide to WezTerm Configuration

At first, the command line interface can be overwhelming: it’s an empty screen and a prompt. When you type, text appears on the screen. But before you can get any use from it, you need to know what to type. Let’s take a look at the commands that will help get things done when you are just starting with the command line. Working directory Before we start any meaningful work, we first need to know where we are. The commands you run are evaluated in a folder—the working directory. There are a few commands that help you check your current context and move to a more convenient location: —shows the full path of your working directory: pwd —switches the working directory to : cd <folder> <folder> A few more examples with : cd —moves to the parent folder of the current one cd .. —moves back to the preview folder cd - —moves to home directory cd ~ Listing files So, now that we know what folder we are in, let’s now see what we have inside. The command to show a list of files is : ls As you see, both files and directories are shown together, and it’s not entirely clear what is what. I usually run this command with two parameters: —to show files, event the hidden ones -a all —to show the information in long format -l In the output you can see: & —aliases to the folder itself and its parent folder . .. —hidden folder for keeping the files used by a Git repository .git each line starts with or . The first means files; the second means directories. - d Managing files and folders To finish up with the basics, we just need some commands to modify the files and directories. Commands to do it: —creates an empty file touch <file-name> —creates an empty folder mkdir <directory-name> —removes the specified file rm <file-name> —removes the specified folder rm -d <directory-name> Read the friendly manual is a command that shows you a manual for other commands. All the commands we have mentioned so far have plenty of options. You can learn more about them directly from the terminal by using . You run : man man man <command name> Return value is a simple program that returns its arguments to the standard output. You can use it to write a value to a file: echo echo Test > test.txt Display files’ content a tool mean to con enates multiple files. It’s often used to pick the content of only one file, to get it to the standard input of another command with the pipe operator. Example: cat cat cat file-1.txt file-2.txt Count content of the file In the context of CLI, stands for word count. It lets you check the length of the output of other files: wc The output here means that in the specified file we have: 29 lines 116 words 542 characters View part of the file and are utilities to read a few lines from the beginning or end of the files, respectively. By default, both show 10 lines. You can see them in action: head tail Checking the whole file is a command that paginates a file or its input to fit it on the screen. I covered the basic navigation shortcuts in : less my recent article You can use to view the output of any other command—just connect with a pipe: less If you are confused by the terminology, I explain standard input, output, and pipes . here Searching the file content is a great search tool that supports . Its power comes from flexibility: by specifying one of its numerous options, you can tweak its behavior to what you need. By default, it waits for values to come in the standard input—not the most common use case. Therefore, you most likely want to run it as a filter inside a command pipeline. grep regular expressions The typical use as a pipe filter looks like this: In this pipeline: —concatenates all files in the current folder that ends with txt and returns it in a standard output cat *txt —returns only lines that have in them grep 1 1 Reverse search Often, it’s easier to describe what you don’t want to have rather than what you want. With , you can easily use it to filter out some lines by adding the option to it. For example: grep -v Note! You can combine many commands with the pipe operator: cat *txt | grep -v 1 | grep file-
Content of file-2.txt Searching through files Grep allows you to search in files as well—you just need to add (from recursive search in subdirectories): -r In the output, you can see: —path to the file ./file —the matching line Lorem ipsum File names only If you are interested only in files have your matching values, then you can add the option to your command: which -l This option becomes especially useful when you combine it with the next command/ Calling commands based on the output of other commands takes lines from standard input and adds them as parameters for another command. One of the common uses is to find all files that contain some value and run a command on them—for example, delete them: xargs grep -rl Lorem | xargs rm There is no output of the command, but let’s see what files are available before and after running the command: ls
long-file.txt For now, the files are gone, but later in this article we will see a tool that helps us track and restore files. As you can see in the second run of (recursive listing of a directory and each subdirectory): ls -R is gone from the top directory, and file is gone from the nested folder. another-file.txt Scripting files edits is a stream editor. It allows for modifications to the values in the pipe: sed echo 'hello world' | sed 's/world/you/'
hello you In our example, the parameter denote the following: s/world/you/ —means substitute s —regex to match the value to be substituted world —new value to be used instead you Editing files on disk A more practical use case for is to edit files. When can combine it with and , you can start developing pretty neat one-liners that will help you apply big updates to your codebase: sed grep xargs # at Linux
grep -lr file | xargs sed -i -e 's/file/File/g'

# at macOS
grep -lr file | xargs sed -i '' -e 's/file/File/g' In our command: —returns the list of all files that contains . grep -lr file file —turns them into input parameters for . xargs sed or —switches the editor to work directly on the files. sed -i -e sed -i '' -e —substitutes lowercase letter “file” with uppercase “File”. at the end means that the change is meant to be global. It should update every instance that is found in the file—not only the first instance in each line. s/file/File/g /g Track files changes Git is a version control system that is ubiquitous in our industry. If you intend to become a developer, you will need to learn it eventually. I’ve already written , but here we will focus on Git commands that integrate nicely with other CLI tools we have covered here. a lot about Git git grep This is a command inspired by . It lets you search through the files tracked by the repository. When you track your files with Git, you can use instead of . The main advantage is that it automatically ignores files that you set Git to ignore—which is often the case with . grep git grep grep -r node_modules Similar to the original , you can use option to get only the file names: grep -l $ git grep -l File
file-a
file-b
file-c git ls-files A command to list all files tracked by the repository. You can combine it with to find all the files that match some pattern, and then use to do some operation on all of them. grep xargs Text editor is a text editor that is a bit of a nerdy cliché, and my editor of choice. I switched to it after I got tired with an old computer that struggled to run Eclipse and other big integrated development environments (IDEs). vim Vim is fast, flexible, and offers great keyboard shortcuts. Even more: keyboard shortcuts are the only way to use it because it doesn’t support a mouse. The learning curve is a bit steep—at first it can be challenging to even close it. Long term, learning Vim can be a good investment. What makes it especially worthwhile is that the editor commands in Vim are very close to the commands that are used by and search patterns in . What you learn in one of those tools, you can immediately apply in the other tools as well. sed greps Clipboard Utilities Sometimes you would like to get the output of a command line program and just paste it in one of the applications in your graphical interface. All operating systems bring some utility that allows you to do exactly that: —utility that is available on macOS pbcopy —utility that you could install on Ubuntu xclip cat file-1.txt | pbcopy And now I can paste the file’s contents in the browser. Managing terminal sessions is a terminal multiplexer—a program that allows you to run multiple sessions inside one terminal emulator window. It allows you to keep different ‘windows’ for different uses. For example, I usually have: tmux one session for running Git commands, another with vim, where I edit code, and at least one session to run the development server Want to learn more? The command line is a great tool set that is often challenging at the beginning. On this blog, I sometimes try to explore such topics in a beginner-friendly way—to help new developers learn those tools so that they can become more efficient with their work. If you are interested in getting updates about my new CLI-related content, . sign up here Also Published Here

Basic Commands That Will Help You Get Started With Terminal

I get asked on every single video how I have autocomplete on my terminal, and the answer is... ! drum rolls... fig.io Actually, it's much more than a simple autocomplete, even if to be honest it's what I use 90% of the time. If you want to see a showcase of some of the major features, as usual, I recorded a video and you can find it on YouTube! https://youtu.be/HNVB9Dro2S4?embedable=true Still here? If you don’t want to watch the video, feel free to read the article instead! Autocomplete Let’s give a closer look at autocomplete. What you could expect from an autocomplete is to suggest you the next command while typing it. Or for example, getting the list of all the files in the current directory. Fig does much much more! When you start typing a command (for example ) you will see fig suggesting all the possible flags and options you can use, for example or . git checkout --force -b Enough? Not yet! You can also see on the recommendations all the available branches you can pass as arguments to the command! I mean, it's cool on an image, but you should really have a look at the video to see it in action! You will be surprised to notice that as soon as you start typing , you will see in the autocomplete some weird commands, like or . git cma lgo What are those? Well, they are the aliases I defined in my dotfiles, and fig is able to read them and suggest them to me! Artificial Intelligence The coolest feature right after autocomplete is… well, the name is self-explanatory… artificial intelligence. We’re in 2023, AI is everywhere, including our terminals. With fig, you can start typing to get some help. fig ai To begin with, let's start with a simple to get help. fig ai -h English -> Bash translation

Usage: fig ai [INPUT]...

Arguments:
  [INPUT]...

Options:
  -h, --help  Print help It's all there on the first line, it translates English to Bash. Just write in plain english what you want to do and fig will translate it to a bash command for you! Then you can either use it, edit it or ask the ai to generate a new command. Again, I think it doesn't give it justice just written as a blog post, you should really really watch the video or even better try it yourself. Custom scripts In a concept similar to alias, you can define some custom scripts and give them a name. When you type in your terminal, you will get a list of all the scripts you defined. fig run There's also a script store where you can find some scripts other people created and use them directly in your terminal. Plugins Similar to the scripts and the script store, you can find plugins aaaand a plugin store. With plugins, you can even further enhance your terminal experience. Dotfiles Fig helps you manage aliases, variables, paths, and more, all in one place. As you can see in the video I'm not really using this feature, but I think I should. It's one of those nice to have that you can easily live without, but once you discover them you start thinking why you haven't started using them earlier. Open Source Did I already mention that autocomplete is Open Source? You can contribute on GitHub. Plugins are open source too and you can add yours directly on the repo! Actually, feel free to go on the page and have a look at all the repos, there's a lot to discover. withfig Closing And that’s it! It wasn’t a paid sponsorship but I genuinely enjoy using fig’s autocomplete every day and since you asked many times I thought it was cool to make an entire piece of content about it. Do you also use fig and its other features? Let me know in the comments! Thanks for reading this article, I hope you found it interesting! Do you like my content? You might consider subscribing to my YouTube channel! It means a lot to me ❤️ You can find it here: @DevLeonardo

How to Enable Autocomplete (and AI) in your Terminal

Cómo habilitar Autocompletar (y AI) en su Terminal

Comment activer la saisie semi-automatique (et l'IA) dans votre terminal

अपने टर्मिनल में स्वतः पूर्ण (और AI) को कैसे सक्षम करें

ターミナルでオートコンプリート (および AI) を有効にする方法

Como ativar o preenchimento automático (e AI) no seu terminal

Cách bật Tự động điền (và AI) trong Terminal của bạn

如何在终端中启用自动完成（和 AI）

For decades, Windows users have been made fun of by the Linux community for the lack of a cool terminal (among other things). Well, it's about time we fight! In this article, we will go through setting up a development workflow in the Windows terminal. Prerequisites Know how to type Windows 10/11 (Some things may not work for you in this article if you are on some other version) (Optional) Know Basic Unix Commands such as , , etc cd mkdir What will we be doing We will set up the following: Powershell Nerd Fonts Theme Scoop z Directory Jumper Terminal Icons Node & Git Neovim Oh-My-Posh Autocomplete Aliases Utilities Well, then, let's get started! Things to remember during the article stands for your root or home directory, the default directory where the terminal will generally open. ~ If anything doesn't work even after installing/configuring just close and reopen the terminal. The command palette opens with . ctrl+shift+p Terminal settings open with ctrl+, Getting Started Powershell First of all, let's install Powershell, this is not Windows Powershell that comes with Windows. You will have to go to the Microsoft Store and search for it, it's free so don't worry. After you have done that open Terminal (not PowerShell or Command Prompt), you can search it up, it's pre-installed on your PC. Press to open settings, here we will set Powershell as our default, it would be Command Prompt in default if you haven’t changed it before. Ctrl+, In the startup menu, change the default profile to PowerShell and save, that's it! Nerd Fonts So, what are Nerd Fonts? Nerd fonts let you use font ligatures and more glyphs in general, it's something everyone should use while coding. You might actually be using it without knowing in your IDE/text editor. I used Fira Code for a long time before knowing it was a Nerd Font. To install a nerd font, first, go to the nerd-fonts and download the zip file of your preferred Nerd Font from the latest release. Extract the zip file and install the fonts. If you have never installed a font before, that’s fine, you can just double-click the files and click on install. GitHub Repo .ttf I use the JetBrains Mono NF and another of my favorites is Hack NF (NF stands for Nerd Fonts). Themes To change the theme of your terminal, open settings and click on "Open JSON file", this will open the file for your terminal. settings.json Now to change the theme you have three options: Choose a theme from the themes already present in the terminal by default Create your own theme from scratch or modify one already present. Use a pre-written theme I use a pre-written theme, you can find a lot of them and paste it into your settings.json under “schemes”. Save the file. here Now, go back to your Terminal settings (not settings.json) and choose the theme you just added. Terminal Tools Scoop Let's first install , a package manager for Windows. We will be then using scoop to install other tools. scoop To install scoop run the following in PowerShell: winget install scoop This will install scoop. If you are wondering what winget is, it is a package manager that comes by default in Windows 10/11. In case, you don't have winget do the following: iwr -useb get.scoop.sh | iex Now type and if it returns an output like the one below then all is good. scoop Usage: scoop <command> [<args>]

Some useful commands are:

alias       Manage scoop aliases
bucket      Manage Scoop buckets
cache       Show or clear the download cache
cat         Show content of specified manifest. If available, `bat` will be used to
            pretty-print the JSON.
checkup     Check for potential problems
cleanup     Cleanup apps by removing old versions
config      Get or set configuration values
create      Create a custom app manifest
depends     List dependencies for an app
download    Download apps in the cache folder and verify hashes
export      Exports (an importable) list of installed apps
help        Show help for a command
hold        Hold an app to disable updates
home        Opens the app homepage
info        Display information about an app
install     Install apps
list        List installed apps
prefix      Returns the path to the specified app
reset       Reset an app to resolve conflicts
search      Search available apps
shim        Manipulate Scoop shims
status      Show status and check for new app versions
unhold      Unhold an app to enable updates
uninstall   Uninstall an app
update      Update apps, or Scoop itself
virustotal  Look for app's hash on virustotal.com
which       Locate a shim/executable (similar to 'which' on Linux)

Type 'scoop help <command>' to get help for a specific command. If it doesn't return an output, just close and reopen the terminal, and it will work. This is the moment you stop using those installers, now you are a terminal guy. You can even install Mozilla Firefox, just do . scoop install firefox There is also which you can use as a package manager but we will stick with scoop for this article. choco/chocolatey z is a directory jumper. What is a directory jumper? Let's say you are in the directory , and you want to go to , the one way of doing this in your terminal would be this: z ~/Desktop/Development/NextJS/tutorial ~/SomewhereElse/Products/Product1/prod-website cd ../../../../

cd SomewhereElse/Products/Product1/prod-website This looks small but you don't always remember where all your projects are so add 4-5 more commands in there. This wastes our time, especially over a prolonged period. This is where a directory jumper comes in, with just a single command you can go from one project to another. Let's take the above example this time you just have to do this (assume you are in ): ~/Desktop/Development/NextJS/tutorial z prod-website That's it! You just should have visited the directory once in your lifetime (which you most probably will during the project setup). You don't even need to use the full name of your project directory, you can just do and you would jump to the most recent directory which has in its name somewhere (in this case, the prod-website). z prod prod One thing to note is, to try not to include spaces in your directory names that may make it hard for the directory jumper to find them. It's a good practice in general too to not include spaces in directory names. Now to install , just type in the following and hit enter, and there you go: z Install-Module -Name z -Force Huh? This is not scoop, is it? Yes, it is not, we are currently installing a PowerShell Module (you can install some modules using scoop or winget too) and thus, we are using the command that is builtin into PowerShell. Install-Module Try it out, if it doesn't work open a new Terminal tab (shortcut: ctrl+shift+t), and it should work now. Terminal Icons As the name suggests it adds icons for when you do . To install it do the following: ls Install-Module -Name Terminal-Icons This will install the module. To be able to use it globally, we need to add it to our PowerShell profile, which we will cover in this article later. Node & Git If you use Node.js install it but if you don’t there is no need to. To install Node, first, install which stands for Node Version Manager, it also lets you have multiple versions of node installed at the same time. nvm scoop install nvm This will install nvm. Now download the stable release of Node.js with: nvm install lts for the latest release do: nvm install latest you can even specify a certain version like this: nvm install 18.1.0 To list out the versions of node available use , the one with a denotes the one being used currently. To change the version do . nvm list * nvm use version_number Quick Tip: You can also install by doing , by using that you don’t have to close and reopen the terminal for admin commands. You can use it like, . sudo scoop install sudo sudo nvm use 18.1.0 Now for git just do either of the following: using scoop: scoop install git or using winget winget install git That's it! Neovim Neovim is a fork of Vim that is better for plugins and extensions. To install Neovim, type in the following and hit the enter key: scoop install neovim Also, install any other packages it asks you to. I don't recommend jumping into Neovim right ahead if you haven't seen it ever before in your life or don't know the common commands/keybindings. You can check out this of mine for learning a bit about it and how to set it up. article I will be using Neovim here for editing files, but it's alright you can just follow along with the steps in your preferred text editor or IDE too. Oh-My-Posh Now that all your terminal tools are all set up, let's start with customizing your prompt. First of all, to install it you can do either of the following: winget install oh-my-posh or scoop install https://github.com/JanDeDobbeleer/oh-my-posh/releases/latest/download/oh-my-posh.json Now, we will start messing with config files! First, let's create a config file for our PowerShell, we will be using this file to customize our prompt as well as to set aliases and utilities. The config file will be in the PowerShell script. You can create it anywhere but you will have to link it accordingly in your PowerShell profile. PowerShell profile is from where PowerShell will load its config, you can write your config there directly but we will write it in a separate file. Let's make ours in . ~/.config/powershell cd .config

mkdir powershell && cd powershell Again, you can name your file anything just make sure it will be the same in your PowerShell profile. Let's get started with the editing then, create a file in your preferred editor, I will be using Neovim here. user_profile.ps1 nvim user_profile.ps1 Now type in the following into your PowerShell config: oh-my-posh init pwsh --config ~/.config/powershell/avi.omp.json | Invoke-Expression Save it now. Here you can see "avi.omp.json" and you can name it anything like "your_name.omp.json" just make sure to replace it in the config. Now, you may ask me though, what even is that file? That file is the one that will contain our oh-my-posh configuration for the prompt. You can create your own custom prompt from scratch by looking at the , but there are a lot of awesome ones already there. I use one of them and just modified it a bit. You can check it out on their website and copy the config. Here's the one I am using: docs {
  "$schema": "https://raw.githubusercontent.com/JanDeDobbeleer/oh-my-posh/main/themes
/schema.json",
  "blocks": [
    {
      "alignment": "left",
      "segments": [
        {
          "foreground": "#41A6B5",
          "style": "plain",
          "template": "@avi",
          "type": "session"
        },
        {
          "foreground": "#7AA2F7",
          "properties": {
            "folder_separator_icon": "/",
            "style": "full"
          },
          "style": "plain",
          "template": " \uf07b {{ .Path }} ",
          "type": "path"
        },
        {
          "foreground": "#BB9AF7",
          "powerline_symbol": "\ue0b0",
          "properties": {
            "fetch_stash_count": true,
            "fetch_upstream_icon": true
          },
          "style": "plain",
          "template": "{{ .UpstreamIcon }}{{ .HEAD }}{{ if gt .StashCount 0 }} \uf692
{{ .StashCount }}{{ end }} ",
          "type": "git"
        }
      ],
      "type": "prompt"
    },
    {
      "alignment": "left",
      "newline": true,
      "segments": [
        {
          "foreground": "#cd5e42",
          "style": "plain",
          "template": "\ue3bf ",
          "type": "root"
        },
        {
          "foreground": "#CD4277",
          "style": "plain",
          "template": "> ",
          "type": "text"
        }
      ],
      "type": "prompt"
    }
  ],
  "version": 2
} Next, open your powershell profile (you can do it by , do it from the home directory if you are not on Neovim, the file is located at ~/My Documents/powershell/Microsoft.PowerShell_profile.ps1), and type in the following: nvim $profile . $env:USERPROFILE\.config\powershell\user_profile.ps1 Save that. Close and reopen the terminal. Your prompt should load now. Awesome! Now, let's add autocomplete. Autocomplete PSReadline is a module of PowerShell that comes pre-installed which will help us out with the autocomplete. To configure it open your and add the following: user_profile.ps1 Set-PSReadLineOption -PredictionSource History

Set-PSReadLineOption -PredictionViewStyle ListView You can choose "HistoryAndPlugin" or "Plugin" too as PredictionSource. For PredictionViewStyle, the other option is InlineView, you can also switch between them by pressing the F2 key. I talked about adding Terminal Icons to the config before, you can do it by just adding the following line into your config: Import-Module Terminal-Icons Aliases Aliases can be useful in saving time. It's quite simple to set aliases, for example: Set-Alias g git The above will set the alias for as , but that will only make it the alias for this particular terminal session/tab not globally. To make it a global alias add the exact same command as above in your PowerShell config file. Now, g is the alias for git. Similarly, you can set other aliases. Here are a few of mine: git g Set-Alias v nvim
Set-Alias g git
Set-Alias y yarn
Set-Alias p pnpm
Set-Alias tig 'C:\Program Files\Git\usr\bin\tig.exe'
Set-Alias explorer explorer.exe These are PowerShell aliases, you can also set up aliases for git to speed up your development process, I won't go into the detail of it here. There is another way to set aliases for commands like , . Here is an example of making an alias for : npm start yarn dev yd yarn dev function yarnDev {
  yarn dev
}

New-Alias yd yarnDev I don’t have experience with PowerShell script, so in the above, I can only explain that we create a function and add whatever we want to run when we call the function. After that, we set the alias to call the function as . yarnDev yd Similarly, you can set up other aliases for such commands. Utilities You can even make your own little commands by setting them in your PowerShell config. For example, command (used to create a file) which is not present in PowerShell, here is how you can add it: touch function touch ($command) {
    New-Item -Path $command -ItemType File | out-null && Write-Host Created $command
} What we are doing above is creating a function and letting it have a parameter. Then, in , we are using built-in PowerShell commands to create a file, you will have to research PowerShell commands to create more utilities on your own, the documentation is amazing, so it won’t be a problem. In the second half of the function, we are just telling it to output . touch New-Item -Path $command -ItemType File Created [file_name] Here is how you can add command from Linux: rm function rm ($command) {
    Remove-Item $command -Recurse && Write-Host Removed $command
} To use this just do and it will delete the file. rm [file_name/directory_name] It is not exactly the same as the command in Linux though. rm Other tools Here are some of the other CLI tools you can use: - Commitizen is used for defining a standard way of committing rules and communicating them in Git. It is designed for teams, but I also use it for my personal projects. Commitizen - gh is GitHub on the command line. It brings pull requests, issues, and other GitHub concepts to the terminal next to where you are already working with git and your code. gh CLI - An extension of gh cli to display a dashboard with pull requests and issues. gh-dash extension - You can use this to get prettier git diffs. dunk - Rich-cli is a command-line toolbox for fancy output in the terminal. Rich CLI WSL Setup Now, you might have already heard of WSL or might even be using it, nothing wrong with it if you are not. WSL stands for Windows Subsystem For Linux, it lets you have the Linux terminal on your windows machine. I will not be discussing WSL setup here but you can check out by @stephanlamoureux, it goes through setting up WSL quite nicely. "The Complete Windows Developer Setup Guide" Conclusion So, that's finished! You can find my config files on GitHub if you want, before copying anything go through the readme once, also do not copy anything you don’t know the meaning of. here If anyone wants to add something, correct me somewhere, or ask anything please feel free to do so in the comments. Resources for themes - or https://windowsterminalthemes.dev/ https://github.com/atomcorp/themes docs for PSReadline - https://docs.microsoft.com/en-us/powershell/module/psreadline/?view=powershell-7.2 video by devsalife on setting up powershell - https://www.youtube.com/watch?v=5-aK2_WwrmM Documentation for all other tools has been linked with their introductions in the article Also published . here

Setting up a Development Workflow in the Windows Terminal

The Terminal window, from back in the days when the computers were operated only by the command line or in the present when developing even the smallest project, we all use it. If this does not ring a bell yet, here is a about terminals aka. command-line interfaces: definition from Wikipedia A ( ) processes commands to a computer program in the form of lines of text. The program which handles the interface is called a or . command-line interface CLI command-line interpreter command-line processor These terminal interfaces are used by a lot of websites like Haskell, Hyper, even Codesandbox has a terminal (console). Let’s make one with for our website. ReactJs What we will build We will build a terminal emulator that accepts a set of predefined commands that we give it. You can or . view the code on GitHub see it in action here To build this terminal, we are using (CRA) to generate a new React application through our computer terminal. You can even see a terminal window animation on the CRA website in the section “Get started in seconds“. create-react-app First things first First things first, let’s create our React project using the (CRA) CLI. We will create an application with the template, to make our code better and avoid possible mistakes like adding two strings when we don’t want to. create-react-app Typescript I will name the application so, on my computer console, I will run the following code: terminal npx create-react-app terminal --template typescript After that, I will open the newly created folder in my code editor of choice, . terminal WebStorm Let’s clean up the files a little bit. Let’s delete the files , and from the folder. From the file , let’s remove everything that is within the with the className and also delete line number 2 and 3, with the logo import. Like so: logo.svg App.css App.test.tsx src/ App.tsx div App import React from 'react';

function App() {
  return (
    <div className="App">
      We will fill this section later
    </div>
  );
}

export default App; Creating the style and basic structure In the folder, let’s create another folder with the name , and inside that, create a file called one called . This will be our basic structure. src/ Terminal/ index.tsx terminal.css The terminal window is composed of two elements, the output, and the input. The output is where we will write the response, and the input is where we will write our commands. So, based on that, let’s create our terminal and add some style to it. In the , we will have the following code: index.tsx import './terminal.css';

export const Terminal = () => {
  return (
    <div className="terminal">
      <div className="terminal__line">A terminal line</div>
      <div className="terminal__prompt">
        <div className="terminal__prompt__label">alexandru.tasica:</div>
        <div className="terminal__prompt__input">
          <input type="text" />
        </div>
      </div>
    </div>
  );
}; Our style will be the following: terminal.css .terminal {
    height: 500px;
    overflow-y: auto;
    background-color: #3C3C3C;
    color: #C4C4C4;
    padding: 35px 45px;
    font-size: 14px;
    line-height: 1.42;
    font-family: 'IBM Plex Mono', Consolas, Menlo, Monaco, 'Courier New', Courier,
    monospace;
    text-shadow: 0 4px 4px rgba(0, 0, 0, 0.25);
}

.terminal__line {
    line-height: 2;
    white-space: pre-wrap;
}

.terminal__prompt {
    display: flex;
    align-items: center;
}

.terminal__prompt__label {
    flex: 0 0 auto;
    color: #F9EF00;
}

.terminal__prompt__input {
    flex: 1;
    margin-left: 1rem;
    display: flex;
    align-items: center;
    color: white;
}

.terminal__prompt__input input {
    flex: 1;
    width: 100%;
    background-color: transparent;
    color: white;
    border: 0;
    outline: none;
    font-size: 14px;
    line-height: 1.42;
    font-family: 'IBM Plex Mono', Consolas, Menlo, Monaco, 'Courier New', Courier,
    monospace;
} And also, let’s import that in our to view it in our browser: App.tsx import React from 'react';
import {Terminal} from "./Terminal";

function App() {
  return (
    <div className="App">
      <Terminal />
    </div>
  );
}

export default App; And the result is, 🥁 drums please: Good, so you’ve got where we are heading to. Basic state management Awesome! So we have the basic structure. Now we need to make users interact with it, keep our messages history and add new messages to the terminal. For that, we will write a custom hook called that will go hand-in-hand with our terminal. Let’s see the basic hook structure that we are going for: useTerminal import {useCallback, useEffect, useState} from 'react';
import {TerminalHistory, TerminalHistoryItem, TerminalPushToHistoryWithDelayProps} from "./types";


export const useTerminal = () => {
  const [terminalRef, setDomNode] = useState<HTMLDivElement>();
  const setTerminalRef = useCallback((node: HTMLDivElement) => setDomNode(node), []);

  const [history, setHistory] = useState<TerminalHistory>([]);

  /**
   * Scroll to the bottom of the terminal when window is resized
   */
  useEffect(() => {
    const windowResizeEvent = () => {
      terminalRef?.scrollTo({
        top: terminalRef?.scrollHeight ?? 99999,
        behavior: 'smooth',
      });
    };
    window.addEventListener('resize', windowResizeEvent);

    return () => {
      window.removeEventListener('resize', windowResizeEvent);
    };
  }, [terminalRef]);

  /**
   * Scroll to the bottom of the terminal on every new history item
   */
  useEffect(() => {
    terminalRef?.scrollTo({
      top: terminalRef?.scrollHeight ?? 99999,
      behavior: 'smooth',
    });
  }, [history, terminalRef]);

  const pushToHistory = useCallback((item: TerminalHistoryItem) => {
    setHistory((old) => [...old, item]);
  }, []);

  /**
   * Write text to terminal
   * @param content The text to be printed in the terminal
   * @param delay The delay in ms before the text is printed
   * @param executeBefore The function to be executed before the text is printed
   * @param executeAfter The function to be executed after the text is printed
   */
  const pushToHistoryWithDelay = useCallback(
    ({
       delay = 0,
       content,
     }: TerminalPushToHistoryWithDelayProps) =>
      new Promise((resolve) => {
        setTimeout(() => {
          pushToHistory(content);
          return resolve(content);
        }, delay);
      }),
    [pushToHistory]
  );

  /**
   * Reset the terminal window
   */
  const resetTerminal = useCallback(() => {
    setHistory([]);
  }, []);

  return {
    history,
    pushToHistory,
    pushToHistoryWithDelay,

    terminalRef,
    setTerminalRef,

    resetTerminal,
  };
}; And let’s also create a separate file that contains the type of the props and all the things we want to strongly type, like . Let’s create a file called with the definitions we have right now. Terminal History types.ts import {ReactNode} from "react";

export type TerminalHistoryItem = ReactNode | string;
export type TerminalHistory = TerminalHistoryItem[];
export type TerminalPushToHistoryWithDelayProps = {
  content: TerminalHistoryItem;
  delay?: number;
}; Now, after we have the types defined, let’s see a quick description of what does every function in our hook: The first state, will keep our reference to the terminal container. We will reference it later in our file. The first function is a helper function that sets the reference for that . terminalRef terminal/index.tsx div The first two will scroll done the terminal every time there is a new entry in our terminal history or every time the window is resized useEffects will push a new message to our terminal history pushToHistory will push the new message to our terminal history with a specific delay. We return a promise instead of resolving it as a function, so we can chain multiple pushes as an animation. pushToHistoryWithDelay Last, we have the which resets the terminal history. Works more like a function from the classic terminal. resetTerminal clear Awesome! Now that we have a way to store and push the messages, let’s go integrate this hook with structure. In the In the file, we will have some props that will be connected with the terminal history and also will handle the focus on our terminal input prompt. Terminal/index.tsx import './terminal.css';
import {ForwardedRef, forwardRef, useCallback, useEffect, useRef} from "react";
import {TerminalHistory, TerminalHistoryItem} from "./types";

export type TerminalProps = {
  history: TerminalHistory;
  promptLabel?: TerminalHistoryItem;
};

export const Terminal = forwardRef(
  (props: TerminalProps, ref: ForwardedRef<HTMLDivElement>) => {
    const {
      history = [],
      promptLabel = '>',
    } = props;

    /**
     * Focus on the input whenever we render the terminal or click in the terminal
     */
    const inputRef = useRef<HTMLInputElement>();
    useEffect(() => {
      inputRef.current?.focus();
    });

    const focusInput = useCallback(() => {
      inputRef.current?.focus();
    }, []);

    return (
    <div className="terminal" ref={ref} onClick={focusInput}>
      {history.map((line, index) => (
        <div className="terminal__line" key={`terminal-line-${index}-${line}`}>
          {line}
        </div>
      ))}
      <div className="terminal__prompt">
        <div className="terminal__prompt__label">{promptLabel}</div>
        <div className="terminal__prompt__input">
          <input
            type="text"
            // @ts-ignore
            ref={inputRef}
          />
        </div>
      </div>
    </div>
  );
}); And not, let’s connect the dots and push something to the terminal. Because we accept any as a line, we can push any HTML we want. ReactNode Our will be the wrapper, this is where all the action will happen. Here we will set the messages we want to show. Here is a working example: App.tsx import React, {useEffect} from 'react';
import {Terminal} from "./Terminal";
import {useTerminal} from "./Terminal/hooks";

function App() {
  const {
    history,
    pushToHistory,
    setTerminalRef,
    resetTerminal,
  } = useTerminal();


  useEffect(() => {
    resetTerminal();

    pushToHistory(<>
        <div><strong>Welcome!</strong> to the terminal.</div>
        <div style={{fontSize: 20}}>It contains <span style={{color: 'yellow'}}><strong>HTML</strong></span>. Awesome, right?</div>
      </>
    );
  }, []);

  return (
    <div className="App">
      <Terminal
        history={history}
        ref={setTerminalRef}
        promptLabel={<>Write something awesome:</>}
      />
    </div>
  );
}

export default App; And, the result so far is: On mount, we just push whatever we want, like that cool big yellow HTML text. Implementing commands Awesome! You made it almost to the end. Now let’s add the ability for the user to interact with our terminal, in writing. In our will add the option to update the input, and also the commands that every word will execute. These are the most important things in a terminal, right? Terminal/index.tsx Let’s handle the user input in the file, and listen there when the user presses the key. After that, we execute the function that he wants. Terminal/index.tsx Enter The the file will transform into: Terminal/index.tsx import './terminal.css';
import {ForwardedRef, forwardRef, useCallback, useEffect, useRef, useState} from "react";
import {TerminalProps} from "./types";

export const Terminal = forwardRef(
  (props: TerminalProps, ref: ForwardedRef<HTMLDivElement>) => {
    const {
      history = [],
      promptLabel = '>',

      commands = {},
    } = props;

    const inputRef = useRef<HTMLInputElement>();
    const [input, setInputValue] = useState<string>('');

    /**
     * Focus on the input whenever we render the terminal or click in the terminal
     */
    useEffect(() => {
      inputRef.current?.focus();
    });

    const focusInput = useCallback(() => {
      inputRef.current?.focus();
    }, []);


    /**
     * When user types something, we update the input value
     */
    const handleInputChange = useCallback(
      (e: React.ChangeEvent<HTMLInputElement>) => {
        setInputValue(e.target.value);
      },
      []
    );

    /**
     * When user presses enter, we execute the command
     */
    const handleInputKeyDown = useCallback(
      (e: React.KeyboardEvent<HTMLInputElement>) => {
        if (e.key === 'Enter') {
          const commandToExecute = commands?.[input.toLowerCase()];
          if (commandToExecute) {
            commandToExecute?.();
          }
          setInputValue('');
        }
      },
      [commands, input]
    );

    return (
    <div className="terminal" ref={ref} onClick={focusInput}>
      {history.map((line, index) => (
        <div className="terminal__line" key={`terminal-line-${index}-${line}`}>
          {line}
        </div>
      ))}
      <div className="terminal__prompt">
        <div className="terminal__prompt__label">{promptLabel}</div>
        <div className="terminal__prompt__input">
          <input
            type="text"
            value={input}
            onKeyDown={handleInputKeyDown}
            onChange={handleInputChange}
            // @ts-ignore
            ref={inputRef}
          />
        </div>
      </div>
    </div>
  );
}); As you can see, we have moved the type defined here, into the separate file we created called . Let’s explore that file and see what new stuff we defined. types.ts import {ReactNode} from "react";

export type TerminalHistoryItem = ReactNode | string;
export type TerminalHistory = TerminalHistoryItem[];
export type TerminalPushToHistoryWithDelayProps = {
  content: TerminalHistoryItem;
  delay?: number;
};


export type TerminalCommands = {
  [command: string]: () => void;
};

export type TerminalProps = {
  history: TerminalHistory;
  promptLabel?: TerminalHistoryItem;
  commands: TerminalCommands;
}; Good, now that we can execute commands from the terminal, let’s define some in the . We will create only two simple ones, but you let your imagination run wild! App.tsx import React, {useEffect, useMemo} from 'react';
import {Terminal} from "./Terminal";
import {useTerminal} from "./Terminal/hooks";

function App() {
  const {
    history,
    pushToHistory,
    setTerminalRef,
    resetTerminal,
  } = useTerminal();


  useEffect(() => {
    resetTerminal();

    pushToHistory(<>
        <div><strong>Welcome!</strong> to the terminal.</div>
        <div style={{fontSize: 20}}>It contains <span style={{color: 'yellow'}}><strong>HTML</strong></span>. Awesome, right?</div>
        <br/>
        <div>You can write: start or alert , to execute some commands.</div>
      </>
    );
  }, []);

  const commands = useMemo(() => ({
    'start': async () => {
      await pushToHistory(<>
          <div>
            <strong>Starting</strong> the server... <span style={{color: 'green'}}>Done</span>
          </div>
        </>);
    },
    'alert': async () => {
      alert('Hello!');
      await pushToHistory(<>
          <div>
            <strong>Alert</strong>
            <span style={{color: 'orange', marginLeft: 10}}>
              <strong>Shown in the browser</strong>
            </span>
          </div>
        </>);
    },
  }), [pushToHistory]);

  return (
    <div className="App">
      <Terminal
        history={history}
        ref={setTerminalRef}
        promptLabel={<>Write something awesome:</>}
        commands={commands}
      />
    </div>
  );
}

export default App; The constant defines the command that should be typed by the user. So if the user types and hits enter, he will see the text “ the server… Done“. commands start Starting What we’ve built Thanks for reaching the end, you are awesome! Here is what we’ve built together, hopefully, it will be helpful for your website or a client’s website. What’s next? What’s next you ask? The terminal right now is pretty simple. You don’t see the previously typed commands. If the user types an incorrect command, he will see nothing. And, of course, animations! See you in part two for these new features. Until then, you can or . view the code on GitHub see it in action here

Creating a Terminal Emulator in React

Introducing Warp Today, I’m proud to officially introduce Warp, a from-first-principles reinvention of the terminal to make it work better for developers and teams. As of today, Warp is in public beta and any Mac user can download and use it for free. We are also excited to announce that we’ve raised some funds to grow Warp ($23M), both from wonderful firms ( , , ) and world-class operators like Dylan Field (who led our Series A), Elad Gil, Jeff Weiner, and Marc Benioff. GV Neo BoxGroup Why Reinvent the Terminal? Walk by any developer’s desk and you are likely to see two apps open: their code editor and their terminal (sometimes the code editor is the terminal!). Both are crucial to developer productivity.  The code editor is where developers write code; the terminal is where they do pretty much everything else, from building code to running and deploying it, interacting with source control, configuring their cloud systems, and more. And yet only one of these two apps – the code editor – has experienced meaningful product improvement over the past 40 years. Compared to using VS Code, using the terminal is like stepping back in time to the 1970s. Only , while 100% use the terminal. So why is the terminal experience still so lackluster? 70% of developers use VSCode Our Product Vision At Warp, our product vision is to bring the terminal into the present in order to help developers build the future. ‍We are doing this by fixing the two biggest pain points that exist in today’s terminals: Terminals are hard to use They don’t work for teams These are pain points that I’ve personally experienced again and again in my twenty years as an engineer, and I’m sure readers feel the same. ‍To get good at using a terminal before Warp, users had to do all sorts of complex configuration, master arcane key shortcuts, and memorize abstruse commands. Even then, seemingly simple things like copying a command’s output or positioning the mouse cursor were still difficult. ‍Warp makes input and output easy, and removes the need for most configuration. Input works like a modern text-editor, and output works like a data notebook. Moreover, Warp makes command-entry fast and fun by suggesting commands for commonly used tools and providing built-in workflows that save developers time. ‍In short, Warp makes the terminal work for the developer, rather than the other way around. Secondly, up until Warp, terminals have been inherently single-user, local applications.  But as I learned when I was leading engineering on Google Docs – and as Dylan showed with Figma – every productivity application is more powerful when it’s collaborative.  This is true 100% of the time – from Figma to GDocs to Notion to Front – and I’m confident that the terminal is no exception. Terminal “collaboration” means not just GDocs-style real-time collaboration, but asynchronous collaboration through sharing commands, settings, and history. It means increased knowledge-sharing through wikis and READMEs that run directly in the terminal. It means making the terminal safer and more secure via integrated password-management and audit logging. It means making the terminal a more extensible and customizable platform, with a nice modern ecosystem. Finally, all of this needs to be built with speed and compatibility in mind – Warp is made in Rust with GPU-accelerated graphics, and works with existing shells like zsh, fish and bash. Go Try Warp! Nine months ago we launched Warp in private beta behind a waitlist.  Since then, thousands of developers have made Warp their daily driver, given us feedback, and allowed us to greatly improve the product. Today, we are removing our waitlist and launching our public beta.  We are calling it a “beta” because we know there are still some issues to smooth out, but we are confident that even today the experience is meaningfully better than in other terminals. If you use a Mac, please give it a shot and let us know how it goes. Otherwise, sign up to be notified when Warp is ready for your platform. here Welcome to the future of the terminal. Also Published here

Warp: The Terminal For the Modern Developers

Linux is one of the best-known and most used operating systems in the world. Major Linux distributions are Linux Mint, Debian, Ubuntu, Archlinux, Fedora, Opensuse, centos, and FreeBSD. Many Linux distributions provide graphical user interfaces but you should also know how to work with the Linux terminal and for that you should know basic commands of Linux OS. Here are 6 essential commands which can make you better at using Linux systems. 1. alias This command allows you to define temporary aliases in your shell session. It’s like variables in programming but instead of storing a value/string in the variable, you will store the command in a variable. syntax : alias [option] [name]='[value]' usage : alias c=’clear’ output : Reverse alias with command unalias usage : unalias c output : 2. kill The kill command sends a signal to particular processes or a process group, causing them to act according to that signal. Default signal when none specified : -15 ( -TERM ) The most common signal used in kill are: 1 ( HUP ) - Reload a process 9 ( KILL ) - kill a process 15 ( TERM ) - stop a process To get a list of all available signals, we have to invoke -l option kill – l output : usage : Find process id of a particular process commands : top, pidof, ps, pgrep ex : pidof atom output : 10607 10531 10512 10499 10474 10472 10471 10468

next command :

kill -9 10607 10531 10512 10499 10474 10472 10471 10468

or 

kill -9 $(pidof atom) 3. man This command is very essential because it is a manual of all the commands in Linux. You can use this command to see another command syntax, usage, and what that command does. usage : man ls output  : 4. chmod This command allows you to change the permission of any files. The Basic permissions are r ( read ), w ( write ), x ( execute ) The most common use of this command is, execute permission syntax : chmod [OPTION]... MODE[,MODE]... FILE... usage : chmod +x change.sh ls -l (this command allows you to see the permissions of a particular file) ls – l change.sh output : -rwxrwxr-x 1 dobz dobz 104 Dec  6 08:14 change.sh Here, First rwx -> owners, second rwx -> groups, third rwx -> others 5. top This command is an all information-packed dashboard, it will show all ongoing activity on your Linux system. usage : top output : This has two areas summary area ( Memory info ) task area ( processes ) 6. common all-time use commands —To make a directory ( ex: ) — Change directory ( ex: ) — Show current working directory ( ex: ) — To make files ( ex: ) — To list all the files and directories ( ex: ) — To delete the file or directory ( ex: ) .. — To get into the previous directory ( ex: ) mkdir mkdir tech_dobz cd cd tech_dobz/ pwd pwd touch touch sample.txt ls ls rm rm sample.txt cd cd .. output : “I’m not a great programmer; I’m just a good programmer with great habits.” — Kent Beck Learning is a never-ending journey you have to learn new things to cope up with this era. Build a habit of learning new things, whether it’s just for 15 min a day.

6 Essential Linux Terminal Commands Everyone Should Know

Photo by on dasha shchukova Unsplash Intro What is Buck? Buck is a free, open-source and lightweight tool used by developers to group multiple terminal commands into one. CLI Starting a new project, installing packages, executing, updating, and deploying requires you to run multiple terminal commands (for example:) Depending on your use case, this can range from a few commands to several commands which can be overwhelming and it distract us from actually building the next big thing. Especially if you are like me and you just want to show your parents that you are actually doing something with your life. Running these commands over and over again for your new projects is pretty inefficient and it goes against a rule we elite programmers swear by: Do not repeat yourself (DRY). Buck solves this problem by allowing you to group multiple commands once into buckets and you can run them with a custom keyword of your choice. Proudly made in 🇳🇬 by  Pleasanttech💚 Getting Started https://docs.getbuck.tech/ Also published here.

How to Run Multiple Terminal Commands in ONE, Like a Boss

Introduction: Sending Desktop Notifications Sometimes it's useful to get visual feedback from a script. For example, when script or cron job completes or when a long-running build fails, or when there is an urgent problem during script execution. Desktop applications can do this with popup notifications. But it can be done from a script too! You can use script commands to send yourself desktop notifications and reminders. The below code has been written and tested on Linux. What about MacOS? Well... it can be done too, with a bit of effort. Sending notifications from Linux terminal To send notifications from the Linux terminal, use the command. Run to see if it's present. If not, install it with your package manager of choice, for example notify-send which at sudo apt install notify-send A few examples of simple notifications: notify-send "Dinner ready!"
notify-send "Tip of the Day" "How about a nap?" You can customize the notification with options such as urgency level, custom icon, etc. Find out more with . You can use a small set of HTML tags in the notification body, to give your notifications nice touch. On top of that, URLs are rendered as clickable, for example: man notify-send notify-send -u critical \
  "Build failed!" \
  "There were <b>123</b> errors. Click to see the results: http://buildserver/latest" Sent notifications are picked up by the desktop environment and displayed just like any other notification. They will have the same consistent look, feel, and behaviour. Combine notify-send with AT We all know cron, used to schedule commands at regular intervals. Command is used to schedule single execution of a command at a specified time. If you run it like this: AT at 12:00 it will start in interactive mode, where you can enter commands to execute at given time. This isn't useful for scripts. Luckily, accepts parameters from standard input, so we can use it this way: at echo "npm run build" | at now + 1 minute
echo "backup-db" | at 13:00 There are many ways of specifying time. From absolute time such as through relative time such as to special times such as or . We can combine it with to show ourselves reminders at some time in future, for example: 10:00 now + 2 hours noon midnight notify-send echo "notify-send 'Stop it and go home now' 'Enough for today.' -u critical" | at now REMIND command Now, let's build a custom bash command for sending ourselves reminders. How about something as simple and human-friendly as: remind "I'm still here" now
remind "Time to wake up!" in 5 minutes
remind "Dinner" in 1 hour
remind "Take a break" at noon
remind "It's Friday pints time!" at 17:00 This is better than Alexa! How to get this goodness? See the code below. It defined bash function called which supports the above syntax. The actual work is done in the last two lines. The rest is responsible for help, parameter validation etc. which rougly matches the proportion of useful code vs necessary white-noise in any large application 😉 Save the code somewhere, for example in file and load the function in your profile: remind ~/bin/remind .bashrc source ~/bin/remind Reload the terminal, then type to see the syntax. Enjoy! remind #!/usr/bin/env bash

function remind () {
  local COUNT="$#"
  local COMMAND="$1"
  local MESSAGE="$1"
  local OP="$2"
  shift 2
  local WHEN="$@"

  # Display help if no parameters or help command
  if [[ $COUNT -eq 0 || "$COMMAND" == "help" || "$COMMAND" == "--help" || "$COMMAND" == "-h" ]]; then
    echo "COMMAND"
    echo "    remind <message> <time>"
    echo "    remind <command>"
    echo
    echo "DESCRIPTION"
    echo "    Displays notification at specified time"
    echo
    echo "EXAMPLES"
    echo '    remind "Hi there" now'
    echo '    remind "Time to wake up" in 5 minutes'
    echo '    remind "Dinner" in 1 hour'
    echo '    remind "Take a break" at noon'
    echo '    remind "Are you ready?" at 13:00'
    echo '    remind list'
    echo '    remind clear'
    echo '    remind help'
    echo
    return
  fi

  # Check presence of AT command
  if ! which at >/dev/null; then
    echo "remind: AT utility is required but not installed on your system. Install it with your package manager of choice, for example 'sudo apt install at'."
    return
  fi

  # Run commands: list, clear
  if [[ $COUNT -eq 1 ]]; then
    if [[ "$COMMAND" == "list" ]]; then
      at -l
    elif [[ "$COMMAND" == "clear" ]]; then
      at -r $(atq | cut -f1)
    else
      echo "remind: unknown command $COMMAND. Type 'remind' without any parameters to see syntax."
    fi
    return
  fi

  # Determine time of notification
  if [[ "$OP" == "in" ]]; then
    local TIME="now + $WHEN"
  elif [[ "$OP" == "at" ]]; then
    local TIME="$WHEN"
  elif [[ "$OP" == "now" ]]; then
    local TIME="now"
  else
    echo "remind: invalid time operator $OP"
    return
  fi

  # Schedule the notification
  echo "notify-send '$MESSAGE' 'Reminder' -u critical" | at $TIME 2>/dev/null
  echo "Notification scheduled at $TIME"
} Script Notifications on MacOS Although there is no on MacOS, notifications can be sent with ActionScript. For example: notify-send osascript -e 'display notification "Wake up!" with title "Reminder"' Also, there's available, so things should be easy? Well, not so. Sadly, MacOS is makes it increasingly difficult for power users to use their powers ... at First, command is disabled by default. Even if you run it, nothing will happen at scheduled time, because daemon is disabled, and no user account is allowed to use it by default. at atrun To allow yourself to use the command, edit file and add your user name. /var/at/at.allow sudo open -a textedit /var/at/at.allow Then enable daemon: atrun sudo launchctl load -w /System/Library/LaunchDaemons/com.apple.atrun.plist Let's try sending a notification: osascript -e 'display notification "Wake up!" with title "Reminder"' | at now ... and nothing happens. Why? The daemon is not allowed to interact with the desktop, nor anything else for that matter. To fix this, go to System Preferences / Security & Privacy / Privacy / Full Disk Access and add to the list. The file is found at path. You want to see this: atrun /usr/libexec/atrun ... only how to select this file? MacOS won't display system folders in the file selector, even if you've been asked to authenticate as admin just a minute ago. I managed to circumvent it by adding my `/usr` folder to list of favourite folders in Finder: Last but not least, for some even this won't work. AT will not send these pesky notifications, period. It has something to do with script executing not in userspace. You can find more information and solution here: . This is what helps: https://github.com/ChrisJohnsen/tmux-MacOSX-pasteboard # Install reattach-to-user-namespace utility
brew install reattach-to-user-namespace
# Run notification command as follows
reattach-to-user-namespace osascript -e 'display notification "Wake up!" with title "Reminder"' | at now Phew. Hopefully, it works for you too, and you can use script on your Mac as well! Happy weekend! remind Software License Permission is hereby granted, free of charge, to any person obtaining a copy of software published on this website and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions, unless stated explicitly otherwise: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. The software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the software.

Using a Script to Send Desktop Notifications from Your Linux Terminal

I bet you didn’t know about this new application under Hackernoon. If I was right, then I also bet you’re really curious to know more about it. So lest get started: What is Terminal Reader App? This is a web application with the intention of providing a different way of reading. Yes, you will be reading in a terminal-like application. You probably noted this button on most stories on Hackernoon: Well, this button will direct you to the terminal reader app where the story will be loaded in the terminal. Why? A big community of Hackernoon writers/readers love tech and many of them are programmers/developers. While working in this field, many developers are used to using the terminal for everything. It is kind of cool to know many commands and to make the computer do what you’re telling it to do. The terminal is part of our daily duties, and so why not keep it that ways by providing a reading experience in a terminal. The Interface The Terminal Reader App has a terminal-like interface giving it a classic touch for our readers. This app functions just like a regular terminal where you can type in commands and expect an output. When computers were first invented, there was only a terminal to receive input and provide an output. There were no fancy-looking applications; this served as one of the main reasons to create this app. The Commands All terminals work with commands. This application is no different. To have a list of all the commands provided, simply type “help” and a list and description of the commands will show up. This application is in the early stages, and will probably have further improvements. If you find a bug or find a way to hack it, please do not hesitate to let us know. We encourage you to play with this app and to provide feedback. By the way, if you do hack it, we will consider your application as a developer. HAPPY CODING HACKERS

Introducing the Terminal Reader App by HackerNoon

As a developer, I love working with the terminal. The plain, simple, and in my opinion the best way to interact with the computer (also it makes you look geeky). I spent most of my time in the terminal. By now you must have guessed I am a huge fan of the terminal and terminal-based applications. Recently I developed an interest in stock markets and started tracking the stock markets. Since I love working with the terminal I decided to build a terminal oriented application that can help me to track the stock market. Inspired by I build which can provide the stock's current prices, historical prices, and global market summary. wttr.in terminal-stocks How to use terminal-stocks is available and can be used without installation. terminal-stocks 1. Get the current price of the stock. curl https://terminal-stocks.herokuapp.com/ITC.NS You need to provide the ticker of the stock and terminal-stocks will give you the price information of the stock. uses yahoo finance’s ticker to fetch stock information. terminal-stocks 2. Get the historical prices of a stock. curl https://terminal-stocks.herokuapp.com/historical/ITC.NS This will give the 10 entries. To fetch more you can get it by providing page parameters like below. curl https://terminal-stocks.herokuapp.com/historical/ITC.NS?page=2 3. Get the global market summary right in your terminal. curl https://terminal-stocks.herokuapp.com/market-summary More and more features will be added going forward. How to use terminal-stocks as CLI If you want to use terminal-stocks as a cli tool, you are lucky, terminal-stocks comes with cli as well. You can install terminal-stocks in windows/ubuntu/mac and use it. 1. Install terminal-stocks from npm npm install terminal-stocks -g 2. Get the price information of stock terminal-stocks -t ITC.NS 3. Get the historical price information of stock terminal-stocks -t ITC.NS --historical 4. Get the market summary terminal-stocks --market 5. Export the data as json or csv terminal-stocks --ticker ITC.NS --json for csv terminal-stocks --ticker ITC.NS --csv Roadmap terminal-stocks is still in development and need a lot of improvements and feature development. Add stock price chart right in the terminal.Add live price for stocks.Add support to maintain portfolio and track p&l right in terminal. If you want to contribute and make terminal-stocks better, contributions are welcome via pull request on Github Important Links: Github: https://github.com/shweshi/terminal-stocks NPM: https://www.npmjs.com/package/terminal-stocks Thanks for reading. If you have some feedback, please reach out to me on or . Twitter Github Happy Coding!!! Also published at https://blog.shashi.dev/2021/01/track-stock-market-information-right-in.html

You Can Track Stock Market Data From Your Terminal

In this tutorial, you'll learn the most common and useful commands that you can run in almost any UNIX-like environment, including Linux and Mac OS X. - print working directory pwd allows you to output the current directory you’re in. It provides a short and easy answer to the question "Where am I?" It’s very useful to run the command at the beginning of your terminal session. Here’s an example of running right after logging into the server as a root. pwd pwd pwd root@scw-tender-lewin:~ /root # pwd - list files and directories ls To view the content of the directory, you can use the ( ) command. The basic usage goes like this: ls list root@scw-tender-lewin:/ bin   dev  home        initrd.img.old  lib64       media  opt   root  sbin  srv       sys  usr  vmlinuz
boot  etc  initrd.img  lib             lost+found  mnt    proc  run   snap  swapfile  tmp  var  vmlinuz.old # ls If you want to check out the content of a specific directory, i.e. var, you can do it by adding its path right after the : ls root@scw-tender-lewin:/ backups  cache  crash  lib lock mail  opt  run  snap  spool  tmp # ls /var local log There are also a couple of useful flags that will change the format of the output of the command. ls Long list view The flag will do the long list view, which shows additional information like permissions, owner, size, date, etc.: -l root@scw-tender-lewin:/ total 4194396
drwxr-xr-x   2 root root       4096 May 15 06:46 bin
drwxr-xr-x   4 root root       4096 Sep  3 06:15 boot
drwxr-xr-x  16 root root       3680 May 20 06:35 dev
drwxrwxr-x  93 root root       4096 Sep  3 06:15 etc
drwxr-xr-x   3 root root       4096 Mar  6 09:14 home
lrwxrwxrwx   1 root root         34 Sep  3 06:15 initrd.img -> boot/initrd.img-4.15.0-115-generic
lrwxrwxrwx   1 root root         34 Sep  3 06:15 initrd.img.old -> boot/initrd.img-4.15.0-112-generic
drwxr-xr-x  23 root root       4096 Mar  6 09:16 lib
drwxr-xr-x   2 root root       4096 Jul  8 06:20 lib64
drwx------   2 root root      16384 Mar  5  2019 lost+found
drwxr-xr-x   2 root root       4096 Feb  4  2019 media
drwxr-xr-x   2 root root       4096 Feb  4  2019 mnt
drwxr-xr-x   3 root root       4096 Mar  6 09:17 opt
dr-xr-xr-x 189 root root          0 May  4 06:16 proc
drwx------   8 root root       4096 Mar 19 08:13 root
drwxr-xr-x  28 root root       1120 Sep  3 07:21 run
drwxr-xr-x   2 root root      12288 Jul  8 06:20 sbin
drwxr-xr-x   2 root root       4096 Mar  6 09:14 snap
drwxr-xr-x   2 root root       4096 Feb  4  2019 srv
-rw-------   1 root root 4294967296 Mar  6 10:10 swapfile
dr-xr-xr-x  13 root root          0 May  4 06:16 sys
drwxrwxrwt  10 root root       4096 Sep  3 07:22 tmp
drwxrwxr-x  10 root root       4096 Mar  5  2019 usr
drwxr-xr-x  13 root root       4096 Mar  5  2019 var
lrwxrwxrwx   1 root root         31 Sep  3 06:15 vmlinuz -> boot/vmlinuz-4.15.0-115-generic
lrwxrwxrwx   1 root root         31 Sep  3 06:15 vmlinuz.old -> boot/vmlinuz-4.15.0-112-generic # ls -l By the way, if you want to check some specific information about a single file, you can add its name the same way we did with the directory. Here’s how you could check the long list view on the : swapfile root@scw-tender-lewin:/ -rw------- 1 root root 4294967296 Mar  6 10:10 swapfile # ls -l swapfile Hidden files and folders To view the hidden files and folders you should add the flag to the command: -a ls root@scw-tender-lewin:/ .   bin   dev  home        initrd.img.old  lib64       media  opt   root  sbin  srv       sys  usr  vmlinuz
..  boot  etc  initrd.img  lib             lost+found  mnt    proc  run   snap  swapfile  tmp  var  vmlinuz.old # ls -a This way, we always get at least two additional records: and . A single dot stands for the current directory and the double dot is used to access the directory one level above the current. . .. Sorting the output of the command ls The flag is used to sort the results by size in descending order. -S root@scw-tender-lewin:/ swapfile    sbin  boot  home  lib64  mnt  root  srv  usr  dev  initrd.img      vmlinuz      proc
lost+found  bin   etc   lib   media  opt  snap  tmp  var  run  initrd.img.old  vmlinuz.old  sys # ls -S Combining the flags Quite often you want to achieve a complex behavior. For example, you might want to get both the long list view with , the human-readable size output with and sort the results with the flag. -l -h -S To achieve this, you can just combine all flags into one. The order of the flags doesn’t matter here and is equivalent to , so you can use any sequence you like: -lhS -hSl root@scw-tender-lewin:/ total 4.1G
-rw-------   1 root root 4.0G Mar  6 10:10 swapfile
drwx------   2 root root  16K Mar  5  2019 lost+found
drwxr-xr-x   2 root root  12K Jul  8 06:20 sbin
drwxr-xr-x  23 root root 4.0K Sep  3 06:15 .
drwxr-xr-x  23 root root 4.0K Sep  3 06:15 ..
drwxr-xr-x   2 root root 4.0K May 15 06:46 bin
drwxr-xr-x   4 root root 4.0K Sep  3 06:15 boot
drwxrwxr-x  93 root root 4.0K Sep  3 06:15 etc
drwxr-xr-x   3 root root 4.0K Mar  6 09:14 home
drwxr-xr-x  23 root root 4.0K Mar  6 09:16 lib
drwxr-xr-x   2 root root 4.0K Jul  8 06:20 lib64
drwxr-xr-x   2 root root 4.0K Feb  4  2019 media
drwxr-xr-x   2 root root 4.0K Feb  4  2019 mnt
drwxr-xr-x   3 root root 4.0K Mar  6 09:17 opt
drwx------   8 root root 4.0K Mar 19 08:13 root
drwxr-xr-x   2 root root 4.0K Mar  6 09:14 snap
drwxr-xr-x   2 root root 4.0K Feb  4  2019 srv
drwxrwxrwt  10 root root 4.0K Sep  3 07:22 tmp
drwxrwxr-x  10 root root 4.0K Mar  5  2019 usr
drwxr-xr-x  13 root root 4.0K Mar  5  2019 var
drwxr-xr-x  16 root root 3.6K May 20 06:35 dev
drwxr-xr-x  28 root root 1.1K Sep  3 07:21 run
lrwxrwxrwx   1 root root   34 Sep  3 06:15 initrd.img -> boot/initrd.img-4.15.0-115-generic
lrwxrwxrwx   1 root root   34 Sep  3 06:15 initrd.img.old -> boot/initrd.img-4.15.0-112-generic
lrwxrwxrwx   1 root root   31 Sep  3 06:15 vmlinuz -> boot/vmlinuz-4.15.0-115-generic
lrwxrwxrwx   1 root root   31 Sep  3 06:15 vmlinuz.old -> boot/vmlinuz-4.15.0-112-generic
dr-xr-xr-x 191 root root    0 May  4 06:16 proc
dr-xr-xr-x  13 root root    0 Sep  3 08:25 sys # ls -lhS - change directory cd So, after you’ve learned everything about the content in the directory, you probably want to go somewhere else. The command will take a directory name as a single argument and move you there. The command only prints the output if there’s an error, so you might want to immediately use the command to look around: cd cd ls root@scw-tender-lewin:/ root@scw-tender-lewin:/var .  ..  backups  cache  crash  lib lock mail  opt  run  snap  spool  tmp # cd var # ls -a local log Moving into the parent folder To move one folder above you should use the as a directory name. To move two or more levels above you can type and so on. .. cd ../.. If you’ve tried to navigate to the directory that doesn’t exist, you’ll see the following message: root@scw-tender-lewin:/var -bash: : local42: No such file or directory
root@scw-tender-lewin:/var root@scw-tender-lewin:/ bin   dev  home        initrd.img.old  lib64       media  opt   root  sbin  srv       sys  usr  vmlinuz
boot  etc  initrd.img  lib             lost+found  mnt    proc  run   snap  swapfile  tmp  var  vmlinuz.old # cd local42 cd # cd .. # ls Going home If you use the symbol as a directory name, you’ll be moved into your home folder. It’s a useful shortcut as it doesn’t matter where you are at the moment and you might now know the exact path to the home directory at some point. ~ root@scw-tender-lewin:/ root@scw-tender-lewin:~ /root # cd ~ # pwd - create a file touch The command allows you to create an empty file. So, here’s the plan: touch Navigate to our home directory with cd ~ Make sure it’s empty with ls Create a new file using and providing a filename right after it touch Run the command once again to see that the newly created file exists ls root@scw-tender-lewin:/var/ root@scw-tender-lewin:~ root@scw-tender-lewin:~ root@scw-tender-lewin:~ hello.txt log # cd ~ # ls # touch hello.txt # ls - create a directory mkdir To create a directory in Linux you should use the command. It works almost the same way as and expects the directory name. mkdir touch root@scw-tender-lewin:~ root@scw-tender-lewin:~ hello.txt  internal # mkdir internal # ls - display a manual / get help man And finally, the superpower! The command will give you a short manual on any command, even itself. If you want to do something but have forgotten an important flag or the command syntax, just type followed by the command name to get an instant manual. Here’s an example: man man root@scw-tender-lewin:~ NAME
     ls -- list directory contents

SYNOPSIS
     ls [-ABCFGHLOPRSTUW@abcdefghiklmnopqrstuwx1%] [file ...]

DESCRIPTION
     For each operand that names a file of a other than directory, ls displays its name as well as any requested, associated information.
     For each operand that names a file of directory, ls displays the names of files contained within that directory, as well as any
     requested, associated information.

     If no operands are given, the contents of the current directory are displayed.  If more than one operand is given, non-directory operands
     are displayed first; directory and non-directory operands are sorted separately and lexicographical order.

     The following options are available:
... # man ls type type in Conclusion In this article, we’ve reviewed the easiest to use and straightforward Linux, macOS, and *nix system commands like , , , , , and . ls pwd cd touch mkdir man If you're just starting your journey into the software development world, you might be intimidated by the looks of the all-mighty terminal or command-line. But as you see, it's quite easy and straightforward if you start at the right spot. Thanks for reading! I write a programming blog at and teach JavaScript programming . learn.coderslang.com Full Stack JS course Talk soon! Previously published at https://learn.coderslang.com/0001-the-most-useful-terminal-commands-linux-mac-and-unix/

Stories, News & Mentions about TERMINAL

Terminal’s Stories on HackerNoon

Terminal's News & Mentions