GENERIC-SPECIFIC-TREE of appEditor

generic-tree-of-appEditor::
* app,
* ... entity,
* McsEngl.appEditor'generic-tree,

specific-tree-of-appEditor::
* audio-editor,
* source-code-editor,
* video-editor,
* word-processor,
* wysiwyg-editor,

* McsEngl.appEditor.specific-tree,

appEditor.wysiwyg

description::
· wysiwyg-editor is an-editor of formated-content that it allows users to create and edit content in a way that closely resembles its final appearance without expertise in the-underline code.
· Some popular WYSIWYG editors include:
* Microsoft Word
* Google Docs
* TinyMCE
· some of the drawbacks of using a WYSIWYG editor:
* Limited control: WYSIWYG editors may not offer the same level of control over the content as a text editor.
* Code bloat: WYSIWYG editors may insert unnecessary code into the content, which can make it difficult to maintain.
* Security risks: WYSIWYG editors may be vulnerable to security risks, such as cross-site scripting (XSS) attacks.

name::
* McsEngl.What-You-See-Is-What-You-Get-appEditor,
* McsEngl.appEditor.wysiwyg,
* McsEngl.wysiwyg-editor,

WebApp.specific

description::
* wordprocessor-WebApp,
* spreadsheet-WebApp,
* painting-WebApp,
===
* https://jspaint.app: painting WebApp,
* https://mermaid.live/: diagrams,
* https://www.google.com/search?q=unit+converter,

=== on this site:
* EuroDrahmas-old,
* EuroDrahmas-new,
* κλίση-Ελληνικών-ουσιαστικών,
===
* search for (F2): 'WebApp.name'
* ψάξε (Ctrl+F2): 'ιστοεφαρμογή.όνομα'

name::
* McsEngl.WebApp.specific,

info-resource of prgmOs

name::
* McsEngl.prgmOs'InfRsc,

addressWpg::
* https://en.wikipedia.org/wiki/Timeline_of_operating_systems,

prgmOs.SPECIFIC

description::
× HitpMcs-creation: {2025-11-19},
* Android,
* Linux,
* MacOs,
* Windows,

name::
* McsEngl.prgmOs.specific,

program of AdrdOs

description::
· any computer-program on Android-Os.

name::
* McsEngl.AdrdPrgm!=program-of-Android-OS,
* McsEngl.CmprPrgm.Android!⇒AdrdPrgm,
* McsEngl.CmprPrgm.AdrdOs!⇒AdrdPrgm,
* McsEngl.AdrdOs'program!⇒AdrdPrgm,

APK-file of AdrdOs

description::
"overview of APK:
APK, or Android Package Kit, is the file format used for distributing and installing mobile apps on Android devices. APK files contain all of the code, resources, and assets needed for an app to run, including:
* **Code:** The compiled code for the app, written in Java or Kotlin.
* **Resources:** The app's user interface elements, such as images, layouts, and strings.
* **Assets:** Other files needed for the app to run, such as sound effects, fonts, and databases.
* **Manifest file:** A file that describes the app's permissions, components, and other metadata.

APK files are typically created using an Android development environment such as Android Studio. Once an APK file is created, it can be installed on an Android device manually or through an app store such as Google Play.

When an APK file is installed on an Android device, the system first verifies the file's signature to ensure that it has not been tampered with. If the signature is valid, the system then extracts the APK file's contents and installs the app.

APK files can also be used to distribute and install system updates and other software packages on Android devices.

Here are some of the benefits of using APK files:
* **Convenience:** APK files provide a convenient way to distribute and install Android apps. Apps can be installed from a variety of sources, including the Google Play Store, third-party app stores, and websites.
* **Flexibility:** APK files can be used to install both free and paid apps. They can also be used to install apps that are not available on the Google Play Store.
* **Control:** APK files give users more control over the apps they install on their devices. Users can choose to install apps from trusted sources and avoid installing apps that may contain malware.

However, there are also some risks associated with installing APK files from unknown sources:
* **Security:** APK files from unknown sources may contain malware, such as viruses or spyware.
* **Compatibility:** APK files may not be compatible with all Android devices.
* **Updates:** APK files from unknown sources may not be updated regularly, which can leave apps vulnerable to security vulnerabilities.

Overall, APK files are a convenient and flexible way to distribute and install Android apps. However, it is important to only install APK files from trusted sources to avoid security risks and compatibility issues."
[{2023-10-30 retrieved} https://bard.google.com/chat/ec6dd4d46ab5f244]

name::
* McsEngl.APK-file,
* McsEngl.Android-package-Kit,
* McsEngl.AdrdOs'APK-file,

command of LinxOs

description::
× HitpMcs-creation: {2025-11-19},

alias::
Create an alias
* McsEngl.LinxCmnd.alias,

apropos::
Search Help manual pages (man -k)
* McsEngl.LinxCmnd.apropos,

apt-get::
Search for and install software packages (Debian/Ubuntu)
* McsEngl.LinxCmnd.apt-get,

aptitude::
Search for and install software packages (Debian/Ubuntu)
* McsEngl.LinxCmnd.aptitude,

aspell::
Spell Checker
* McsEngl.LinxCmnd.aspell,

awk::
Find and Replace text, database sort/validate/index
* McsEngl.LinxCmnd.awk,

basename::
Strip directory and suffix from filenames
* McsEngl.LinxCmnd.basename,

bash::
GNU Bourne-Again SHell
* McsEngl.LinxCmnd.bash,

bc::
Arbitrary precision calculator language
* McsEngl.LinxCmnd.bc,

bg::
Send to background
* McsEngl.LinxCmnd.bg,

break::
Exit from a loop
* McsEngl.LinxCmnd.break,

builtin::
Run a shell builtin
* McsEngl.LinxCmnd.builtin,

bzip2::
Compress or decompress named file(s)
* McsEngl.LinxCmnd.bzip2,

cal::
Display a calendar
* McsEngl.LinxCmnd.cal,

case::
Conditionally perform a command
* McsEngl.LinxCmnd.case,

cat::
Concatenate and print (display) the content of files
* print the contents of one or more files to the screen
* $ cat /etc/*-release: prints linux distribution.
* McsEngl.LinxCmnd.cat,

cd::
Change Directory
* http://www.linuxnix.com/2012/07/23-linux-cd-command-examples.html,
* The cd command is just like the one of DOS, with a few extras. It does just what its acronym says, change the working directory. You can use . and .., which stand respectively for the current directory and its parent directory. Typing cd alone will bring you back to your home directory. Typing cd - will bring you back to the latest directory you were in. And lastly, you can specify the home directory of a user john by typing john (' ' on its own or followed by '/' means your own home directory).
* cd  = goes to home.
* cd ~  = goes to home.
* cd ..  = goes to previous directory.
* McsEngl.LinxCmnd.cd,

cfdisk::
Partition table manipulator for Linux
* McsEngl.LinxCmnd.cfdisk,

chgrp::
Change group ownership
* McsEngl.LinxCmnd.chgrp,

chmod::
Change access permissions
change the permissions on a file or change one of the other attributes that make up the file's mode.
chmod +x autogen.sh ⭢ if permission denyed.
* McsEngl.LinxCmnd.chmod,

chown::
Change file owner and group
* McsEngl.LinxCmnd.chown,

chroot::
Run a command with a different root directory
* McsEngl.LinxCmnd.chroot,

chkconfig::
System services (runlevel)
* McsEngl.LinxCmnd.chkconfig,

cksum::
Print CRC checksum and byte counts
* McsEngl.LinxCmnd.cksum,

clear::
Clear terminal screen
* McsEngl.LinxCmnd.clear,
* McsEngl.LinxCmnd.cls,

cmp::
Compare two files
* McsEngl.LinxCmnd.cmp,

comm::
Compare two sorted files line by line
* McsEngl.LinxCmnd.comm,

command::
Run a command - ignoring shell functions
* McsEngl.LinxCmnd.command,

continue::
Resume the next iteration of a loop
* McsEngl.LinxCmnd.continue,

cp::
Copy one or more files to another location
* McsEngl.LinxCmnd.cp,

cron::
Daemon to execute scheduled commands
* McsEngl.LinxCmnd.cron,

crontab::
Schedule a command to run at a later time
* McsEngl.LinxCmnd.crontab,

csplit::
Split a file into context-determined pieces
* McsEngl.LinxCmnd.csplit,

cut::
Divide a file into several parts
* McsEngl.LinxCmnd.cut,

date::
Display or change the date & time
* McsEngl.LinxCmnd.date,

dc::
Desk Calculator
* McsEngl.LinxCmnd.dc,

dd::
Convert and copy a file, write disk headers, boot records
* McsEngl.LinxCmnd.dd,

ddrescue::
Data recovery tool
* McsEngl.LinxCmnd.ddrescue,

declare::
Declare variables and give them attributes
* McsEngl.LinxCmnd.declare,

df::
Display free disk space
* McsEngl.LinxCmnd.df,

diff::
Display the differences between two files
* McsEngl.LinxCmnd.diff,

diff3::
Show differences among three files
* McsEngl.LinxCmnd.diff3,

dig::
DNS lookup
* McsEngl.LinxCmnd.dig,

dir::
Briefly list directory contents
* McsEngl.LinxCmnd.dir,

dircolors::
Colour setup for `ls'
* McsEngl.LinxCmnd.dircolors,

dirname::
Convert a full pathname to just a path
* McsEngl.LinxCmnd.dirname,

dirs::
Display list of remembered directories
* McsEngl.LinxCmnd.dirs,

dmesg::
Print kernel & driver messages
* McsEngl.LinxCmnd.dmesg,

du::
Estimate file space usage
* McsEngl.LinxCmnd.du,

echo::
Display message on screen
* Processes have their environment variables and the shell allows you to view them directly, with the echo command.
* example:
- $ echo $HOME /home/joe  =displays the value of $HOME.
- $ echo Hello >myfile  = creates the file 'myfile' with content "Hello".
* McsEngl.LinxCmnd.echo,

egrep::
Search file(s) for lines that match an extended expression
* McsEngl.LinxCmnd.egrep,

eject::
Eject removable media
* McsEngl.LinxCmnd.eject,

enable::
Enable and disable builtin shell commands
* McsEngl.LinxCmnd.enable,

env::
Environment variables
* McsEngl.LinxCmnd.env,

ethtool::
Ethernet card settings
* McsEngl.LinxCmnd.ethtool,

eval::
Evaluate several commands/arguments
* McsEngl.LinxCmnd.eval,

exec::
Execute a command
* McsEngl.LinxCmnd.exec,

exit::
Exit the shell
* McsEngl.LinxCmnd.exit,

expect::
Automate arbitrary applications accessed over a terminal
* McsEngl.LinxCmnd.expect,

expand::
Convert tabs to spaces
* McsEngl.LinxCmnd.expand,

export::
Set an environment variable
* McsEngl.LinxCmnd.export,

expr::
Evaluate expressions
* McsEngl.LinxCmnd.expr,

false::
Do nothing, unsuccessfully
* McsEngl.LinxCmnd.false,

fdformat::
Low-level format a floppy disk
* McsEngl.LinxCmnd.fdformat,

fdisk::
Partition table manipulator for Linux
* McsEngl.LinxCmnd.fdisk,

fg::
Send job to foreground
* McsEngl.LinxCmnd.fg,

fgrep::
Search file(s) for lines that match a fixed string
* McsEngl.LinxCmnd.fgrep,

file::
Determine file type
* McsEngl.LinxCmnd.file,

find::
Search for files that meet a desired criteria
* find / -name <name> -print  = searches at root dir
* McsEngl.LinxCmnd.find,

fmt::
Reformat paragraph text
* McsEngl.LinxCmnd.fmt,

fold::
Wrap text to fit a specified width.
* McsEngl.LinxCmnd.fold,

for::
Expand words, and execute commands
* McsEngl.LinxCmnd.for,

format::
Format disks or tapes
* McsEngl.LinxCmnd.format,

free::
Display memory usage
* McsEngl.LinxCmnd.free,

fsck::
File system consistency check and repair
* McsEngl.LinxCmnd.fsck,

ftp::
File Transfer Protocol
* McsEngl.LinxCmnd.ftp,

function::
Define Function Macros
* McsEngl.LinxCmnd.function,

fuser::
Identify/kill the process that is accessing a file
* McsEngl.LinxCmnd.fuser,

gawk::
Find and Replace text within file(s)
* McsEngl.LinxCmnd.gawk,

getopts::
Parse positional parameters
* McsEngl.LinxCmnd.getopts,

grep::
Search file(s) for lines that match a given pattern
"Here are many practical examples of the grep command in Linux, from basic to advanced:Basic usagebash
grep "error" logfile.txt # Search for "error" in a file
grep -i "error" logfile.txt # Case-insensitive search (-i)
grep -i -n "error" logfile.txt # Show line numbers (-n)
grep -i -n -C 3 "error" logfile.txt # Show 3 lines of context before/after (-C)
Common useful optionsbash
grep -r "search_term" /path/to/dir/ # Recursive search in directory (-r or --recursive)
grep -l "search_term" *.log # Only show filenames that contain match (-l)
grep -L "search_term" *.log # Show filenames that DO NOT contain match
grep -v "search_term" file.txt # Invert match – show lines that do NOT contain the term (-v)
grep -w "exactword" file.txt # Match whole word only (-w)
grep -c "error" *.log # Count occurrences per file (-c)
Search in running processesbash
ps aux | grep firefox # Find processes containing "firefox"
ps aux | grep -v grep | grep firefox # Exclude grep itself from results

Search with regular expressionsbash
grep "^root" /etc/passwd # Lines that start with "root" (^ = beginning of line)
grep "bash$" /etc/passwd # Lines that end with "bash" ($ = end of line)
grep "error\|warning" logfile.txt # Search for "error" OR "warning" (use \| in basic grep)
grep -E "error|warning" logfile.txt # Same as above but with extended regex (-E)
grep "[0-9]\{3\}-[0-9]\{3\}-[0-9]\{4\}" file.txt # Find US phone pattern (e.g., 123-456-7890)
Color output (default on most modern systems)bash
grep --color=auto "error" logfile.txt # Highlight matches in color
grep -i --color=always "error" file.txt | less -R # Keep color when piping to less

Real-world practical examplesbash
# Find all Python files containing "TODO"
find . -name "*.py" -exec grep -l "TODO" {} \;
# Show only the matched part (not whole line)
grep -o "http[^[:space:]]*" webpage.html # Extract all URLs
# Check if a user exists in /etc/passwd
grep "^john:" /etc/passwd
# Monitor logs in real-time (like tail -f but with filtering)
tail -f /var/log/syslog | grep -i "failed|error"
# Find large files in current directory (combine with ls)
ls -la | grep -E "[0-9]{3}M|[0-9]G" # Files 100MB or larger
# Search compressed files without extracting
zgrep "pattern" file.log.gz # Works with .gz files
zgrep -r "pattern" /var/log/ # Recursive on .gz files
Bonus: Modern alternatives (often faster)bash
# ripgrep (rg) – much faster than grep
rg "search_term" # Simple and fast
rg -i -n --type py "def main" # Case-insensitive, show line numbers, only Python files
# The Silver Searcher (ag)
ag "TODO" --python # Search only Python files
These examples cover 95% of daily grep usage. Let me know what you're trying to search for and I can give you the exact command!"
[{2025-11-24 retrieved} https://x.com/i/grok?conversation=1992836493077774435]
* McsEngl.LinxCmnd.grep,

groupadd::
Add a user security group
* McsEngl.LinxCmnd.groupadd,

groupdel::
Delete a group
* McsEngl.LinxCmnd.groupdel,

groupmod::
Modify a group
* McsEngl.LinxCmnd.groupmod,

groups::
Print group names a user is in
* McsEngl.LinxCmnd.groups,

gzip::
Compress or decompress named file(s)
* McsEngl.LinxCmnd.gzip,

hash::
Remember the full pathname of a name argument
* McsEngl.LinxCmnd.hash,

head::
Output the first part of file(s)
* McsEngl.LinxCmnd.head,

help::
Display help for a built-in command
* McsEngl.LinxCmnd.help,

history::
Command History
* McsEngl.LinxCmnd.history,

hostname::
Print or set system name
* McsEngl.LinxCmnd.hostname,

iconv::
Convert the character set of a file
* McsEngl.LinxCmnd.iconv,

id::
Print user and group id's
* McsEngl.LinxCmnd.id,

if::
Conditionally perform a command
* McsEngl.LinxCmnd.if,

ifconfig::
Configure a network interface
* McsEngl.LinxCmnd.ifconfig,

ifdown::
Stop a network interface
* McsEngl.LinxCmnd.ifdown,

ifup::
Start a network interface up
* McsEngl.LinxCmnd.ifup,

import::
Capture an X server screen and save the image to file
* McsEngl.LinxCmnd.import,

info::
* info pages are another source source of documentation which are more complete than manual pages. The command for accessing info pages is info.
The info pages are arranged in the form of a tree structure with its top called dir. From the top, you can access all existing info pages.
You can call up info in two ways: either with no argument, in which case you will find yourself at the top of the tree structure, or followed by a command or package name, in which case the corresponding page, if it exists, will be opened. For example:
$ info emacs
* McsEngl.LinxCmnd.info,

install::
Copy files and set attributes
=============================
# List installed packages
apt list --installed

# Uninstall a package
sudo apt remove package-name

# Uninstall + remove config files
sudo apt purge package-name

# Clean unused dependencies
sudo apt autoremove
* McsEngl.LinxCmnd.install,
* McsEngl.LinxCmnd.uninstall,

jobs::
List active jobs
* McsEngl.LinxCmnd.jobs,

join::
Join lines on a common field
* McsEngl.LinxCmnd.join,

kill::
Stop a process from running
* McsEngl.LinxCmnd.kill,

killall::
Kill processes by name
* McsEngl.LinxCmnd.killall,

less::
Display output one screen at a time
* a pager. Its name is a play on words related to the first pager ever under Unix, which was called more. A pager is a program which allows a user to view long files page-by-page (more accurately, screen-by-screen). We speak about less rather than more because its use is much more intuitive. Use less to view large files, which do not fit on a screen. For example:
less /usr/doc/HOWTO/PCMCIA-HOWTO
To navigate the file, just use the up and down arrow keys. Use 'q' to quit. less can do far more than that, indeed: just type h for help, and look. But anyway, the goal of this section is just to enable you to read long files, and this goal is now achieved :)
* McsEngl.LinxCmnd.less,

let::
Perform arithmetic on shell variables
* McsEngl.LinxCmnd.let,

lilo::
* lilo -u /dev/hda  = removes linux from hda boot sector.
* lilo    = installs lilo in boot record.
* Η ντιρεκτίβα boot = στο αρχείο /etc/lilo.conf λέει στο Lilo πού θα πρέπει να τοποθετήσει το primary boot loader. Γενικά, μπορείτε να επιλέξετε είτε το master boot sector (/dev/hda) είτε το root partition της Linux εγκατάστασης σας (συνήθως είναι στο /dev/hda1 ή στο /dev/hda2).
* McsEngl.LinxCmnd.lilo,

ln::
Create a symbolic link to a file
* ln a b  =links the file a with file b.
* whole: file-management-command.
* McsEngl.LinxCmnd.ln,

local::
Create variables
* McsEngl.LinxCmnd.local,

locate::
Find files
* McsEngl.LinxCmnd.locate,

logname::
Print current login name
* McsEngl.LinxCmnd.logname,

logout::
Exit a login shell
* McsEngl.LinxCmnd.logout,

look::
Display lines beginning with a given string
* McsEngl.LinxCmnd.look,

lpc::
Line printer control program
* McsEngl.LinxCmnd.lpc,

lpr::
Off line print
* McsEngl.LinxCmnd.lpr,

lprint::
Print a file
* McsEngl.LinxCmnd.lprint,

lprintd::
Abort a print job
* McsEngl.LinxCmnd.lprintd,

lprintq::
List the print queue
* McsEngl.LinxCmnd.lprintq,

lprm::
Remove jobs from the print queue
* McsEngl.LinxCmnd.lprm,

ls::
List information about file(s)
* listing files (LiSt)
This command is equivalent to dir in DOS, but it can do much much more. In fact, this is largely due to the fact that files can do more too :) The command syntax for ls is as follows:
ls [options] [file|directory] [file|directory...]
If no file or directory is specified on the command line, ls will print the list of files in the current directory. Its options are very numerous and we will only cite a few of them:
-a: List all files, including hidden files (in Unix hidden files are files whose names begin with .); the option -A lists "almost" all files, which means every file the -a option would print except "." and "..";
-R: List recursively, i.e. all files and subdirectories of the directories mentioned in the command line;
-s: Displays the file size in kilobytes next to each file;
-l: Displays additional information about the files;
-i: Displays the inode number (the file's unique number on a filesystem, see chapter 14.0) next to each file;
-d: Displays the directories as normal files instead of listing their contents.

* example:
- ls -al images/*.gif: lists all files (including any hidden files) in directory images/ with names ending in .gif. Note that this also includes the file .gif if one exists.
* McsEngl.LinxCmnd.ls,

lsof::
List open files
* McsEngl.LinxCmnd.lsof,

make::
Recompile a group of programs
* McsEngl.LinxCmnd.make,

man::
Help manual
* The command for displaying a manual page is man, and its syntax is as follows:
man [options] [section] <manual page>
* McsEngl.LinxCmnd.man,

mkdir::
Create new folder(s)
* mkdir is used for creating directories. Its syntax is simple:
mkdir [options] <directory> [directory ...]
Only one option is worth noting: the option -p. If this option is set, mkdir will create parent directories if these did not exist before. If this option is not specified and the parent directories do not exist, mkdir will display an error. Examples:
mkdir foo: creates a directory foo in the current directory;
mkdir -p : --parents "no error if existing, make parent directories as needed".
* McsEngl.LinxCmnd.mkdir,

mkfifo::
Make FIFOs (named pipes)
* McsEngl.LinxCmnd.mkfifo,

mkisofs::
Create an hybrid ISO9660/JOLIET/HFS filesystem
* McsEngl.LinxCmnd.mkisofs,

mknod::
Make block or character special files
* McsEngl.LinxCmnd.mknod,

more::
Display output one screen at a time
* McsEngl.LinxCmnd.more,

mount::
Mount a file system
* The command to mount filesystems is the mount command, and its syntax is as follows:
$ mount [options] <-t type> [-mount options] <device> <mounting point>
In this case, we want to mount our partition on /mnt (or any other mount point you have chosen -- don't forget that it must exist); the command for mounting our newly created partition is as follows:
$ mount -t ext2 /dev/hdb1 /mnt
The -t option is used to specify what type of filesystem the partition is supposed to host. Among the filesystems you will encounter most frequently, are ext2 (the Linux filesystem), vfat (for all DOS/Windows partitions: FAT 12, 16 or 32) and iso9660 (CDROM filesystem).
The -o option is used to specify one or more mounting options. These options depend on the filesystem used. Refer to the mount(8) manual page for more details.
* WHOLE: file-management-commands.
* mount /windows/F : mount my shared 20GB disk.
* McsEngl.LinxCmnd.mount,

mtools::
Manipulate MS-DOS files
* McsEngl.LinxCmnd.mtools,

mtr::
Network diagnostics (traceroute/ping)
* McsEngl.LinxCmnd.mtr,

mv::
Move or rename files or directories
* McsEngl.LinxCmnd.mv,

mmv::
Mass Move and rename (files)
* McsEngl.LinxCmnd.mmv,

netstat::
Networking information
* McsEngl.LinxCmnd.netstat,

nice::
Set the priority of a command or job
* McsEngl.LinxCmnd.nice,

nl::
Number lines and write files
* McsEngl.LinxCmnd.nl,

nohup::
Run a command immune to hangups
* McsEngl.LinxCmnd.nohup,

notify::
send Send desktop notifications
* McsEngl.LinxCmnd.notify,

nslookup::
Query Internet name servers interactively
* McsEngl.LinxCmnd.nslookup,

open::
Open a file in its default application
* McsEngl.LinxCmnd.open,

op::
Operator access
* McsEngl.LinxCmnd.op,

passwd::
Modify a user password
* McsEngl.LinxCmnd.passwd,

paste::
Merge lines of files
* McsEngl.LinxCmnd.paste,

pathchk::
Check file name portability
* McsEngl.LinxCmnd.pathchk,

ping::
Test a network connection
* McsEngl.LinxCmnd.ping,

pkill::
Stop processes from running
* McsEngl.LinxCmnd.pkill,

popd::
Restore the previous value of the current directory
* McsEngl.LinxCmnd.popd,

pr::
Prepare files for printing
* McsEngl.LinxCmnd.pr,

printcap::
Printer capability database
* McsEngl.LinxCmnd.printcap,

printenv::
Print environment variables
* McsEngl.LinxCmnd.printenv,

printf::
Format and print data
* McsEngl.LinxCmnd.printf,

ps::
Process status
* McsEngl.LinxCmnd.ps,

pushd::
Save and then change the current directory
* McsEngl.LinxCmnd.pushd,

pwd::
Print Working Directory
* McsEngl.LinxCmnd.pwd,

quota::
Display disk usage and limits
* McsEngl.LinxCmnd.quota,

quotacheck::
Scan a file system for disk usage
* McsEngl.LinxCmnd.quotacheck,

quotactl::
Set disk quotas
* McsEngl.LinxCmnd.quotactl,

ram::
ram disk device
* McsEngl.LinxCmnd.ram,

rcp::
Copy files between two machines
* McsEngl.LinxCmnd.rcp,

read::
Read a line from standard input
* McsEngl.LinxCmnd.read,

readarray::
Read from stdin into an array variable
* McsEngl.LinxCmnd.readarray,

readonly::
Mark variables/functions as readonly
* McsEngl.LinxCmnd.readonly,

reboot::
Reboot the system
* McsEngl.LinxCmnd.reboot,

rename::
Rename files.
· if not present:
sudo apt update && sudo apt install rename -y
- mv: Move or rename files or directories
- mmv: Mass Move and rename (files)
* McsEngl.LinxCmnd.rename,

renice::
Alter priority of running processes
* McsEngl.LinxCmnd.renice,

remsync::
Synchronize remote files via email
* McsEngl.LinxCmnd.remsync,

return::
Exit a shell function
* McsEngl.LinxCmnd.return,

rev::
Reverse lines of a file
* McsEngl.LinxCmnd.rev,

rm::
Remove files
* rm: deleting files or directories (ReMove) This command replaces the DOS commands del and deltree, and more. Its syntax is as follows:

rm [options] <file|directory> [file|directory...]
Options include:
-r, or -R: Delete recursively. This option is mandatory for deleting a directory, empty or not. However, there is also the command rmdir for deleting empty directories. -i: Request confirmation before each deletion. It is recommended to alias the bare rm word to rm -i in your shell, and the same goes for cp and mv commands. -f: The opposite of -i, forces deletion of the files or directories, even if the user has no write authorisation on the files[4].
* McsEngl.LinxCmnd.rm,
* McsEngl.LinxCmnd.remove,
* McsEngl.LinxCmnd.delete,

rmdir::
Remove folder(s)
* McsEngl.LinxCmnd.rmdir,

rsync::
Remote file copy (Synchronize file trees)
* McsEngl.LinxCmnd.rsync,

screen::
Multiplex terminal, run remote shells via ssh
* McsEngl.LinxCmnd.screen,

scp::
Secure copy (remote file copy)
* McsEngl.LinxCmnd.scp,

sdiff::
Merge two files interactively
* McsEngl.LinxCmnd.sdiff,

sed::
Stream Editor
* McsEngl.LinxCmnd.sed,

select::
Accept keyboard input
* McsEngl.LinxCmnd.select,

seq::
Print numeric sequences
* McsEngl.LinxCmnd.seq,

set::
Manipulate shell variables and functions
* McsEngl.LinxCmnd.set,

sftp::
Secure File Transfer Program
* McsEngl.LinxCmnd.sftp,

shift::
Shift positional parameters
* McsEngl.LinxCmnd.shift,

shopt::
Shell Options
* McsEngl.LinxCmnd.shopt,

shutdown::
Shutdown or restart linux
* McsEngl.LinxCmnd.shutdown,

sleep::
Delay for a specified time
* McsEngl.LinxCmnd.sleep,

slocate::
Find files
* McsEngl.LinxCmnd.slocate,

sort::
Sort text files
* McsEngl.LinxCmnd.sort,

source::
Run commands from a file `.'
* McsEngl.LinxCmnd.source,

split::
Split a file into fixed-size pieces
* McsEngl.LinxCmnd.split,

ssh::
Secure Shell client (remote login program)
* McsEngl.LinxCmnd.ssh,

strace::
Trace system calls and signals
* McsEngl.LinxCmnd.strace,

su::
Substitute user identity
The su command, also referred to as substitute user, super user, or switch user, allows a computer operator to change the current user account associated with the running virtual console.
By default, and without any other command line argument, this will elevate the current user to the superuser of the local system.
[http://en.wikipedia.org/wiki/Su_(Unix)]
===
* The command to "become" root when you have launched a shell as a user is su:
* McsEngl.LinxCmnd.su,

sudo::
Execute a command as another user
This means that in the terminal you should use sudo for commands that require root privileges; simply prepend sudo to all the commands you would normally run as Root.
[https://help.ubuntu.com/community/RootSudo]
===
Sudo stands for either "substitute user do" or "super user do" (depending upon how you want to look at it). What sudo does is incredibly important and crucial to many Linux distributions. Effectively, sudo allows a user to run a program as another user (most often the root user). There are many that think sudo is the best way to achieve "best practice security" on Linux. There are some, however, that feel quite the opposite. Regardless of where you stand, and what distribution you are currently using, there will come a time when you will have to take advantage of sudo. Whether you will need to simply use sudo or you will have to configure sudo you will want to know the ins and outs of this powerful tool.
[http://www.linux.com/learn/tutorials/306766:linux-101-introduction-to-sudo]
* McsEngl.LinxCmnd.sudo,

sum::
Print a checksum for a file
* McsEngl.LinxCmnd.sum,

suspend::
Suspend execution of this shell
* McsEngl.LinxCmnd.suspend,

symlink::
Make a new name for a file
* McsEngl.LinxCmnd.symlink,

sync::
Synchronize data on disk with memory
* McsEngl.LinxCmnd.sync,

tail::
Output the last part of file
* McsEngl.LinxCmnd.tail,

tar::
Tape ARchiver
* tar: Tape ARchiver:
* http://www.thegeekstuff.com/2010/04/unix-tar-command-examples//
* Extract a *.tar file using option xvf
$ tar xvf archive_name.tar
* Extract a gzipped tar archive ( *.tar.gz ) using option xvzf
$ tar xvfz archive_name.tar.gz
===
Although we have already seen a use for tar in chapter 21.0, we haven't explained how it works. This is what this section is here for. As for find, tar is a long standing Unix utility, and as such its sytax is a bit special. The syntax is:
$ tar [options] [files...]
Now, here is a list of options. Note that all of them have an equivalent long option, but you will have to refer to the manual page for this as they won't be listed here. And of course, not all options will be listed either :)
Note: the initial dash (-) of short options is not now deprecated with tar, except after a long option.
c: This option is used in order to create new archives. x: This option is used in order to extract files from an existing archive. t: List files from an existing archive. v: This will simply list the files are they are added to an archive or extracted from an archive, or, in conjunction with the t option (see above), it outputs a long listing of file instead of a short one. f <file>: Create archive with name <file>, extract from archive <file> or list files from archive <file>. If this parameter is not given, the default file will be /dev/rmt0, which is generally the special file associated to a streamer. If the file parameter is - (a dash), the input or output (depending on whether you create an archive or extract from one) will be associated to the standard input or standard output. z: Tells tar that the archive to create should be compressed with gzip, or that the archive to extract from is compressed with gzip. y: Same as z, but the program used for compression is bzip2. p: When extracting files from an archive, preserve all file attributes, including ownership, last access time and so on. Very useful for filesystem dumps. r: Append the list of files given on the command line to an existing archive. Note that the archive to which you want to append files should not be compressed! A: Append archives given on the command line to the one submitted with the f option. Similarly to r, the archives should not be compressed in order for this to work.
There are many, many, many other options, you may want to refer to the tar(1) for a whole list. See, for example, the d option. Now, on for a little practice. Say you want to create an archive of all images in /shared/images, compressed with bzip2, named images.tar.bz2 and located in your home directory. You will then type:
## Note: you must be in the directory from which# you want to archive files!
# $ cd /shared $ tar cyf ~/images.tar.bz2 images/
As you can see, we have used three options here: c told tar that we wanted to create an archive, y told it that we wanted it compressed with bzip2, and f /images.tar.bz2 told it that the archive was to be created in our home directory, with name images.tar.bz2. We may want to check if the archive is valid now. We can just check this out by listing its files:
## Get back to our home directory# $ cd $ tar tyvf images.tar.bz2
Here, we told tar to list (t) files from archive images.tar.bz2 (f images.tar.bz2), warned that this archive was compressed with bzip2 (y), and that we wanted a long listing (v). Now, say you have erased the images directory. Fortunately, your archive is intact, and you now want to extract it back to its original place, in /shared. But as you don't want to break your find command for new images, you need to preserve all file attributes:
## cd to the directory where you want to extract# $ cd /shared $ tar yxpf ~/images.tar.bz2
And here you are!
Now, let's say you want to extract the directory images/cars from the archive, and nothing else. Then you can type this:
$ tar yxf ~/images.tar.bz2 images/cars
In case you would worry about this, don't: no, if you try to back up special files, tar will take them as what they are, special files, and will not dump their contents. So yes, you can safely put /dev/mem in an archive :) Oh, and it also deals correctly with links, so do not worry for this either. For symbolic links, also look at the h option in the manpage.
* McsEngl.LinxCmnd.tar,

tee::
Redirect output to multiple files
* McsEngl.LinxCmnd.tee,

test::
Evaluate a conditional expression
* McsEngl.LinxCmnd.test,

time::
Measure Program running time
* McsEngl.LinxCmnd.time,

times::
User and system times
* McsEngl.LinxCmnd.times,

touch::
Change file timestamps
* Initially, the touch command is not intended for creating files but for updating file access and modification times[3]. However, one of its side-effects is to create the files mentioned if they did not exist before. The syntax is:
touch [options] file [file...]
So running the command:
touch file1 images/file2
will create a file called file1 in the current directory and a file file2 in directory images.
* McsEngl.LinxCmnd.touch,

top::
List processes running on the system
* McsEngl.LinxCmnd.top,

traceroute::
Trace Route to Host
* McsEngl.LinxCmnd.traceroute,

trap::
Run a command when a signal is set(bourne)
* McsEngl.LinxCmnd.trap,

tr::
Translate, squeeze, and/or delete characters
* McsEngl.LinxCmnd.tr,

true::
Do nothing, successfully
* McsEngl.LinxCmnd.true,

tsort::
Topological sort
* McsEngl.LinxCmnd.tsort,

tty::
Print filename of terminal on stdin
* McsEngl.LinxCmnd.tty,

type::
Describe a command
* McsEngl.LinxCmnd.type,

ulimit::
Limit user resources
* McsEngl.LinxCmnd.ulimit,

umask::
Users file creation mask
* McsEngl.LinxCmnd.umask,

umount::
Unmount a device
* The syntax is simple:
umount <mounting point|device>
So, to unmount our new partition, we can type:
$ umount /mnt
or else:
$ umount /dev/hdb1
* McsEngl.LinxCmnd.umount,
* McsEngl.LinxCmnd.unmount,

unalias::
Remove an alias
* McsEngl.LinxCmnd.unalias,

uname::
Print system information
* McsEngl.LinxCmnd.uname,

unexpand::
Convert spaces to tabs
* McsEngl.LinxCmnd.unexpand,

uniq::
Uniquify files
* McsEngl.LinxCmnd.uniq,

units::
Convert units from one scale to another
* McsEngl.LinxCmnd.units,

unset::
Remove variable or function names
* McsEngl.LinxCmnd.unset,

unshar::
Unpack shell archive scripts
* McsEngl.LinxCmnd.unshar,

until::
Execute commands (until error)
* McsEngl.LinxCmnd.until,

uptime::
Show uptime
* McsEngl.LinxCmnd.uptime,

useradd::
Create new user account
* McsEngl.LinxCmnd.useradd,

userdel::
Delete a user account
* McsEngl.LinxCmnd.userdel,

usermod::
Modify user account
* McsEngl.LinxCmnd.usermod,

users::
List users currently logged in
* McsEngl.LinxCmnd.users,

uuencode::
Encode a binary file
* McsEngl.LinxCmnd.uuencode,

uudecode::
Decode a file created by uuencode
* McsEngl.LinxCmnd.uudecode,

v::
Verbosely list directory contents (`ls -l -b')
* McsEngl.LinxCmnd.v,

vdir::
Verbosely list directory contents (`ls -l -b')
* McsEngl.LinxCmnd.vdir,

vi::
Text Editor
* McsEngl.LinxCmnd.vi,

vmstat::
Report virtual memory statistics
* McsEngl.LinxCmnd.vmstat,

wait::
Wait for a process to complete
* McsEngl.LinxCmnd.wait,

watch::
Execute/display a program periodically
* McsEngl.LinxCmnd.watch,

wc::
Print byte, word, and line counts
* McsEngl.LinxCmnd.wc,

whereis::
Search the user's $path, man pages and source files for a program
* McsEngl.LinxCmnd.whereis,

which::
Search the user's $path for a program file
* McsEngl.LinxCmnd.which,

while::
Execute commands
* McsEngl.LinxCmnd.while,

who::
Print all usernames currently logged in
* McsEngl.LinxCmnd.who,

whoami::
Print the current user id and name (`id -un')
* McsEngl.LinxCmnd.whoami,

wget::
Retrieve web pages or files via HTTP, HTTPS or FTP
* McsEngl.LinxCmnd.wget,

write::
Send a message to another user
* McsEngl.LinxCmnd.write,

xargs::
Execute utility, passing constructed argument list(s)
* McsEngl.LinxCmnd.xargs,

xdg-open::
Open a file or URL in the user's preferred application.
* McsEngl.LinxCmnd.xdg-open,

yes::
Print a string until interrupted
* McsEngl.LinxCmnd.yes,

.::
Run a command script in the current shell
* McsEngl.LinxCmnd..,

!!::
Run the last command again
* McsEngl.LinxCmnd.!!,

###::
Comment / Remark
* McsEngl.LinxCmnd.###,

view-file::
Here are the most common and useful ways to view the contents of a file in Linux, from simplest to most powerful:
| `cat filename` | Small to medium files | Displays the entire file at once |
| `less filename` | Large files, scrolling | View file with scrolling (press `q` to quit) |
| `more filename` | Large files (older systems) | Similar to less, but more limited |
| `head filename` | First few lines | Shows first 10 lines by default |
| `tail filename` | Last few lines, logs | Shows last 10 lines by default |
* McsEngl.LinxCmnd.view-file,

name::
* McsEngl.LinxCmnd!=command-of-Linux,
* McsEngl.LinxOs'command!⇒LinxCmnd,

info-resource of appVideo

name::
* McsEngl.appVideo'InfRsc,

description::
* https://en.wikipedia.org/wiki/Comparison_of_web_conferencing_software,

info-resource of pgmTranspiler

description::
* {2020-06-10}-https://tomassetti.me/how-to-write-a-transpiler/,

name::
* McsEngl.prgmTranspiler'InfRsc,