From 20ddbcbba94a147b85a944b3edf7eb6db4efbfc6 Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Fri, 31 Jul 2015 00:21:20 +0200 Subject: [PATCH 01/26] Initial Commit - table of contents --- README-de.md | 488 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 488 insertions(+) create mode 100644 README-de.md diff --git a/README-de.md b/README-de.md new file mode 100644 index 0000000..ecfd3b7 --- /dev/null +++ b/README-de.md @@ -0,0 +1,488 @@ +[ Languages: [English](README.md), [Español](README-es.md), [한국어](README-ko.md), [Português](README-pt.md), [Русский](README-ru.md), [Slovenščina](README-sl.md), [中文](README-zh.md), [German](README-de.md) ] + + +# The Art of Command Line + +[![Join the chat at https://gitter.im/jlevy/the-art-of-command-line](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/jlevy/the-art-of-command-line?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + +- [Kurzbeschreibung](#meta) +- [Grundlagen](#basics) +- [Täglicher Gebrauch](#everyday-use) +- [Umgang mit Dateien und Daten](#processing-files-and-data) +- [Fehlerbehebung auf Systemebene](#system-debugging) +- [Einzeiler](#one-liners) +- [Eigenartig aber hilfreich](#obscure-but-useful) +- [Nur MacOS X](#macos-x-only) +- [Weitere Quellen](#more-resources) +- [Haftungsausschluss](#disclaimer) + + +![curl -s 'https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README.md' | egrep -o '`\w+`' | tr -d '`' | cowsay -W50](cowsay.png) + +Fluency on the command line is a skill often neglected or considered arcane, but it improves your flexibility and productivity as an engineer in both obvious and subtle ways. This is a selection of notes and tips on using the command-line that I've found useful when working on Linux. Some tips are elementary, and some are fairly specific, sophisticated, or obscure. This page is not long, but if you can use and recall all the items here, you know a lot. + +Much of this +[originally](http://www.quora.com/What-are-some-lesser-known-but-useful-Unix-commands) +[appeared](http://www.quora.com/What-are-the-most-useful-Swiss-army-knife-one-liners-on-Unix) +on [Quora](http://www.quora.com/What-are-some-time-saving-tips-that-every-Linux-user-should-know), +but given the interest there, it seems it's worth using Github, where people more talented than I can readily suggest improvements. If you see an error or something that could be better, please submit an issue or PR! (Of course please review the meta section and existing PRs/issues first.) + + +## Meta + +Scope: + +- This guide is both for beginners and the experienced. The goals are *breadth* (everything important), *specificity* (give concrete examples of the most common case), and *brevity* (avoid things that aren't essential or digressions you can easily look up elsewhere). Every tip is essential in some situation or significantly saves time over alternatives. +- This is written for Linux, with the exception of the "[MacOS X only](#macos-x-only)" section. Many of the other items apply or can be installed on other Unices or MacOS (or even Cygwin). +- The focus is on interactive Bash, though many tips apply to other shells and to general Bash scripting. +- It includes both "standard" Unix commands as well as ones that require special package installs -- so long as they are important enough to merit inclusion. + +Notes: + +- To keep this to one page, content is implicitly included by reference. You're smart enough to look up more detail elsewhere once you know the idea or command to Google. Use `apt-get`/`yum`/`dnf`/`pacman`/`pip`/`brew` (as appropriate) to install new programs. +- Use [Explainshell](http://explainshell.com/) to get a helpful breakdown of what commands, options, pipes etc. do. + + +## Basics + +- Learn basic Bash. Actually, type `man bash` and at least skim the whole thing; it's pretty easy to follow and not that long. Alternate shells can be nice, but Bash is powerful and always available (learning *only* zsh, fish, etc., while tempting on your own laptop, restricts you in many situations, such as using existing servers). + +- Learn at least one text-based editor well. Ideally Vim (`vi`), as there's really no competition for random editing in a terminal (even if you use Emacs, a big IDE, or a modern hipster editor most of the time). + +- Know how to read documentation with `man` (for the inquisitive, `man man` lists the section numbers, e.g. 1 is "regular" commands, 5 is files/conventions, and 8 are for administration). Find man pages with `apropos`. Know that some commands are not executables, but Bash builtins, and that you can get help on them with `help` and `help -d`. + +- Learn about redirection of output and input using `>` and `<` and pipes using `|`. Know `>` overwrites the output file and `>>` appends. Learn about stdout and stderr. + +- Learn about file glob expansion with `*` (and perhaps `?` and `{`...`}`) and quoting and the difference between double `"` and single `'` quotes. (See more on variable expansion below.) + +- Be familiar with Bash job management: `&`, **ctrl-z**, **ctrl-c**, `jobs`, `fg`, `bg`, `kill`, etc. + +- Know `ssh`, and the basics of passwordless authentication, via `ssh-agent`, `ssh-add`, etc. + +- Basic file management: `ls` and `ls -l` (in particular, learn what every column in `ls -l` means), `less`, `head`, `tail` and `tail -f` (or even better, `less +F`), `ln` and `ln -s` (learn the differences and advantages of hard versus soft links), `chown`, `chmod`, `du` (for a quick summary of disk usage: `du -hs *`). For filesystem management, `df`, `mount`, `fdisk`, `mkfs`, `lsblk`. + +- Basic network management: `ip` or `ifconfig`, `dig`. + +- Know regular expressions well, and the various flags to `grep`/`egrep`. The `-i`, `-o`, `-v`, `-A`, `-B`, and `-C` options are worth knowing. + +- Learn to use `apt-get`, `yum`, `dnf` or `pacman` (depending on distro) to find and install packages. And make sure you have `pip` to install Python-based command-line tools (a few below are easiest to install via `pip`). + + +## Everyday use + +- In Bash, use **Tab** to complete arguments and **ctrl-r** to search through command history. + +- In Bash, use **ctrl-w** to delete the last word, and **ctrl-u** to delete all the way back to the start of the line. Use **alt-b** and **alt-f** to move by word, **ctrl-a** to move cursor to beginning of line, **ctrl-e** to move cursor to end of line, **ctrl-k** to kill to the end of the line, **ctrl-l** to clear the screen. See `man readline` for all the default keybindings in Bash. There are a lot. For example **alt-.** cycles through previous arguments, and **alt-*** expands a glob. + +- Alternatively, if you love vi-style key-bindings, use `set -o vi`. + +- To see recent commands, `history`. There are also many abbreviations such as `!$` (last argument) and `!!` last command, though these are often easily replaced with **ctrl-r** and **alt-.**. + +- To go back to the previous working directory: `cd -` + +- If you are halfway through typing a command but change your mind, hit **alt-#** to add a `#` at the beginning and enter it as a comment (or use **ctrl-a**, **#**, **enter**). You can then return to it later via command history. + +- Use `xargs` (or `parallel`). It's very powerful. Note you can control how many items execute per line (`-L`) as well as parallelism (`-P`). If you're not sure if it'll do the right thing, use `xargs echo` first. Also, `-I{}` is handy. Examples: +```bash + find . -name '*.py' | xargs grep some_function + cat hosts | xargs -I{} ssh root@{} hostname +``` + +- `pstree -p` is a helpful display of the process tree. + +- Use `pgrep` and `pkill` to find or signal processes by name (`-f` is helpful). + +- Know the various signals you can send processes. For example, to suspend a process, use `kill -STOP [pid]`. For the full list, see `man 7 signal` + +- Use `nohup` or `disown` if you want a background process to keep running forever. + +- Check what processes are listening via `netstat -lntp` or `ss -plat` (for TCP; add `-u` for UDP). + +- See also `lsof` for open sockets and files. + +- See `uptime` or `w` to know the how long the system has been running. + +- Use `alias` to create shortcuts for commonly used commands. For example, `alias ll='ls -latr'` creates a new alias `ll`. + +- In Bash scripts, use `set -x` for debugging output. Use strict modes whenever possible. Use `set -e` to abort on errors. Use `set -o pipefail` as well, to be strict about errors (though this topic is a bit subtle). For more involved scripts, also use `trap`. + +- In Bash scripts, subshells (written with parentheses) are convenient ways to group commands. A common example is to temporarily move to a different working directory, e.g. +```bash + # do something in current dir + (cd /some/other/dir && other-command) + # continue in original dir +``` + +- In Bash, note there are lots of kinds of variable expansion. Checking a variable exists: `${name:?error message}`. For example, if a Bash script requires a single argument, just write `input_file=${1:?usage: $0 input_file}`. Arithmetic expansion: `i=$(( (i + 1) % 5 ))`. Sequences: `{1..10}`. Trimming of strings: `${var%suffix}` and `${var#prefix}`. For example if `var=foo.pdf`, then `echo ${var%.pdf}.txt` prints `foo.txt`. + +- The output of a command can be treated like a file via `<(some command)`. For example, compare local `/etc/hosts` with a remote one: +```sh + diff /etc/hosts <(ssh somehost cat /etc/hosts) +``` + +- Know about "here documents" in Bash, as in `cat <logfile 2>&1`. Often, to ensure a command does not leave an open file handle to standard input, tying it to the terminal you are in, it is also good practice to add ` foo: + rename 's/\.bak$//' *.bak + # Full rename of filenames, directories, and contents foo -> bar: + repren --full --preserve-case --from foo --to bar . +``` + +- Use `shuf` to shuffle or select random lines from a file. + +- Know `sort`'s options. For numbers, use `-n`, or `-h` for handling human-readable numbers (e.g. from `du -h`). Know how keys work (`-t` and `-k`). In particular, watch out that you need to write `-k1,1` to sort by only the first field; `-k1` means sort according to the whole line. Stable sort (`sort -s`) can be useful. For example, to sort first by field 2, then secondarily by field 1, you can use `sort -k1,1 | sort -s -k2,2`. + +- If you ever need to write a tab literal in a command line in Bash (e.g. for the -t argument to sort), press **ctrl-v** **[Tab]** or write `$'\t'` (the latter is better as you can copy/paste it). + +- The standard tools for patching source code are `diff` and `patch`. See also `diffstat` for summary statistics of a diff. Note `diff -r` works for entire directories. Use `diff -r tree1 tree2 | diffstat` for a summary of changes. + +- For binary files, use `hd` for simple hex dumps and `bvi` for binary editing. + +- Also for binary files, `strings` (plus `grep`, etc.) lets you find bits of text. + +- For binary diffs (delta compression), use `xdelta3`. + +- To convert text encodings, try `iconv`. Or `uconv` for more advanced use; it supports some advanced Unicode things. For example, this command lowercases and removes all accents (by expanding and dropping them): +```sh + uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt +``` + +- To split files into pieces, see `split` (to split by size) and `csplit` (to split by a pattern). + +- Use `zless`, `zmore`, `zcat`, and `zgrep` to operate on compressed files. + + +## System debugging + +- For web debugging, `curl` and `curl -I` are handy, or their `wget` equivalents, or the more modern [`httpie`](https://github.com/jakubroztocil/httpie). + +- To know disk/cpu/network status, use `iostat`, `netstat`, `top` (or the better `htop`), and (especially) `dstat`. Good for getting a quick idea of what's happening on a system. + +- For a more in-depth system overview, use [`glances`](https://github.com/nicolargo/glances). It presents you with several system level statistics in one terminal window. Very helpful for quickly checking on various subsystems. + +- To know memory status, run and understand the output of `free` and `vmstat`. In particular, be aware the "cached" value is memory held by the Linux kernel as file cache, so effectively counts toward the "free" value. + +- Java system debugging is a different kettle of fish, but a simple trick on Oracle's and some other JVMs is that you can run `kill -3 ` and a full stack trace and heap summary (including generational garbage collection details, which can be highly informative) will be dumped to stderr/logs. The JDK's `jps`, `jstat`, `jstack`, `jmap` are useful. [SJK tools](https://github.com/aragozin/jvm-tools) are more advanced. + +- Use `mtr` as a better traceroute, to identify network issues. + +- For looking at why a disk is full, `ncdu` saves time over the usual commands like `du -sh *`. + +- To find which socket or process is using bandwidth, try `iftop` or `nethogs`. + +- The `ab` tool (comes with Apache) is helpful for quick-and-dirty checking of web server performance. For more complex load testing, try `siege`. + +- For more serious network debugging, `wireshark`, `tshark`, or `ngrep`. + +- Know about `strace` and `ltrace`. These can be helpful if a program is failing, hanging, or crashing, and you don't know why, or if you want to get a general idea of performance. Note the profiling option (`-c`), and the ability to attach to a running process (`-p`). + +- Know about `ldd` to check shared libraries etc. + +- Know how to connect to a running process with `gdb` and get its stack traces. + +- Use `/proc`. It's amazingly helpful sometimes when debugging live problems. Examples: `/proc/cpuinfo`, `/proc/meminfo`, `/proc/cmdline`, `/proc/xxx/cwd`, `/proc/xxx/exe`, `/proc/xxx/fd/`, `/proc/xxx/smaps` (where `xxx` is the process id or pid). + +- When debugging why something went wrong in the past, `sar` can be very helpful. It shows historic statistics on CPU, memory, network, etc. + +- For deeper systems and performance analyses, look at `stap` ([SystemTap](https://sourceware.org/systemtap/wiki)), [`perf`](http://en.wikipedia.org/wiki/Perf_(Linux)), and [`sysdig`](https://github.com/draios/sysdig). + +- Check what OS you're on with `uname` or `uname -a` (general Unix/kernel info) or `lsb_release -a` (Linux distro info). + +- Use `dmesg` whenever something's acting really funny (it could be hardware or driver issues). + + +## One-liners + +A few examples of piecing together commands: + +- It is remarkably helpful sometimes that you can do set intersection, union, and difference of text files via `sort`/`uniq`. Suppose `a` and `b` are text files that are already uniqued. This is fast, and works on files of arbitrary size, up to many gigabytes. (Sort is not limited by memory, though you may need to use the `-T` option if `/tmp` is on a small root partition.) See also the note about `LC_ALL` above and `sort`'s `-u` option (left out for clarity below). +```sh + cat a b | sort | uniq > c # c is a union b + cat a b | sort | uniq -d > c # c is a intersect b + cat a b b | sort | uniq -u > c # c is set difference a - b +``` + +- Use `grep . *` to visually examine all contents of all files in a directory, e.g. for directories filled with config settings, like `/sys`, `/proc`, `/etc`. + + +- Summing all numbers in the third column of a text file (this is probably 3X faster and 3X less code than equivalent Python): +```sh + awk '{ x += $3 } END { print x }' myfile +``` + +- If want to see sizes/dates on a tree of files, this is like a recursive `ls -l` but is easier to read than `ls -lR`: +```sh + find . -type f -ls +``` + +- Say you have a text file, like a web server log, and a certain value that appears on some lines, such as an `acct_id` parameter that is present in the URL. If you want a tally of how many requests for each `acct_id`: +```sh + cat access.log | egrep -o 'acct_id=[0-9]+' | cut -d= -f2 | sort | uniq -c | sort -rn +``` + +- To continuously monitor changes, use `watch`, e.g. check changes to files in a directory with `watch -d -n 2 'ls -rtlh | tail'` or to network settings while troubleshooting your wifi settings with `watch -d -n 2 ifconfig`. + +- Run this function to get a random tip from this document (parses Markdown and extracts an item): +```sh + function taocl() { + curl -s https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README.md | + pandoc -f markdown -t html | + xmlstarlet fo --html --dropdtd | + xmlstarlet sel -t -v "(html/body/ul/li[count(p)>0])[$RANDOM mod last()+1]" | + xmlstarlet unesc | fmt -80 + } +``` + + +## Obscure but useful + +- `expr`: perform arithmetic or boolean operations or evaluate regular expressions + +- `m4`: simple macro processor + +- `yes`: print a string a lot + +- `cal`: nice calendar + +- `env`: run a command (useful in scripts) + +- `printenv`: print out environment variables (useful in debugging and scripts) + +- `look`: find English words (or lines in a file) beginning with a string + +- `cut`, `paste` and `join`: data manipulation + +- `fmt`: format text paragraphs + +- `pr`: format text into pages/columns + +- `fold`: wrap lines of text + +- `column`: format text fields into aligned, fixed-width columns or tables + +- `expand` and `unexpand`: convert between tabs and spaces + +- `nl`: add line numbers + +- `seq`: print numbers + +- `bc`: calculator + +- `factor`: factor integers + +- [`gpg`](https://gnupg.org/): encrypt and sign files + +- `toe`: table of terminfo entries + +- `nc`: network debugging and data transfer + +- `socat`: socket relay and tcp port forwarder (similar to `netcat`) + +- [`slurm`](https://github.com/mattthias/slurm): network trafic visualization + +- `dd`: moving data between files or devices + +- `file`: identify type of a file + +- `tree`: display directories and subdirectories as a nesting tree; like `ls` but recursive + +- `stat`: file info + +- `time`: execute and time a command + +- `watch`: run a command repeatedly, showing results and/or highlighting changes + +- `tac`: print files in reverse + +- `shuf`: random selection of lines from a file + +- `comm`: compare sorted files line by line + +- `pv`: monitor the progress of data through a pipe + +- `hd` and `bvi`: dump or edit binary files + +- `strings`: extract text from binary files + +- `tr`: character translation or manipulation + +- `iconv` or `uconv`: conversion for text encodings + +- `split` and `csplit`: splitting files + +- `sponge`: read all input before writing it, useful for reading from then writing to the same file, e.g., `grep -v something some-file | sponge some-file` + +- `units`: unit conversions and calculations; converts furlongs per fortnight to twips per blink (see also `/usr/share/units/definitions.units`) + +- `7z`: high-ratio file compression + +- `ldd`: dynamic library info + +- `nm`: symbols from object files + +- `ab`: benchmarking web servers + +- `strace`: system call debugging + +- `mtr`: better traceroute for network debugging + +- `cssh`: visual concurrent shell + +- `rsync`: sync files and folders over SSH or in local file system + +- `wireshark` and `tshark`: packet capture and network debugging + +- `ngrep`: grep for the network layer + +- `host` and `dig`: DNS lookups + +- `lsof`: process file descriptor and socket info + +- `dstat`: useful system stats + +- [`glances`](https://github.com/nicolargo/glances): high level, multi-subsystem overview + +- `iostat`: Disk usage stats + +- `mpstat`: CPU usage stats + +- `vmstat`: Memory usage stats + +- `htop`: improved version of top + +- `last`: login history + +- `w`: who's logged on + +- `id`: user/group identity info + +- `sar`: historic system stats + +- `iftop` or `nethogs`: network utilization by socket or process + +- `ss`: socket statistics + +- `dmesg`: boot and system error messages + +- `sysctl`: view and configure Linux kernel parameters at run time + +- `hdparm`: SATA/ATA disk manipulation/performance + +- `lsb_release`: Linux distribution info + +- `lsblk`: list block devices: a tree view of your disks and disk paritions + +- `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: hardware information, including CPU, BIOS, RAID, graphics, devices, etc. + +- `lsmod` and `modifno`: List and show details of kernel modules. + +- `fortune`, `ddate`, and `sl`: um, well, it depends on whether you consider steam locomotives and Zippy quotations "useful" + + +## MacOS X only + +These are items relevant *only* on MacOS. + +- Package management with `brew` (Homebrew) and/or `port` (MacPorts). These can be used to install on MacOS many of the above commands. + +- Copy output of any command to a desktop app with `pbcopy` and paste input from one with `pbpaste`. + +- To enable the Option key in Mac OS Terminal as an alt key (such as used in the commands above like **alt-b**, **alt-f**, etc.), open Preferences -> Profiles -> Keyboard and select "Use Option as Meta key". + +- To open a file with a desktop app, use `open` or `open -a /Applications/Whatever.app`. + +- Spotlight: Search files with `mdfind` and list metadata (such as photo EXIF info) with `mdls`. + +- Be aware MacOS is based on BSD Unix, and many commands (for example `ps`, `ls`, `tail`, `awk`, `sed`) have many subtle variations from Linux, which is largely influenced by System V-style Unix and GNU tools. You can often tell the difference by noting a man page has the heading "BSD General Commands Manual." In some cases GNU versions can be installed, too (such as `gawk` and `gsed` for GNU awk and sed). If writing cross-platform Bash scripts, avoid such commands (for example, consider Python or `perl`) or test carefully. + + +## More resources + +- [awesome-shell](https://github.com/alebcay/awesome-shell): A curated list of shell tools and resources. +- [Strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/) for writing better shell scripts. +- [shellcheck](https://github.com/koalaman/shellcheck) - A shell script static analysis tool. Essentially, lint for bash/sh/zsh. + + +## Disclaimer + +With the exception of very small tasks, code is written so others can read it. With power comes responsibility. The fact you *can* do something in Bash doesn't necessarily mean you should! ;) + + +## License + +[![Creative Commons License](https://i.creativecommons.org/l/by-sa/4.0/88x31.png)](http://creativecommons.org/licenses/by-sa/4.0/) + +This work is licensed under a [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/). From d6fe2cbfe017586b27bd548e508f1bed1020dbab Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Fri, 31 Jul 2015 00:53:09 +0200 Subject: [PATCH 02/26] Finished introduction --- README-de.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/README-de.md b/README-de.md index ecfd3b7..6d1ee87 100644 --- a/README-de.md +++ b/README-de.md @@ -19,13 +19,13 @@ ![curl -s 'https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README.md' | egrep -o '`\w+`' | tr -d '`' | cowsay -W50](cowsay.png) -Fluency on the command line is a skill often neglected or considered arcane, but it improves your flexibility and productivity as an engineer in both obvious and subtle ways. This is a selection of notes and tips on using the command-line that I've found useful when working on Linux. Some tips are elementary, and some are fairly specific, sophisticated, or obscure. This page is not long, but if you can use and recall all the items here, you know a lot. +Der flüssige Umgang mit der Kommandozeile ist eine oft vernachlässigte oder als undurchsichtig empfundene Fähigkeit, steigert jedoch Flexibilität und Produktivität eines Informatikers auf offensichtliche als auch subtile Weise. Was folgt, ist eine Auswahl an Notizen und Tipps im Umgang mit der Kommandozeile, welche ich beim Arbeiten mit Linux zu schätzen gelernt habe. Manche dieser Hinweise beinhalten Grundwissen, andere sind sehr spezifisch, fortgeschritten oder auch eigenartig. Die Seite ist nicht lang, aber wenn du alle Punkte verstanden hast und anwenden kannst, weißt du eine ganze Menge. -Much of this -[originally](http://www.quora.com/What-are-some-lesser-known-but-useful-Unix-commands) -[appeared](http://www.quora.com/What-are-the-most-useful-Swiss-army-knife-one-liners-on-Unix) -on [Quora](http://www.quora.com/What-are-some-time-saving-tips-that-every-Linux-user-should-know), -but given the interest there, it seems it's worth using Github, where people more talented than I can readily suggest improvements. If you see an error or something that could be better, please submit an issue or PR! (Of course please review the meta section and existing PRs/issues first.) +Vieles davon +[erschien](http://www.quora.com/What-are-the-most-useful-Swiss-army-knife-one-liners-on-Unix) +[ursprünglich](http://www.quora.com/What-are-some-lesser-known-but-useful-Unix-commands) +auf [Quora](http://www.quora.com/What-are-some-time-saving-tips-that-every-Linux-user-should-know), +aber angesichts des Interesses scheint es vielversprechend, Github zu nutzen, wo talentiertere Menschen als ich es bin kontinuierlich Verbesserungen vorschlagen können. Wenn du einen Fehler entdeckst oder etwas, das man besser machen könnte, erstelle ein Issue oder einen PR! (Lies aber bitte zuerst die Kurzbeschreibung und überprüfe bereits vorhandene Issues/PRs.) ## Meta From 07a3c00211485d12e207014408b822cf6fa027cc Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Fri, 31 Jul 2015 13:10:23 +0200 Subject: [PATCH 03/26] Finished meta --- README-de.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/README-de.md b/README-de.md index 6d1ee87..6401f94 100644 --- a/README-de.md +++ b/README-de.md @@ -28,19 +28,19 @@ auf [Quora](http://www.quora.com/What-are-some-time-saving-tips-that-every-Linux aber angesichts des Interesses scheint es vielversprechend, Github zu nutzen, wo talentiertere Menschen als ich es bin kontinuierlich Verbesserungen vorschlagen können. Wenn du einen Fehler entdeckst oder etwas, das man besser machen könnte, erstelle ein Issue oder einen PR! (Lies aber bitte zuerst die Kurzbeschreibung und überprüfe bereits vorhandene Issues/PRs.) -## Meta +## Kurzbeschreibung -Scope: +Umfang: -- This guide is both for beginners and the experienced. The goals are *breadth* (everything important), *specificity* (give concrete examples of the most common case), and *brevity* (avoid things that aren't essential or digressions you can easily look up elsewhere). Every tip is essential in some situation or significantly saves time over alternatives. -- This is written for Linux, with the exception of the "[MacOS X only](#macos-x-only)" section. Many of the other items apply or can be installed on other Unices or MacOS (or even Cygwin). -- The focus is on interactive Bash, though many tips apply to other shells and to general Bash scripting. -- It includes both "standard" Unix commands as well as ones that require special package installs -- so long as they are important enough to merit inclusion. +- Diese Anleitung richtet sich an Anfänger und Fortgeschrittene. Die Ziele sind The goals are *Breite* (alles ist wichtig), *Genauigkeit* (konkrete Beispiele für die gebräuchlichsten Anwendungsfälle) und *Knappheit* (Dinge, die nicht wesentlich sind oder leicht anderswo nachgeschlagen werden können, sollen vermieden werden). Jeder Tipp ist in einer bestimmten Situation wesentlich oder deutlich zeitsparend gegenüber bestehenden Alternativen. +- Sie ist für Linux geschrieben, mit der Ausnahme des Abschnitts "[Nur MacOS X](#macos-x-only)". Viele der anderen Punkte lassen sich nutzen oder sind installierbar auf anderen Unices oder MacOS (oder sogar Cygwin). +- Der Fokus liegt auf interaktiver Bash, allerdings gelten viele Tipps auch auf anderen Shells sowie für allgemeines Bash-Skripting. +- Sie beinhaltet sowohl "normale" Unix-Befehle als auch solche, die bestimmte installierte Pakete voaussetzen -- sofern sie wichtig genug sind, dass sie die Aufnahme in diese Anleitung verdienen. -Notes: +Hinweise: -- To keep this to one page, content is implicitly included by reference. You're smart enough to look up more detail elsewhere once you know the idea or command to Google. Use `apt-get`/`yum`/`dnf`/`pacman`/`pip`/`brew` (as appropriate) to install new programs. -- Use [Explainshell](http://explainshell.com/) to get a helpful breakdown of what commands, options, pipes etc. do. +- Um eine Seite nicht zu sprengen, ist ihr Inhalt durchgängig anhand von Verweisen aufgelistet. Du bist schlau genug, anderswo zusätzliche Informationen nachzuschlagen, sobald du die Idee bzw. den Befehl dahinter kennst. Benutze `apt-get`/`yum`/`dnf`/`pacman`/`pip`/`brew` (je nachdem), um neue Programme zu installieren. +- Nutze [Explainshell](http://explainshell.com/), um einen hilfreichen Einblick zu erhalten, was es mit Befehlen, Optionen, Pipes etc. auf sich hat. ## Basics From 17bf03c507cd4d3f5338ca2643aebcf75ee1a939 Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Sat, 1 Aug 2015 03:04:48 +0200 Subject: [PATCH 04/26] Finished basics --- README-de.md | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/README-de.md b/README-de.md index 6401f94..915ef3f 100644 --- a/README-de.md +++ b/README-de.md @@ -43,29 +43,29 @@ Hinweise: - Nutze [Explainshell](http://explainshell.com/), um einen hilfreichen Einblick zu erhalten, was es mit Befehlen, Optionen, Pipes etc. auf sich hat. -## Basics +## Grundlagen -- Learn basic Bash. Actually, type `man bash` and at least skim the whole thing; it's pretty easy to follow and not that long. Alternate shells can be nice, but Bash is powerful and always available (learning *only* zsh, fish, etc., while tempting on your own laptop, restricts you in many situations, such as using existing servers). +- Lerne einfache Bash. Tatsächlich, gib `man bash` ein und überfliege das Ganze zumindest; es ist leicht zu verstehen und nicht allzu lang. Alternative Shells sind nett, aber Bash ist mächtig und immer verfügbar (*nur* zsh, fish, etc. zu lernen ist auf dem eigenen Laptop vielleicht reizvoll, beschränkt jedoch deine Möglichkeiten in vielerlei Hinsicht, etwa beim Arbeiten mit bestehenden Servern). -- Learn at least one text-based editor well. Ideally Vim (`vi`), as there's really no competition for random editing in a terminal (even if you use Emacs, a big IDE, or a modern hipster editor most of the time). +- Lerne mindestens einen Text-basierten Editor zu benutzen. Idealerweise Vim (`vi`), da es letztlich keinen vergleichbaren Mitbewerber für gelegentliche Einsätze in einem Terminal gibt (selbst dann, wenn man eine große Entwicklungsumgebung wie Emacs oder die meiste Zeit einen modernen Hipster-Editor benutzt). -- Know how to read documentation with `man` (for the inquisitive, `man man` lists the section numbers, e.g. 1 is "regular" commands, 5 is files/conventions, and 8 are for administration). Find man pages with `apropos`. Know that some commands are not executables, but Bash builtins, and that you can get help on them with `help` and `help -d`. +- Wisse, wie man Dokumentationen mit `man` liest (für Neugierige, `man man` listet Abschnittsnummern, bspw. stehen unter 1 "reguläre" Befehle, 5 beinhaltet Dateien/Konventionen und unter 8 solche zur Rechnerverwaltung). Finde man-Seiten mit `apropos`. Wisse, dass manche Befehle keine ausführbaren Dateien, sondern Bash-Builtins sind, und dass du Hilfe zu diesen mit `help` und `help -d` erhälst. -- Learn about redirection of output and input using `>` and `<` and pipes using `|`. Know `>` overwrites the output file and `>>` appends. Learn about stdout and stderr. +- Lerne etwas über die Umleitung von Ein- und Ausgaben per `>` und `<` sowie `|` für Pipes. Wisse, dass `>` die Ausgabedatei überschreibt und `>>` etwas anhängt. Lerne etwas über stdout und stderr. -- Learn about file glob expansion with `*` (and perhaps `?` and `{`...`}`) and quoting and the difference between double `"` and single `'` quotes. (See more on variable expansion below.) +- Lerne etwas über die Dateinamenerweiterung mittels `*` (und möglicherweise `?` und `{`...`}`) sowie Anführungszeichen, etwa den Unterschied zwischen doppelten `"` und einfachen `'`. (Mehr zur Variablenerweiterung findest du unten.) -- Be familiar with Bash job management: `&`, **ctrl-z**, **ctrl-c**, `jobs`, `fg`, `bg`, `kill`, etc. +- Sei vertraut mit Bash-Jobmanagement: `&`, **ctrl-z**, **ctrl-c**, `jobs`, `fg`, `bg`, `kill`, etc. -- Know `ssh`, and the basics of passwordless authentication, via `ssh-agent`, `ssh-add`, etc. +- Kenne `ssh` und die Grundlagen passwortloser Authentifizierung mittels `ssh-agent`, `ssh-add`, etc. -- Basic file management: `ls` and `ls -l` (in particular, learn what every column in `ls -l` means), `less`, `head`, `tail` and `tail -f` (or even better, `less +F`), `ln` and `ln -s` (learn the differences and advantages of hard versus soft links), `chown`, `chmod`, `du` (for a quick summary of disk usage: `du -hs *`). For filesystem management, `df`, `mount`, `fdisk`, `mkfs`, `lsblk`. +- Grundlegende Dateiverwaltung: `ls` and `ls -l` (und spezieller, lerne die Funktion jeder einzelnen Spalte von `ls -l` kennen), `less`, `head`, `tail` und `tail -f` (oder noch besser, `less +F`), `ln` und `ln -s` (lerne die Unterschiede und Vorteile von Hard- und Softlinks), `chown`, `chmod`, `du` (für eine Kurzzusammenfassung der Festplattenbelegung: `du -hs *`). Für Dateisystemmanagement, `df`, `mount`, `fdisk`, `mkfs`, `lsblk`. -- Basic network management: `ip` or `ifconfig`, `dig`. +- Grundlagen der Netzwerkverwaltung: `ip` oder `ifconfig`, `dig`. -- Know regular expressions well, and the various flags to `grep`/`egrep`. The `-i`, `-o`, `-v`, `-A`, `-B`, and `-C` options are worth knowing. +- Kenne reguläre Ausdrücke gut, und die verschiedenen Statusindikatoren zu `grep`/`egrep`. Die Optionen `-i`, `-o`, `-v`, `-A`, `-B`, und `-C` sind gut zu wissen. -- Learn to use `apt-get`, `yum`, `dnf` or `pacman` (depending on distro) to find and install packages. And make sure you have `pip` to install Python-based command-line tools (a few below are easiest to install via `pip`). +- Lerne den Umgang mit `apt-get`, `yum`, `dnf` oder `pacman` (je nach Distribution), um Pakete zu finden bzw. zu installieren. Und stell sicher, dass du `pip` hast, um Python-basierte Kommandozeilen-Tools nutzen zu können (einige der untenstehenden werden am einfachsten über `pip` installiert). ## Everyday use From 73874dfc5a94b4da235c08f0e2f1fe726d50f57b Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Sun, 2 Aug 2015 00:19:12 +0200 Subject: [PATCH 05/26] Halfway through everyday use --- README-de.md | 50 +++++++++++++++++++++++++------------------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/README-de.md b/README-de.md index 915ef3f..1a32b36 100644 --- a/README-de.md +++ b/README-de.md @@ -39,8 +39,8 @@ Umfang: Hinweise: -- Um eine Seite nicht zu sprengen, ist ihr Inhalt durchgängig anhand von Verweisen aufgelistet. Du bist schlau genug, anderswo zusätzliche Informationen nachzuschlagen, sobald du die Idee bzw. den Befehl dahinter kennst. Benutze `apt-get`/`yum`/`dnf`/`pacman`/`pip`/`brew` (je nachdem), um neue Programme zu installieren. -- Nutze [Explainshell](http://explainshell.com/), um einen hilfreichen Einblick zu erhalten, was es mit Befehlen, Optionen, Pipes etc. auf sich hat. +- Um eine Seite nicht zu sprengen, ist ihr Inhalt durchgängig anhand von Verweisen aufgelistet. Du bist schlau genug, anderswo zusätzliche Informationen nachzuschlagen, sobald du die Idee bzw. den Befehl dahinter kennst. Verwende `apt-get`/`yum`/`dnf`/`pacman`/`pip`/`brew` (je nachdem), um neue Programme zu installieren. +- Verwende [Explainshell](http://explainshell.com/), um einen hilfreichen Einblick zu erhalten, was es mit Befehlen, Optionen, Pipes etc. auf sich hat. ## Grundlagen @@ -53,9 +53,9 @@ Hinweise: - Lerne etwas über die Umleitung von Ein- und Ausgaben per `>` und `<` sowie `|` für Pipes. Wisse, dass `>` die Ausgabedatei überschreibt und `>>` etwas anhängt. Lerne etwas über stdout und stderr. -- Lerne etwas über die Dateinamenerweiterung mittels `*` (und möglicherweise `?` und `{`...`}`) sowie Anführungszeichen, etwa den Unterschied zwischen doppelten `"` und einfachen `'`. (Mehr zur Variablenerweiterung findest du unten.) +- Lerne etwas über die Dateinamenerweiterung mittels `*` (und eventuell `?` und `{`...`}`) sowie Anführungszeichen, etwa den Unterschied zwischen doppelten `"` und einfachen `'`. (Mehr zur Variablenerweiterung findest du unten.) -- Sei vertraut mit Bash-Jobmanagement: `&`, **ctrl-z**, **ctrl-c**, `jobs`, `fg`, `bg`, `kill`, etc. +- Mach dich vertraut mit Bash-Jobmanagement: `&`, **ctrl-z**, **ctrl-c**, `jobs`, `fg`, `bg`, `kill`, etc. - Kenne `ssh` und die Grundlagen passwortloser Authentifizierung mittels `ssh-agent`, `ssh-add`, etc. @@ -68,49 +68,49 @@ Hinweise: - Lerne den Umgang mit `apt-get`, `yum`, `dnf` oder `pacman` (je nach Distribution), um Pakete zu finden bzw. zu installieren. Und stell sicher, dass du `pip` hast, um Python-basierte Kommandozeilen-Tools nutzen zu können (einige der untenstehenden werden am einfachsten über `pip` installiert). -## Everyday use +## Täglicher Gebrauch -- In Bash, use **Tab** to complete arguments and **ctrl-r** to search through command history. +- In Bash kannst du mit **Tab** Parameter vervollständigen und mit **ctrl-r** bereits benutzte Befehle durchsuchen. -- In Bash, use **ctrl-w** to delete the last word, and **ctrl-u** to delete all the way back to the start of the line. Use **alt-b** and **alt-f** to move by word, **ctrl-a** to move cursor to beginning of line, **ctrl-e** to move cursor to end of line, **ctrl-k** to kill to the end of the line, **ctrl-l** to clear the screen. See `man readline` for all the default keybindings in Bash. There are a lot. For example **alt-.** cycles through previous arguments, and **alt-*** expands a glob. +- In Bash kannst du mit **ctrl-w** das letzte Wort löschen und mit **ctrl-u** alles bis zum Anfang einer Zeile. Verwende **alt-b** und **alt-f**, um dich Wort für Wort fortzubewegen, springe mit **ctrl-a** zum Beginn einer Zeile, mit **ctrl-e** zum Ende einer Zeile, lösche mit **ctrl-k** alles bis zum Ende einer Zeile und bereinige mit **ctrl-l** den Bildschirm. Siehe `man readline` für alle voreingestellten Tastenbelegungen in Bash. Davon gibt's viele. Zum Beispiel **alt-.** wechselt durch vorherige Parameter und **alt-*** erweitert ein Suchmuster. -- Alternatively, if you love vi-style key-bindings, use `set -o vi`. +- Alternativ, falls du vi-artige Tastenbelegungen magst, verwende `set -o vi`. -- To see recent commands, `history`. There are also many abbreviations such as `!$` (last argument) and `!!` last command, though these are often easily replaced with **ctrl-r** and **alt-.**. +- Um kürzich genutzte Befehle zu sehen, `history`. Es gibt außerdem viele Abkürzungen wie etwa `!$` (letzter Parameter) und `!!` (letzter Befehl), wenngleich diese oft einfach ersetzt werden durch **ctrl-r** und **alt-.**. -- To go back to the previous working directory: `cd -` +- Um ins vorangegangene Arbeitsverzeichnis zu gelangen: `cd -` - If you are halfway through typing a command but change your mind, hit **alt-#** to add a `#` at the beginning and enter it as a comment (or use **ctrl-a**, **#**, **enter**). You can then return to it later via command history. -- Use `xargs` (or `parallel`). It's very powerful. Note you can control how many items execute per line (`-L`) as well as parallelism (`-P`). If you're not sure if it'll do the right thing, use `xargs echo` first. Also, `-I{}` is handy. Examples: +- Verwende `xargs` (oder `parallel`). Es ist sehr mächtig. Beachte, wie du viele Dinge pro Zeile (`-L`) als auch parallel (`-P`) ausführen kannst. Wenn du dir nicht sicher bist, ob das Richtige dabei herauskommt, verwende zunächst `xargs echo`. Außerdem ist`-I{}` nützlich. Beispiele: ```bash - find . -name '*.py' | xargs grep some_function + find . -name '*.py' | xargs grep irgendeine_funktion cat hosts | xargs -I{} ssh root@{} hostname ``` -- `pstree -p` is a helpful display of the process tree. +- `pstree -p` liefert eine hilfreiche Anzeige des Prozessbaums. -- Use `pgrep` and `pkill` to find or signal processes by name (`-f` is helpful). +- Verwende `pgrep` und `pkill`, um Prozesse anhand eines Namens zu finden oder festzustellen (`-f` ist hilfreich). -- Know the various signals you can send processes. For example, to suspend a process, use `kill -STOP [pid]`. For the full list, see `man 7 signal` +- Kenne die verschiedenen Signale, die du Prozessen senden kannst. Um einen Prozess etwa zu unterbrechen, verwende `kill -STOP [pid]`. Für die vollständige Liste, siehe `man 7 signal` -- Use `nohup` or `disown` if you want a background process to keep running forever. +- Verwende `nohup` oder `disown`, wenn du einen Hintergrundprozess für immer laufen lassen willst. -- Check what processes are listening via `netstat -lntp` or `ss -plat` (for TCP; add `-u` for UDP). +- Überprüfe mithörende Prozesse mit `netstat -lntp` oder `ss -plat` (für TCP; füge `-u` für UDP hinzu). -- See also `lsof` for open sockets and files. +- Siehe zudem `lsof` für offene Sockets und Dateien. -- See `uptime` or `w` to know the how long the system has been running. +- Siehe `uptime` oder `w`, um die laufende Betriebszeit des Systems zu erfahren, -- Use `alias` to create shortcuts for commonly used commands. For example, `alias ll='ls -latr'` creates a new alias `ll`. +- Verwende `alias`, um Verknüpfungen für gebräuchliche Befehle zu erstellen. So erstellt etwa `alias ll='ls -latr'` den neuen Alias `ll`. -- In Bash scripts, use `set -x` for debugging output. Use strict modes whenever possible. Use `set -e` to abort on errors. Use `set -o pipefail` as well, to be strict about errors (though this topic is a bit subtle). For more involved scripts, also use `trap`. +- Verwende in Bash-Skripts `set -x` zur Fehlerbehebung. Benutze strict modes wann immer möglich. Verwende `set -e` zum Abbruch bei Fehlern. Benutze `set -o pipefail` ebenfalls, um mit Fehlern präzise zu arbeiten (auch wenn dieses Thema etwas heikel ist). Verwende für etwas komplexere Skripte weiterhin `trap`. -- In Bash scripts, subshells (written with parentheses) are convenient ways to group commands. A common example is to temporarily move to a different working directory, e.g. +- In Bash-Skripts stellen Subshells (geschrieben in runden Klammern) einen praktischen Weg dar, Befehle zusammenzufassen. Ein gebräuchliches Beispiel ist die vorübergehende Arbeit in einem anderen Arbeitsverzeichnis: ```bash - # do something in current dir - (cd /some/other/dir && other-command) - # continue in original dir + # erledige etwas im aktuellen Verzeichnis + (cd /irgendein/anderes/verzeichnis && anderer-befehl) + # fahre fort im aktuellen Verzeichnis ``` - In Bash, note there are lots of kinds of variable expansion. Checking a variable exists: `${name:?error message}`. For example, if a Bash script requires a single argument, just write `input_file=${1:?usage: $0 input_file}`. Arithmetic expansion: `i=$(( (i + 1) % 5 ))`. Sequences: `{1..10}`. Trimming of strings: `${var%suffix}` and `${var#prefix}`. For example if `var=foo.pdf`, then `echo ${var%.pdf}.txt` prints `foo.txt`. From cdcc586614b4f89a5e866e89f448301d4ae95d25 Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Sun, 2 Aug 2015 01:09:18 +0200 Subject: [PATCH 06/26] Finished everyday use --- README-de.md | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/README-de.md b/README-de.md index 1a32b36..5f177a8 100644 --- a/README-de.md +++ b/README-de.md @@ -113,24 +113,24 @@ Hinweise: # fahre fort im aktuellen Verzeichnis ``` -- In Bash, note there are lots of kinds of variable expansion. Checking a variable exists: `${name:?error message}`. For example, if a Bash script requires a single argument, just write `input_file=${1:?usage: $0 input_file}`. Arithmetic expansion: `i=$(( (i + 1) % 5 ))`. Sequences: `{1..10}`. Trimming of strings: `${var%suffix}` and `${var#prefix}`. For example if `var=foo.pdf`, then `echo ${var%.pdf}.txt` prints `foo.txt`. +- Beachte, dass es in Bash viele Möglichkeiten gibt, Variablen zu erweitern. Überprüfen, ob eine Variable existiert: `${name:?error message}`.Wenn bspw. ein Bash-Skript nur einen einzelnen Parameter benötigt, schreibe einfach `input_file=${1:?usage: $0 input_file}`. Arithmetische Erweiterung: `i=$(( (i + 1) % 5 ))`. Sequenzen: `{1..10}`. Zeichenkette kürzen: `${var%suffix}` und `${var#prefix}`. Wenn bspw. `var=foo.pdf`, dann gibt `echo ${var%.pdf}.txt` die Ausgabe `foo.txt` aus. -- The output of a command can be treated like a file via `<(some command)`. For example, compare local `/etc/hosts` with a remote one: +- Die Ausgabe eines Befehls kann wie eine Datei behandelt werden mit `<(irgendein befehl)`. Das Vergleichen der lokalen `/etc/hosts` mit einer entfernten: ```sh - diff /etc/hosts <(ssh somehost cat /etc/hosts) + diff /etc/hosts <(ssh andererhost cat /etc/hosts) ``` -- Know about "here documents" in Bash, as in `cat <logfile 2>&1`. Often, to ensure a command does not leave an open file handle to standard input, tying it to the terminal you are in, it is also good practice to add `logfile 2>&1`. Oftmals ist es gute Praxis, einen Befehl an das verwendete Terminal zu binden, um keinen offenen Dateizugriff im standard input zu erzeugen, also ` Date: Thu, 20 Aug 2015 23:41:54 +0200 Subject: [PATCH 07/26] Halfway through processing files and data --- README-de.md | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/README-de.md b/README-de.md index 5f177a8..9c4d674 100644 --- a/README-de.md +++ b/README-de.md @@ -160,29 +160,29 @@ Hinweise: ## Umgang mit Dateien und Daten -- To locate a file by name in the current directory, `find . -iname '*something*'` (or similar). To find a file anywhere by name, use `locate something` (but bear in mind `updatedb` may not have indexed recently created files). +- Um eine Datei im aktuellen Verzeichnis anhand des Namens zu finden, `find . -iname '*irgendwas*'`. Um eine Datei unabhängig vom Verzeichnis anhand des Namens zu finden, verwende `locate irgendwas` (bedenke jedoch, dass `updatedb` kürzlich erstellte Datein möglicherweise noch nicht indexiert hat). -- For general searching through source or data files (more advanced than `grep -r`), use [`ag`](https://github.com/ggreer/the_silver_searcher). +- Für das allgemeine Durchsuchen von (Quell-)Dateien (fortgeschrttener als `grep -r`), verwende [`ag`](https://github.com/ggreer/the_silver_searcher). -- To convert HTML to text: `lynx -dump -stdin` +- Um HTML in Text zu konvertieren: `lynx -dump -stdin` -- For Markdown, HTML, and all kinds of document conversion, try [`pandoc`](http://pandoc.org/). +- Für Markdown, HTML und viele andere Dokumentkonvertieren, versuch's mit [`pandoc`](http://pandoc.org/). -- If you must handle XML, `xmlstarlet` is old but good. +- Wenn du mit XML arbeiten musst, `xmlstarlet` ist alt, aber gut. -- For JSON, use [`jq`](http://stedolan.github.io/jq/). +- Für JSON, verwende [`jq`](http://stedolan.github.io/jq/). -- For Excel or CSV files, [csvkit](https://github.com/onyxfish/csvkit) provides `in2csv`, `csvcut`, `csvjoin`, `csvgrep`, etc. +- Für Excel- bzw. CSV-Dateien hält [csvkit](https://github.com/onyxfish/csvkit) `in2csv`, `csvcut`, `csvjoin`, `csvgrep`, etc bereit. -- For Amazon S3, [`s3cmd`](https://github.com/s3tools/s3cmd) is convenient and [`s4cmd`](https://github.com/bloomreach/s4cmd) is faster. Amazon's [`aws`](https://github.com/aws/aws-cli) is essential for other AWS-related tasks. +- Für Amazon S3 ist [`s3cmd`](https://github.com/s3tools/s3cmd) praktisch und [`s4cmd`](https://github.com/bloomreach/s4cmd) schneller. Amazons [`aws`](https://github.com/aws/aws-cli) ist essentiell für andere AWS-bezogene Aufgaben. -- Know about `sort` and `uniq`, including uniq's `-u` and `-d` options -- see one-liners below. See also `comm`. +- Kenne `sort` und `uniq`, letzteres einschließlich der Optionen `-u` und `-d` -- siehe die Einzeiler unten. Siehe auch `comm`. -- Know about `cut`, `paste`, and `join` to manipulate text files. Many people use `cut` but forget about `join`. +- Kenne `cut`, `paste` und `join` zur Arbeit mit Textdateien. Viele Leute nutzen `cut`, vergessen aber `join`. -- Know about `wc` to count newlines (`-l`), characters (`-m`), words (`-w`) and bytes (`-c`). +- Kenne `wc`, um neue Zeilen (`-l`), Zeichen (`-m`), Wörter (`-w`) und Bytes (`-c`) zu zählen. -- Know about `tee` to copy from stdin to a file and also to stdout, as in `ls -al | tee file.txt`. +- Kenne `tee`, um von stdin in eine Datei und sogar nach stdout zu kopieren, wie etwa mit `ls -al | tee datei.txt`. - Know that locale affects a lot of command line tools in subtle ways, including sorting order (collation) and performance. Most Linux installations will set `LANG` or other locale variables to a local setting like US English. But be aware sorting will change if you change locale. And know i18n routines can make sort or other commands run *many times* slower. In some situations (such as the set operations or uniqueness operations below) you can safely ignore slow i18n routines entirely and use traditional byte-based sort order, using `export LC_ALL=C`. From 05ef3fa20b10d6e9f9445080161d444272d41321 Mon Sep 17 00:00:00 2001 From: Gernot Pointner Date: Wed, 6 Jan 2016 03:49:09 -0800 Subject: [PATCH 08/26] German translation for MacOS / Resources / Disclaimer / License --- README-de.md | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/README-de.md b/README-de.md index 9c4d674..8160c19 100644 --- a/README-de.md +++ b/README-de.md @@ -452,37 +452,37 @@ A few examples of piecing together commands: - `fortune`, `ddate`, and `sl`: um, well, it depends on whether you consider steam locomotives and Zippy quotations "useful" -## MacOS X only +## Nur MacOS X -These are items relevant *only* on MacOS. +Diese Hinweise sind *nur* für MacOS relevant. -- Package management with `brew` (Homebrew) and/or `port` (MacPorts). These can be used to install on MacOS many of the above commands. +- Paketverwaltung mit `brew` (Homebrew) und/oder `port` (MacPorts). Mit diesen Tools kann man viele der obrigen Programme für MacOs installieren. -- Copy output of any command to a desktop app with `pbcopy` and paste input from one with `pbpaste`. +- Kopiere die Ausgabe jedes Kommandos an eine Desktop App mit `pbcopy` und füge die Eingabe von einer solchen ein mit `pbpaste`. -- To enable the Option key in Mac OS Terminal as an alt key (such as used in the commands above like **alt-b**, **alt-f**, etc.), open Preferences -> Profiles -> Keyboard and select "Use Option as Meta key". +- Um die Option Taste als alt Taste in einer Mac OS Konsole zu nutzen (so wie in den obrigen Kommandos wie **alt-b**, **alt-f**, etc.), öffne Einstellungen -> Profile -> Tastatur und aktiviere + "Benutze Option Taste als Meta Taste" -- To open a file with a desktop app, use `open` or `open -a /Applications/Whatever.app`. +- Um eine Datei mit einer Desktopanwendung zu öffnen, kann man `open` oder `open -a /Applications/Whatever.app` benutzen. -- Spotlight: Search files with `mdfind` and list metadata (such as photo EXIF info) with `mdls`. +- Spotlight: Dateisuche mit `mdfind` und Ausgabe von Metadaten (wie z.B. photo EXIF info) mit `mdls`. -- Be aware MacOS is based on BSD Unix, and many commands (for example `ps`, `ls`, `tail`, `awk`, `sed`) have many subtle variations from Linux, which is largely influenced by System V-style Unix and GNU tools. You can often tell the difference by noting a man page has the heading "BSD General Commands Manual." In some cases GNU versions can be installed, too (such as `gawk` and `gsed` for GNU awk and sed). If writing cross-platform Bash scripts, avoid such commands (for example, consider Python or `perl`) or test carefully. +- Man sollte sich bewusst sein, dass MacOS auf BSD Unix basiert und sich viele Kommandos (wie z.B. `ps`, `ls`, `tail`, `awk`, `sed`) bezüglich subtiler Kleinigkeiten von Linux, dass stark von System V-style Unix und GNU tools beeinflusst ist, unterscheiden. Oft kann man den Unterschied daran erkennen, dass eine man page die Überschrift "BSD General Commands Manual" trägt. In manchen Fällen kann auch die GNU version installiert werden (wie z.B. bei `gawk` und `gsed` für GNU awk und sed). Falls man cross-platform Bash Skripte schreiben möchte, sollte man solche Kommandos vermeiden (und z.B. Python oder `perl` in Betracht ziehen) oder sorgfätig testen. +## Mehr Quellen -## More resources +- [awesome-shell](https://github.com/alebcay/awesome-shell): Eine hilfreiche Liste von Shell Werkzeugen und Quellen +- [Strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/) um bessere Shell Skripte zu schreiben +- [shellcheck](https://github.com/koalaman/shellcheck) - Ein statisches Analysetool für Shell Skripte. Im Grunde lint für bash/sh/zsh. -- [awesome-shell](https://github.com/alebcay/awesome-shell): A curated list of shell tools and resources. -- [Strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/) for writing better shell scripts. -- [shellcheck](https://github.com/koalaman/shellcheck) - A shell script static analysis tool. Essentially, lint for bash/sh/zsh. +## Haftungsausschluss -## Disclaimer +Mit der Ausnahme einiger sehr kleiner Aufgaben ist der Code so geschrieben, dass andere ihn lesen können. Mit Macht kommt Verantwortung. Die Tatsache etwas in Bash tuen zu *können*, heißt nicht +zwangsläufig, dass Du es tuen solltest! -With the exception of very small tasks, code is written so others can read it. With power comes responsibility. The fact you *can* do something in Bash doesn't necessarily mean you should! ;) - - -## License +## Lizenz [![Creative Commons License](https://i.creativecommons.org/l/by-sa/4.0/88x31.png)](http://creativecommons.org/licenses/by-sa/4.0/) -This work is licensed under a [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/). +Dieses Werk ist lizensiert gemäß der [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/). From dd474fa1757c8a2b16e17ec78518e7481c685dcb Mon Sep 17 00:00:00 2001 From: Gernot Pointner Date: Tue, 19 Jan 2016 15:53:27 +0100 Subject: [PATCH 09/26] German translation for obscure but useful --- README-de.md | 147 +++++++++++++++++++++++++-------------------------- 1 file changed, 73 insertions(+), 74 deletions(-) diff --git a/README-de.md b/README-de.md index 8160c19..029d6bc 100644 --- a/README-de.md +++ b/README-de.md @@ -65,7 +65,7 @@ Hinweise: - Kenne reguläre Ausdrücke gut, und die verschiedenen Statusindikatoren zu `grep`/`egrep`. Die Optionen `-i`, `-o`, `-v`, `-A`, `-B`, und `-C` sind gut zu wissen. -- Lerne den Umgang mit `apt-get`, `yum`, `dnf` oder `pacman` (je nach Distribution), um Pakete zu finden bzw. zu installieren. Und stell sicher, dass du `pip` hast, um Python-basierte Kommandozeilen-Tools nutzen zu können (einige der untenstehenden werden am einfachsten über `pip` installiert). +- Lerne den Umgang mit `apt-get`, `yum`, `dnf` oder `pacman` (je nach Distribution), um Pakete zu finden bzw. zu installieren. Und stell sicher, dass du `pip` hast, um Python-basierte Kommandozeilen-Werkzeuge nutzen zu können (einige der untenstehenden werden am einfachsten über `pip` installiert). ## Täglicher Gebrauch @@ -307,156 +307,155 @@ A few examples of piecing together commands: ``` -## Obscure but useful +## Obskur aber nützlich -- `expr`: perform arithmetic or boolean operations or evaluate regular expressions +- `expr`: Führe arithmetische oder boolsche Operationen aus oder werte reguläre Ausdrücke aus -- `m4`: simple macro processor +- `m4`: Simpler Macro Auswerter -- `yes`: print a string a lot +- `yes`: Gebe eine Zeichenkette sehr oft aus -- `cal`: nice calendar +- `cal`: netter Kalender -- `env`: run a command (useful in scripts) +- `env`: Führe ein Kommando aus (nützlich für Skripte) -- `printenv`: print out environment variables (useful in debugging and scripts) +- `printenv`: Gebe Umgebungsvariablen aus (nützlich zum Debuggen und für Skripte) -- `look`: find English words (or lines in a file) beginning with a string +- `look`: finde Englische Worte (oder Zeilen in einer Datei) die mit einer bestimmten Zeichenkette anfangen -- `cut`, `paste` and `join`: data manipulation +- `cut`, `paste` und `join`: Datenmanipulation -- `fmt`: format text paragraphs +- `fmt`: Formatiere Textabsätze -- `pr`: format text into pages/columns +- `pr`: Formatiere Text als Seiten/Spalten -- `fold`: wrap lines of text +- `fold`: Breche Textzeilen um -- `column`: format text fields into aligned, fixed-width columns or tables +- `column`: Formatiere Textfelder als bündige Spalten oder Tabellen mit fester Größe -- `expand` and `unexpand`: convert between tabs and spaces +- `expand` and `unexpand`: Konvertiere zwischen Tabs und Spaces -- `nl`: add line numbers +- `nl`: Füge Zeilennummern hinzu -- `seq`: print numbers +- `seq`: Gebe Zahlen aus -- `bc`: calculator +- `bc`: Taschenrechner -- `factor`: factor integers +- `factor`: faktorisiere Ganzzahlen -- [`gpg`](https://gnupg.org/): encrypt and sign files +- [`gpg`](https://gnupg.org/): Verschlüssle und signiere Dateien -- `toe`: table of terminfo entries +- `toe`: Tabelle von terminfo Einträgen -- `nc`: network debugging and data transfer +- `nc`: Netzwerk Debugging und Datentransfer -- `socat`: socket relay and tcp port forwarder (similar to `netcat`) +- `socat`: Socket und TCP Port Weiterleitung (ähnlich wie `netcat`) -- [`slurm`](https://github.com/mattthias/slurm): network trafic visualization +- [`slurm`](https://github.com/mattthias/slurm): Netzwerk Verkehr Visulaisierung -- `dd`: moving data between files or devices +- `dd`: Daten zwischen Dateien und Geräten bewegen -- `file`: identify type of a file +- `file`: Identifiziere den Typ einer Datei -- `tree`: display directories and subdirectories as a nesting tree; like `ls` but recursive +- `tree`: Zeige Verzeichnisse und Unterverzeichnisse als verschachtelten Baum; wie 'ls' aber rekursiv -- `stat`: file info +- `stat`: Date Infomationen -- `time`: execute and time a command +- `time`: Führe ein Kommando aus und messe die Zeit - `watch`: run a command repeatedly, showing results and/or highlighting changes -- `tac`: print files in reverse +- `tac`: Gebe Dateien in umgekehrter Reihenfolge aus -- `shuf`: random selection of lines from a file +- `shuf`: Zufällige Auswahl von Zeilen von einer Datei -- `comm`: compare sorted files line by line +- `comm`: Vergleiche sortierte Dateien Zeile für Zeile -- `pv`: monitor the progress of data through a pipe +- `pv`: Überwache den Fortschritt von Daten durch eine Pipe -- `hd` and `bvi`: dump or edit binary files +- `hd` und `bvi`: Ausgabe und Editieren von Binärdateien -- `strings`: extract text from binary files +- `strings`: Text aus Binärdateien extrahieren -- `tr`: character translation or manipulation +- `tr`: Buchstabenübersetzung und Manipulation -- `iconv` or `uconv`: conversion for text encodings +- `iconv` oder `uconv`: Konvertierung von Zeichensätzen -- `split` and `csplit`: splitting files +- `split` und `csplit`: Dateien aufteilen -- `sponge`: read all input before writing it, useful for reading from then writing to the same file, e.g., `grep -v something some-file | sponge some-file` +- `sponge`: liest die gesamte Eingabe, bevor sie wieder ausgegeben wird. Nützlich um aus der selben Datei zu lesen und in diese zu schreiben, z.B. `grep -v irgendwas irgendeine-datei | sponge irgendeine-datei` -- `units`: unit conversions and calculations; converts furlongs per fortnight to twips per blink (see also `/usr/share/units/definitions.units`) +- `units`: Einheiten Konvertierungen und Berechnungen; konvertiert Furlong(Achtelmeile)/Fortnights(2 Wochen) zu twips/blink (siehe `/usr/share/units/definitions.units`) -- `7z`: high-ratio file compression +- `7z`: hochperformante Dateikomprimierung -- `ldd`: dynamic library info +- `ldd`: Informationen zu dynamisch gelinkten Bibliotheken -- `nm`: symbols from object files +- `nm`: Symbole aus Objektdateien anzeigen -- `ab`: benchmarking web servers +- `ab`: Web Server benchmarken -- `strace`: system call debugging +- `strace`: Debugging von Syscalls -- `mtr`: better traceroute for network debugging +- `mtr`: ein besseres "traceroute" zum Netzwerk debuggen -- `cssh`: visual concurrent shell +- `cssh`: visuelle, nebenläufige Shell -- `rsync`: sync files and folders over SSH or in local file system +- `rsync`: synchronisiere Dateien und Ordner über SSH oder im lokalen Dateisystem -- `wireshark` and `tshark`: packet capture and network debugging +- `wireshark` und `tshark`: Pakete aufzeichnen und Netzwerk Debugging -- `ngrep`: grep for the network layer +- `ngrep`: grep für die Netzwerk Schicht -- `host` and `dig`: DNS lookups +- `host` und `dig`: DNS Auflösung -- `lsof`: process file descriptor and socket info +- `lsof`: Prozess Datei Deskriptor und Socket Informationen -- `dstat`: useful system stats +- `dstat`: nützliche Systemstatistiken -- [`glances`](https://github.com/nicolargo/glances): high level, multi-subsystem overview +- [`glances`](https://github.com/nicolargo/glances): Grobe Übersicht über zahlreiche Subsysteme -- `iostat`: Disk usage stats +- `iostat`: Fesplatten Nutzungsstatistiken -- `mpstat`: CPU usage stats +- `mpstat`: CPU Nutzungsstatistiken -- `vmstat`: Memory usage stats +- `vmstat`: Speicher Nutzungsstatistiken -- `htop`: improved version of top +- `htop`: eine verbesserte Version von top -- `last`: login history +- `last`: Login Verlauf -- `w`: who's logged on +- `who`: wer ist gerade angemeldet -- `id`: user/group identity info +- `id`: Benutzer/Gruppen Identitätsinformationen -- `sar`: historic system stats +- `sar`: Historische System Statistiken -- `iftop` or `nethogs`: network utilization by socket or process +- `iftop` oder `nethogs`: Netzwerknutzung durch Sockets oder Prozesse -- `ss`: socket statistics +- `ss`: Socket Statistiken -- `dmesg`: boot and system error messages +- `dmesg`: Bootvorgang und System Fehlermeldungen -- `sysctl`: view and configure Linux kernel parameters at run time +- `sysctl`: Anzeige und Konfiguration von Linux Kernel Parametern zur Laufzeit -- `hdparm`: SATA/ATA disk manipulation/performance +- `hdparm`: SATA/ATA Festplatten Manipulation/Performanceinformationen -- `lsb_release`: Linux distribution info +- `lsb_release`: Informationen über die Linux Distribution -- `lsblk`: list block devices: a tree view of your disks and disk paritions +- `lsblk`: Auflisten von block devices: eine Baumansicht deiner Festplatten und Partitionen -- `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: hardware information, including CPU, BIOS, RAID, graphics, devices, etc. +- `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: hardware informationen, inklusive CPU, BIOS, RAID, Grafikkarten, Geräte, etc. -- `lsmod` and `modifno`: List and show details of kernel modules. - -- `fortune`, `ddate`, and `sl`: um, well, it depends on whether you consider steam locomotives and Zippy quotations "useful" +- `lsmod` und `modinfo`: Auflisten und Details anzeigen von Kernel Modulen +- `fortune`, `ddate`, und `sl`: ähm ja, kommt darauf an, ob man Dampflokomotiven und flotte Zitate "nützlich" findet ## Nur MacOS X Diese Hinweise sind *nur* für MacOS relevant. -- Paketverwaltung mit `brew` (Homebrew) und/oder `port` (MacPorts). Mit diesen Tools kann man viele der obrigen Programme für MacOs installieren. +- Paketverwaltung mit `brew` (Homebrew) und/oder `port` (MacPorts). Mit diesen Werkzeugen kann man viele der obrigen Programme für MacOs installieren. - Kopiere die Ausgabe jedes Kommandos an eine Desktop App mit `pbcopy` und füge die Eingabe von einer solchen ein mit `pbpaste`. From 13b2422f869649e2950f91668d45b092ab420d58 Mon Sep 17 00:00:00 2001 From: Gernot Pointner Date: Tue, 16 Feb 2016 07:23:29 +0100 Subject: [PATCH 10/26] German Translation: Obscure but useful fixes --- README-de.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README-de.md b/README-de.md index 029d6bc..70da46a 100644 --- a/README-de.md +++ b/README-de.md @@ -307,7 +307,7 @@ A few examples of piecing together commands: ``` -## Obskur aber nützlich +## Eigenartig aber hilfreich - `expr`: Führe arithmetische oder boolsche Operationen aus oder werte reguläre Ausdrücke aus @@ -359,11 +359,11 @@ A few examples of piecing together commands: - `tree`: Zeige Verzeichnisse und Unterverzeichnisse als verschachtelten Baum; wie 'ls' aber rekursiv -- `stat`: Date Infomationen +- `stat`: Datei Infomationen - `time`: Führe ein Kommando aus und messe die Zeit -- `watch`: run a command repeatedly, showing results and/or highlighting changes +- `watch`: führe ein Kommando wiederholt aus, wobei die Ergebnisse angezeigt und/oder Änderungen hervorgehoben werden - `tac`: Gebe Dateien in umgekehrter Reihenfolge aus From 5734d27de856d2ac1c179bfd77ccbdfdcef45aae Mon Sep 17 00:00:00 2001 From: Gernot Pointner Date: Fri, 6 May 2016 10:05:22 +0200 Subject: [PATCH 11/26] [de] Adds German translation for One-Liner section --- README-de.md | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/README-de.md b/README-de.md index 70da46a..cf5c3fb 100644 --- a/README-de.md +++ b/README-de.md @@ -264,41 +264,42 @@ Hinweise: - Use `dmesg` whenever something's acting really funny (it could be hardware or driver issues). -## One-liners +## Einzeiler -A few examples of piecing together commands: +Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: -- It is remarkably helpful sometimes that you can do set intersection, union, and difference of text files via `sort`/`uniq`. Suppose `a` and `b` are text files that are already uniqued. This is fast, and works on files of arbitrary size, up to many gigabytes. (Sort is not limited by memory, though you may need to use the `-T` option if `/tmp` is on a small root partition.) See also the note about `LC_ALL` above and `sort`'s `-u` option (left out for clarity below). +- Manchmal ist es unglaublich hilfreich, dass man die Schnittmenge, Vereinigung und den Unterschied zwischen Textdateien via `sort`/`uniq` bilden kann. Angenommen a und b sind Textdateien, die bereits "unique" sind. Diese Herangehensweise ist schnell, funktioniert mit Dateien beliebiger Größe, bis zu mehreren Gigabytes (Sort ist nicht durch Speicher beschränkt, obwohl man eventuell die `-T` Option nutzen muss, falls `/tmp` auf einer kleinen root partition liegt.) Siehe auch die Bemerkung über `LC_ALL` weiter oben und die `sort`'s `-u` Option (wurde oben aus Gründen der Übersichtlichkeit ausgelassen). ```sh - cat a b | sort | uniq > c # c is a union b - cat a b | sort | uniq -d > c # c is a intersect b - cat a b b | sort | uniq -u > c # c is set difference a - b + cat a b | sort | uniq > c # c ist a vereint mit b + cat a b | sort | uniq -d > c # c ist a geschnitten b + cat a b b | sort | uniq -u > c # c ist die Menge mit unterschiedlichen Elementen a - b ``` -- Use `grep . *` to visually examine all contents of all files in a directory, e.g. for directories filled with config settings, like `/sys`, `/proc`, `/etc`. +- Benutze `grep . *` um alle Inhalte aller Dateien in einem Verzeichnis anzuzeigen, z.B. für Verzeichnisse, die mit Konfigurationen + gefüllt sind wie `/sys`, `/proc`, `/etc`. - -- Summing all numbers in the third column of a text file (this is probably 3X faster and 3X less code than equivalent Python): +- Alle Zahlen in der dritten Spalte einer Textdatei aufsummieren(dieser Ansatz ist wahrscheinlich 3x schneller und 3x weniger Code als + das Äquivalent in python): ```sh awk '{ x += $3 } END { print x }' myfile ``` -- If want to see sizes/dates on a tree of files, this is like a recursive `ls -l` but is easier to read than `ls -lR`: +- Falls man die Größen/Datumsangaben von einem Dateibaum wissen möchte, funktioniert das Folgende wie ein rekursives `ls -l`, aber ist + leichter zu lesen als `ls -lR`: ```sh find . -type f -ls ``` - -- Say you have a text file, like a web server log, and a certain value that appears on some lines, such as an `acct_id` parameter that is present in the URL. If you want a tally of how many requests for each `acct_id`: +- Angenommen innerhalb einer Textdatei, so wie ein server web log, tauch ein gewisser Wert in manchen Zeilen auf, wie z.B. ein `acct_id` Parameter in der URL. Falls eine Aufzählung gewünscht ist, wie viele Anfragen es jeweils für eine `acct_id` gibt: ```sh cat access.log | egrep -o 'acct_id=[0-9]+' | cut -d= -f2 | sort | uniq -c | sort -rn ``` -- To continuously monitor changes, use `watch`, e.g. check changes to files in a directory with `watch -d -n 2 'ls -rtlh | tail'` or to network settings while troubleshooting your wifi settings with `watch -d -n 2 ifconfig`. +- Um durchgehend Änderungen zu überwachen, solltest Du "watch" benutzen; z.B. Dateiänderungen in einem Verzeichnis können mittels `watch -d -n 2 'ls -rtlh | tail'` überwacht werden, während Du Deine Wifi Einstellungen mittels `watch -d -n 2 ifconfig` auf Fehler überprüfen kannst. -- Run this function to get a random tip from this document (parses Markdown and extracts an item): +- Führe diese Funktion aus, um einen zufälligen Tip aus diesem Dokument zu erhalten(parst das Markdown Dokument und extrahiert ein Element) ```sh function taocl() { - curl -s https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README.md | + curl -s https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README-de.md | pandoc -f markdown -t html | xmlstarlet fo --html --dropdtd | xmlstarlet sel -t -v "(html/body/ul/li[count(p)>0])[$RANDOM mod last()+1]" | From 0c3e2223ffee7d21b26e2e96826982072784b8c3 Mon Sep 17 00:00:00 2001 From: Gernot Pointner Date: Mon, 16 May 2016 15:16:43 +0200 Subject: [PATCH 12/26] de: Translates System Debugging section --- README-de.md | 41 ++++++++++++++++++++++------------------- 1 file changed, 22 insertions(+), 19 deletions(-) diff --git a/README-de.md b/README-de.md index cf5c3fb..792f511 100644 --- a/README-de.md +++ b/README-de.md @@ -225,43 +225,46 @@ Hinweise: - Use `zless`, `zmore`, `zcat`, and `zgrep` to operate on compressed files. -## System debugging +## Fehlerbehebung auf Systemebene -- For web debugging, `curl` and `curl -I` are handy, or their `wget` equivalents, or the more modern [`httpie`](https://github.com/jakubroztocil/httpie). +- Zur Fehlersuche bei Webanwendungen sind `curl` und `curl -I` hilfreich, ebenso wie ihre `wget` Äquivalente oder das modernere [`httpie`](https://github.com/jakubroztocil/httpie). -- To know disk/cpu/network status, use `iostat`, `netstat`, `top` (or the better `htop`), and (especially) `dstat`. Good for getting a quick idea of what's happening on a system. +- Um den Festplatten/CPU/Netzwerk Status zu erfahren, nutze `iostat`, `netstat`, `top` (oder das bessere `htop`), und (besonders) `dstat`. Gut um eine grobe Übersicht darüber zu bekommen, was sich auf einem System abspielt. -- For a more in-depth system overview, use [`glances`](https://github.com/nicolargo/glances). It presents you with several system level statistics in one terminal window. Very helpful for quickly checking on various subsystems. +- Für eine tiefgreifendere Systemübersicht, nutze [`glances`](https://github.com/nicolargo/glances). Es zeigt Dir einige System Statistiken in einem Terminalfenster an. Sehr hilfreich, um schnell mehrere Subsysteme überprüfen zu können. -- To know memory status, run and understand the output of `free` and `vmstat`. In particular, be aware the "cached" value is memory held by the Linux kernel as file cache, so effectively counts toward the "free" value. +- Um den Zustand des Speichers zu kennen, solltest Du `free` und `vmstat` ausführen und die Ausgabe verstehen. Sei Dir insbesondere bewusst, dass der "cached" Wert, der Wert ist, der vom Linux Kernel als Datei Cache genutzt wird, so dieser effektiv als zum + Wert "free" addiert werden kann. -- Java system debugging is a different kettle of fish, but a simple trick on Oracle's and some other JVMs is that you can run `kill -3 ` and a full stack trace and heap summary (including generational garbage collection details, which can be highly informative) will be dumped to stderr/logs. The JDK's `jps`, `jstat`, `jstack`, `jmap` are useful. [SJK tools](https://github.com/aragozin/jvm-tools) are more advanced. +- Java Systeme zu debuggen ist ein anderes Paar Schuhe, aber ein simpler Trick für die Oracle JVM (der teilweise auch für andere JVMs funktioniert) ist `kill -3 `, so dass ein vollständiger Strack trace und Heap Informationen (inklusive Garbage Collection + Details, die sehr informativ sein können) nach stderr/logs ausgegeben werden. Die JDK Befehle `jps`, `jstat`, `jstack`, `jmap` are useful. [SJK tools](https://github.com/aragozin/jvm-tools) sind noch weiter fortgeschritten. -- Use `mtr` as a better traceroute, to identify network issues. +- Benutze `mtr` als ein besseres traceroute, um Netzwerk Probleme zu identifizieren. -- For looking at why a disk is full, `ncdu` saves time over the usual commands like `du -sh *`. +- Beim Nachsehen, warum die Festplatte voll ist, spart `ncdu` Zeit gegenüber den üblichen Kommandos wie `du -sh *`. -- To find which socket or process is using bandwidth, try `iftop` or `nethogs`. +- Um herauszufunden, welcher Socket oder Prozess Bandbreite verbraucht, solltest Du `iftop` oder `nethogs` verwenden. -- The `ab` tool (comes with Apache) is helpful for quick-and-dirty checking of web server performance. For more complex load testing, try `siege`. +- Das `ab` Werkzeug (ein Teil vom Apache) ist hilfreich, um schnell und pragmatisch die Performanz eines Webservers zu messen. Für komplexere Messungen solltest Du`siege` ausprobieren. -- For more serious network debugging, `wireshark`, `tshark`, or `ngrep`. +- Für eine tiefergehende Netzwerk Problemsuche, `wireshark`, `tshark`, oder `ngrep`. -- Know about `strace` and `ltrace`. These can be helpful if a program is failing, hanging, or crashing, and you don't know why, or if you want to get a general idea of performance. Note the profiling option (`-c`), and the ability to attach to a running process (`-p`). +- Kenne `strace` und `ltrace`. Diese können hilfreich sein, falls ein Programm fehlschlägt, hängt, oder abstürzt und Du weißt nicht warum, oder um einen generellen Eindruck von der Performanz zu bekommen. Beachte die Profiling Option(`-c`), und die Fähigkeit, + sich zu laufen Prozessen zu verbinden (`-p`). -- Know about `ldd` to check shared libraries etc. +- Kenne `ldd` um Shared Libraries zu überprüfen. -- Know how to connect to a running process with `gdb` and get its stack traces. +- Sei in der Lage, sich zu einem laufenden Prozess mittels `gdb` zu verbinden und die Stack Traces zu holen. -- Use `/proc`. It's amazingly helpful sometimes when debugging live problems. Examples: `/proc/cpuinfo`, `/proc/meminfo`, `/proc/cmdline`, `/proc/xxx/cwd`, `/proc/xxx/exe`, `/proc/xxx/fd/`, `/proc/xxx/smaps` (where `xxx` is the process id or pid). +- Benutze `/proc`. Es ist manchmal unglaublich hilfreich, um Probleme in Echtzeit zu debuggen. Beispiele: `/proc/cpuinfo`, `/proc/meminfo`, `/proc/cmdline`, `/proc/xxx/cwd`, `/proc/xxx/exe`, `/proc/xxx/fd/`, `/proc/xxx/smaps` (wobei `xxx` die Prozess Id /pid ist). -- When debugging why something went wrong in the past, `sar` can be very helpful. It shows historic statistics on CPU, memory, network, etc. +- Bei der Problemfindung, warum etwas in der Vergangenheit schief gelaufen ist, kann `sar` sehr hilfreich sein. Es zeigt historische Statistiken über CPU, Speicher, Netzwerk, etc. -- For deeper systems and performance analyses, look at `stap` ([SystemTap](https://sourceware.org/systemtap/wiki)), [`perf`](http://en.wikipedia.org/wiki/Perf_(Linux)), and [`sysdig`](https://github.com/draios/sysdig). +- Für eine genauere System und Performanceanalyse, solltest Du Dir `stap` ([SystemTap](https://sourceware.org/systemtap/wiki)), [`perf`](http://en.wikipedia.org/wiki/Perf_(Linux)), und [`sysdig`](https://github.com/draios/sysdig) ansehen. -- Check what OS you're on with `uname` or `uname -a` (general Unix/kernel info) or `lsb_release -a` (Linux distro info). +- Finde heraus, welches Betriebssystem Du nutzt mittels `uname` oder `uname -a` (allgemeine Unix/Kernelinformationen) oder `lsb_release -a` (Linux Distribution Informationen) -- Use `dmesg` whenever something's acting really funny (it could be hardware or driver issues). +- Benutze `dmesg` wenn sich etwas merkdwürdig verhält (es könnte ein Hardware oder Treiber Problem sein) ## Einzeiler From 5ff60fd54d9d274b633bcb277cbc96d839a8f4c2 Mon Sep 17 00:00:00 2001 From: Gernot Pointner Date: Fri, 15 Jul 2016 10:49:42 +0200 Subject: [PATCH 13/26] de: Translate System debugging and parts of handling files --- README-de.md | 36 ++++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 16 deletions(-) diff --git a/README-de.md b/README-de.md index 792f511..cf216af 100644 --- a/README-de.md +++ b/README-de.md @@ -184,45 +184,49 @@ Hinweise: - Kenne `tee`, um von stdin in eine Datei und sogar nach stdout zu kopieren, wie etwa mit `ls -al | tee datei.txt`. -- Know that locale affects a lot of command line tools in subtle ways, including sorting order (collation) and performance. Most Linux installations will set `LANG` or other locale variables to a local setting like US English. But be aware sorting will change if you change locale. And know i18n routines can make sort or other commands run *many times* slower. In some situations (such as the set operations or uniqueness operations below) you can safely ignore slow i18n routines entirely and use traditional byte-based sort order, using `export LC_ALL=C`. +- Sei Dir bewusst, dass die locale Einstellungen viele Kommandozeilenwerkzeuge auf subtile Art und Weise beeinflussen, inklusive der Sortierreihenfolge und ihrer Performanz. Die meisten Linux Installation setzen `LANG` oder andere lokale Variablen auf eine + lokale Einstellung wie z.B. US English. Aber sei Dir bewusst, dass sich das Sortierverhalten ändern wird, falls Du die locale Einstellung änderst. Und wisse, dass i18n Routinen sort und andere Kommandos *um ein Vielfaches* verlangsamen können. In manchen +Situationen (wie den Mengen oder Identitätsfunktionen unterhalb) kann man ruhigen Gewissens langsame i18n Routinen ignorieren und traditionelle byte-basierte Sortierreihenfolge nutzen, indem man `export LC_ALL=C` setzt. -- Know basic `awk` and `sed` for simple data munging. For example, summing all numbers in the third column of a text file: `awk '{ x += $3 } END { print x }'`. This is probably 3X faster and 3X shorter than equivalent Python. +- Kenne Grundlagen von`awk` und `sed` für einfache Datenverarbeitung. Um z.B. alle Zahlen in der dritten Spalte einer Textdatei aufzusummieren: `awk '{ x += $3 } END { print x }'`. Das ist wahrscheinlich 3X schneller und 3X kürzer als das Python Äquivalent. -- To replace all occurrences of a string in place, in one or more files: +- Um alle Vorkommen einer Zeichenkette in einem oder mehreren Dateien zu ersetzen: ```sh perl -pi.bak -e 's/old-string/new-string/g' my-files-*.txt ``` -- To rename many files at once according to a pattern, use `rename`. For complex renames, [`repren`](https://github.com/jlevy/repren) may help. +- Um mehrere Dateien auf einmal anhand eines Musters umzubennen, nutze `rename`. Für komplexe Umbenennungen könnte [`repren`](https://github.com/jlevy/repren) helfen. ```sh - # Recover backup files foo.bak -> foo: + # Stelle backup Dateien wieder her: foo.bak -> foo: rename 's/\.bak$//' *.bak - # Full rename of filenames, directories, and contents foo -> bar: + # Komplette Umbenennung von Dateinamen, Verzeichnissen und Inhalten foo -> bar: repren --full --preserve-case --from foo --to bar . ``` -- Use `shuf` to shuffle or select random lines from a file. +- Nutze `shuf` zum Mischen oder um zufällige Zeilen aus einer Datei auszuwählen. -- Know `sort`'s options. For numbers, use `-n`, or `-h` for handling human-readable numbers (e.g. from `du -h`). Know how keys work (`-t` and `-k`). In particular, watch out that you need to write `-k1,1` to sort by only the first field; `-k1` means sort according to the whole line. Stable sort (`sort -s`) can be useful. For example, to sort first by field 2, then secondarily by field 1, you can use `sort -k1,1 | sort -s -k2,2`. +- Kenne die Optionen von `sort`. Benutze `-n` für Zahlen, oder `-h` um mit menschenlesbaren Zahlen umzugehen (wie z.B. von `du -h`). Sei Dir bewusst, wie Schlüssel funktionieren (`-t` und `-k`). Sei Dir insbesondere bewusst, dass Du `-k1,1` verwenden musst, um bezüglich des ersten Felds zu sortieren;`-k1 bedeutet, sortiere anhand der ganzen Zeile. Stabiles Suchen (`sort -s`) kann ebenfalls nützlich sein. Um beispielsweise primär nach Feld 2 und sekundär nach Feld 1 zu sortieren, kannst Du `sort -k1,1 | sort -s -k2,2` benutzen. -- If you ever need to write a tab literal in a command line in Bash (e.g. for the -t argument to sort), press **ctrl-v** **[Tab]** or write `$'\t'` (the latter is better as you can copy/paste it). +- Falls Du jemals ein Tabulator Literal in eine Kommandozeile in Bash schreiben musst (z.B. für das -t Argument für sort), drücke **ctrl-v** **[Tab]** oder schreibe `$'\t'` (letzteres ist besser, da man es Kopieren/Einfügen kann). -- The standard tools for patching source code are `diff` and `patch`. See also `diffstat` for summary statistics of a diff. Note `diff -r` works for entire directories. Use `diff -r tree1 tree2 | diffstat` for a summary of changes. +- Die Standardwerkzeuge für das Patchen von Quellcode sind `diff` und `patch`. Siehe auch `diffstat`, um zusammenfassende Statistiken eines diffs zu erhalten. Beachte, dass `diff -r` für komplette Verzeichnisse funktioniert. Nutze `diff -r tree1 tree2 | diffstat`, um eine Übersicht aller Änderungen zu bekommen. -- For binary files, use `hd` for simple hex dumps and `bvi` for binary editing. +- Für Binärdateien, nutze `hd` für einfache HexDumps und `bvi`, um Binärdateien zu editieren -- Also for binary files, `strings` (plus `grep`, etc.) lets you find bits of text. +- Ebenfalls für Binärdateien, `kann strings` (und `grep`, etc.) benutzt werden, um Textpassagen zu finden. -- For binary diffs (delta compression), use `xdelta3`. +- Um Diffs für Binärdateien zu erstellen (Delta Kompression), nutze `xdelta3`. -- To convert text encodings, try `iconv`. Or `uconv` for more advanced use; it supports some advanced Unicode things. For example, this command lowercases and removes all accents (by expanding and dropping them): +- Um zwischen Text Kodierungen zu konvertieren, solltest Du `iconv` probieren. Oder `uconv` für fortgeschrittene Anwendungsfälle; es + unterstüzt einige fortgeschrittene Unicode Dinge. Dieses Kommando beispielsweise wandelt alle Buchstaben in Kleinbuchstaben um und +entfernt alle Akzente (indem sie erweitert und verworfen werden): ```sh uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt ``` -- To split files into pieces, see `split` (to split by size) and `csplit` (to split by a pattern). +- Um Dateien aufzuteilen, siehe `split` (um anhand einer bestimmten Größe zu teilen) und `csplit` (um Anhand eines gewissen Patterns zu teilen). -- Use `zless`, `zmore`, `zcat`, and `zgrep` to operate on compressed files. +- Benutze `zless`, `zmore`, `zcat`, und `zgrep` um mit komprimierten Dateien zu arbeiten ## Fehlerbehebung auf Systemebene From 1eaecf4bbf77552f25c53a46b0cc3a872a61d00b Mon Sep 17 00:00:00 2001 From: Gernot Pointner Date: Mon, 5 Sep 2016 06:51:18 +0200 Subject: [PATCH 14/26] de: Fix links in table of contents --- README-de.md | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/README-de.md b/README-de.md index cf216af..ef91e37 100644 --- a/README-de.md +++ b/README-de.md @@ -5,16 +5,16 @@ [![Join the chat at https://gitter.im/jlevy/the-art-of-command-line](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/jlevy/the-art-of-command-line?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) -- [Kurzbeschreibung](#meta) -- [Grundlagen](#basics) -- [Täglicher Gebrauch](#everyday-use) -- [Umgang mit Dateien und Daten](#processing-files-and-data) -- [Fehlerbehebung auf Systemebene](#system-debugging) -- [Einzeiler](#one-liners) -- [Eigenartig aber hilfreich](#obscure-but-useful) -- [Nur MacOS X](#macos-x-only) -- [Weitere Quellen](#more-resources) -- [Haftungsausschluss](#disclaimer) +- [Kurzbeschreibung](#kurzbeschreibung) +- [Grundlagen](#grundlagen) +- [Täglicher Gebrauch](#täglicher-gebrauch) +- [Umgang mit Dateien und Daten](#umgang-mit-dateien-und-daten) +- [Fehlerbehebung auf Systemebene](#fehlerbehebung-auf-systemebene) +- [Einzeiler](#einzeiler) +- [Eigenartig aber hilfreich](#eigenartig-aber-hilfreich) +- [Nur MacOS X](#nur-macos-x) +- [Weitere Quellen](#weitere-quellen) +- [Haftungsausschluss](#haftungsausschluss) ![curl -s 'https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README.md' | egrep -o '`\w+`' | tr -d '`' | cowsay -W50](cowsay.png) @@ -476,7 +476,7 @@ Diese Hinweise sind *nur* für MacOS relevant. - Man sollte sich bewusst sein, dass MacOS auf BSD Unix basiert und sich viele Kommandos (wie z.B. `ps`, `ls`, `tail`, `awk`, `sed`) bezüglich subtiler Kleinigkeiten von Linux, dass stark von System V-style Unix und GNU tools beeinflusst ist, unterscheiden. Oft kann man den Unterschied daran erkennen, dass eine man page die Überschrift "BSD General Commands Manual" trägt. In manchen Fällen kann auch die GNU version installiert werden (wie z.B. bei `gawk` und `gsed` für GNU awk und sed). Falls man cross-platform Bash Skripte schreiben möchte, sollte man solche Kommandos vermeiden (und z.B. Python oder `perl` in Betracht ziehen) oder sorgfätig testen. -## Mehr Quellen +## Weitere Quellen - [awesome-shell](https://github.com/alebcay/awesome-shell): Eine hilfreiche Liste von Shell Werkzeugen und Quellen - [Strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/) um bessere Shell Skripte zu schreiben From e83636c32e85f32b8c9e7a70f02d86409b76a45b Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Tue, 6 Sep 2016 09:27:44 +0200 Subject: [PATCH 15/26] Meta section is up-to-date with current english version --- README-de.md | 88 +++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 67 insertions(+), 21 deletions(-) diff --git a/README-de.md b/README-de.md index ef91e37..3ec8633 100644 --- a/README-de.md +++ b/README-de.md @@ -1,10 +1,14 @@ -[ Languages: [English](README.md), [Español](README-es.md), [한국어](README-ko.md), [Português](README-pt.md), [Русский](README-ru.md), [Slovenščina](README-sl.md), [中文](README-zh.md), [German](README-de.md) ] +🌍 +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # The Art of Command Line +[![Ask a Question](https://img.shields.io/badge/%3f-Ask%20a%20Question-ff69b4.svg)](https://airtable.com/shrzMhx00YiIVAWJg) + [![Join the chat at https://gitter.im/jlevy/the-art-of-command-line](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/jlevy/the-art-of-command-line?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + - [Kurzbeschreibung](#kurzbeschreibung) - [Grundlagen](#grundlagen) - [Täglicher Gebrauch](#täglicher-gebrauch) @@ -13,6 +17,7 @@ - [Einzeiler](#einzeiler) - [Eigenartig aber hilfreich](#eigenartig-aber-hilfreich) - [Nur MacOS X](#nur-macos-x) +- [Nur Windows](#nur-windows) - [Weitere Quellen](#weitere-quellen) - [Haftungsausschluss](#haftungsausschluss) @@ -27,25 +32,24 @@ Vieles davon auf [Quora](http://www.quora.com/What-are-some-time-saving-tips-that-every-Linux-user-should-know), aber angesichts des Interesses scheint es vielversprechend, Github zu nutzen, wo talentiertere Menschen als ich es bin kontinuierlich Verbesserungen vorschlagen können. Wenn du einen Fehler entdeckst oder etwas, das man besser machen könnte, erstelle ein Issue oder einen PR! (Lies aber bitte zuerst die Kurzbeschreibung und überprüfe bereits vorhandene Issues/PRs.) - ## Kurzbeschreibung Umfang: - Diese Anleitung richtet sich an Anfänger und Fortgeschrittene. Die Ziele sind The goals are *Breite* (alles ist wichtig), *Genauigkeit* (konkrete Beispiele für die gebräuchlichsten Anwendungsfälle) und *Knappheit* (Dinge, die nicht wesentlich sind oder leicht anderswo nachgeschlagen werden können, sollen vermieden werden). Jeder Tipp ist in einer bestimmten Situation wesentlich oder deutlich zeitsparend gegenüber bestehenden Alternativen. -- Sie ist für Linux geschrieben, mit der Ausnahme des Abschnitts "[Nur MacOS X](#macos-x-only)". Viele der anderen Punkte lassen sich nutzen oder sind installierbar auf anderen Unices oder MacOS (oder sogar Cygwin). +- Sie ist für Linux geschrieben, mit der Ausnahme der Abschnitte "[Nur MacOS X](#nur-macos-x)" und "[Nur Windows](#nur-windows)". Viele der anderen Punkte lassen sich nutzen oder sind installierbar auf anderen Unices oder MacOS (oder sogar Cygwin). - Der Fokus liegt auf interaktiver Bash, allerdings gelten viele Tipps auch auf anderen Shells sowie für allgemeines Bash-Skripting. - Sie beinhaltet sowohl "normale" Unix-Befehle als auch solche, die bestimmte installierte Pakete voaussetzen -- sofern sie wichtig genug sind, dass sie die Aufnahme in diese Anleitung verdienen. Hinweise: -- Um eine Seite nicht zu sprengen, ist ihr Inhalt durchgängig anhand von Verweisen aufgelistet. Du bist schlau genug, anderswo zusätzliche Informationen nachzuschlagen, sobald du die Idee bzw. den Befehl dahinter kennst. Verwende `apt-get`/`yum`/`dnf`/`pacman`/`pip`/`brew` (je nachdem), um neue Programme zu installieren. +- Um eine Seite nicht zu sprengen, ist ihr Inhalt durchgängig anhand von Verweisen aufgelistet. Du bist schlau genug, anderswo zusätzliche Informationen nachzuschlagen, sobald du die Idee bzw. den Befehl dahinter kennst. Verwende `apt-get`, `yum`, `dnf`, `pacman`, `pip` oder `brew`, um ggf. neue Programme zu installieren. - Verwende [Explainshell](http://explainshell.com/), um einen hilfreichen Einblick zu erhalten, was es mit Befehlen, Optionen, Pipes etc. auf sich hat. ## Grundlagen -- Lerne einfache Bash. Tatsächlich, gib `man bash` ein und überfliege das Ganze zumindest; es ist leicht zu verstehen und nicht allzu lang. Alternative Shells sind nett, aber Bash ist mächtig und immer verfügbar (*nur* zsh, fish, etc. zu lernen ist auf dem eigenen Laptop vielleicht reizvoll, beschränkt jedoch deine Möglichkeiten in vielerlei Hinsicht, etwa beim Arbeiten mit bestehenden Servern). +- Lerne Bash-Grundlagen. Tatsächlich, gib `man bash` ein und überfliege das Ganze zumindest; es ist leicht zu verstehen und nicht allzu lang. Alternative Shells sind nett, aber Bash ist mächtig und immer verfügbar (*nur* zsh, fish, etc. zu lernen ist auf dem eigenen Laptop vielleicht reizvoll, beschränkt jedoch deine Möglichkeiten in vielerlei Hinsicht, etwa beim Arbeiten mit bestehenden Servern). - Lerne mindestens einen Text-basierten Editor zu benutzen. Idealerweise Vim (`vi`), da es letztlich keinen vergleichbaren Mitbewerber für gelegentliche Einsätze in einem Terminal gibt (selbst dann, wenn man eine große Entwicklungsumgebung wie Emacs oder die meiste Zeit einen modernen Hipster-Editor benutzt). @@ -53,16 +57,18 @@ Hinweise: - Lerne etwas über die Umleitung von Ein- und Ausgaben per `>` und `<` sowie `|` für Pipes. Wisse, dass `>` die Ausgabedatei überschreibt und `>>` etwas anhängt. Lerne etwas über stdout und stderr. -- Lerne etwas über die Dateinamenerweiterung mittels `*` (und eventuell `?` und `{`...`}`) sowie Anführungszeichen, etwa den Unterschied zwischen doppelten `"` und einfachen `'`. (Mehr zur Variablenerweiterung findest du unten.) +- Lerne etwas über die Dateinamenerweiterung mittels `*` (und eventuell `?` und `[`...`]`) sowie Anführungszeichen, etwa den Unterschied zwischen doppelten `"` und einfachen `'`. (Mehr zur Variablenerweiterung findest du unten.) - Mach dich vertraut mit Bash-Jobmanagement: `&`, **ctrl-z**, **ctrl-c**, `jobs`, `fg`, `bg`, `kill`, etc. - Kenne `ssh` und die Grundlagen passwortloser Authentifizierung mittels `ssh-agent`, `ssh-add`, etc. -- Grundlegende Dateiverwaltung: `ls` and `ls -l` (und spezieller, lerne die Funktion jeder einzelnen Spalte von `ls -l` kennen), `less`, `head`, `tail` und `tail -f` (oder noch besser, `less +F`), `ln` und `ln -s` (lerne die Unterschiede und Vorteile von Hard- und Softlinks), `chown`, `chmod`, `du` (für eine Kurzzusammenfassung der Festplattenbelegung: `du -hs *`). Für Dateisystemmanagement, `df`, `mount`, `fdisk`, `mkfs`, `lsblk`. +- Grundlegende Dateiverwaltung: `ls` and `ls -l` (und spezieller, lerne die Funktion jeder einzelnen Spalte von `ls -l` kennen), `less`, `head`, `tail` und `tail -f` (oder noch besser, `less +F`), `ln` und `ln -s` (lerne die Unterschiede und Vorteile von Hard- und Softlinks), `chown`, `chmod`, `du` (für eine Kurzzusammenfassung der Festplattenbelegung: `du -hs *`). Für Dateisystemmanagement `df`, `mount`, `fdisk`, `mkfs`, `lsblk`. Lerne, was ein Inode (engl. index node) ist (`ls -i` oder `df -i`). - Grundlagen der Netzwerkverwaltung: `ip` oder `ifconfig`, `dig`. +- Lerne etwas über Versionskontrolle und benutze ein entsprechendes System, wie etwa `git`. + - Kenne reguläre Ausdrücke gut, und die verschiedenen Statusindikatoren zu `grep`/`egrep`. Die Optionen `-i`, `-o`, `-v`, `-A`, `-B`, und `-C` sind gut zu wissen. - Lerne den Umgang mit `apt-get`, `yum`, `dnf` oder `pacman` (je nach Distribution), um Pakete zu finden bzw. zu installieren. Und stell sicher, dass du `pip` hast, um Python-basierte Kommandozeilen-Werkzeuge nutzen zu können (einige der untenstehenden werden am einfachsten über `pip` installiert). @@ -70,17 +76,23 @@ Hinweise: ## Täglicher Gebrauch -- In Bash kannst du mit **Tab** Parameter vervollständigen und mit **ctrl-r** bereits benutzte Befehle durchsuchen. +- In Bash kannst du mit **Tab** Parameter vervollständigen sowie alle verfügbaren Befehle anzeigen lassen und mit **ctrl-r** bereits benutzte Befehle durchsuchen (drück die Kombination, gib dann deinen Suchtext ein und springe anschließend durch wiederholtes Drücken von **ctrl-r** durch die Suchergebnisse, mit **Enter** kannst du den gefundenen Befehl ausführen sowie mit der rechten Pfeiltaste in die aktuelle Zeile einfügen, um ihn zu bearbeiten). - In Bash kannst du mit **ctrl-w** das letzte Wort löschen und mit **ctrl-u** alles bis zum Anfang einer Zeile. Verwende **alt-b** und **alt-f**, um dich Wort für Wort fortzubewegen, springe mit **ctrl-a** zum Beginn einer Zeile, mit **ctrl-e** zum Ende einer Zeile, lösche mit **ctrl-k** alles bis zum Ende einer Zeile und bereinige mit **ctrl-l** den Bildschirm. Siehe `man readline` für alle voreingestellten Tastenbelegungen in Bash. Davon gibt's viele. Zum Beispiel **alt-.** wechselt durch vorherige Parameter und **alt-*** erweitert ein Suchmuster. -- Alternativ, falls du vi-artige Tastenbelegungen magst, verwende `set -o vi`. +- Alternativ, falls du vi-artige Tastenbelegungen magst, verwende `set -o vi` (und `set -o emacs`, um es wiederzuholen). + +- Um kürzlich genutzte Befehle zu sehen, `history`. Es gibt außerdem viele Abkürzungen wie etwa `!$` (letzter Parameter) und `!!` (letzter Befehl), wenngleich diese oft einfach ersetzt werden durch **ctrl-r** und **alt-.**. + +- Um lange Befehle zu bearbeiten, kannst du sie (nachdem du deinen Editor angegeben hast, etwa mit `export EDITOR=vim`) mit **ctrl-x** **ctrl-e** im Editor öffnen, um mehrere Zeilen bearbeiten zu können. Oder vi-Style, **escape-v**. -- Um kürzich genutzte Befehle zu sehen, `history`. Es gibt außerdem viele Abkürzungen wie etwa `!$` (letzter Parameter) und `!!` (letzter Befehl), wenngleich diese oft einfach ersetzt werden durch **ctrl-r** und **alt-.**. +- Um kürzlich verwendete Befehle anzuzeigen, benutze `history`. Anschließend `!n` (wobei `n` die Nummer des Befehls ist), um es erneut auszuführen. Es gibt zudem zahlreiche Abkürzungen, die man verwenden kann, die nützlichste ist wahrscheinlich `!$` für den letzten Parameter und `!!` für den letzten Befehl (siehe "HISTORY EXPANSION" in der `man`-Seite). Diese werden allerdings oft einfach ersetzt durch **ctrl-r** und **alt-.**. + +- Go to your home directory with `cd`. Access files relative to your home directory with the `~` prefix (e.g. `~/.bashrc`). In `sh` scripts refer to the home directory as `$HOME`. - Um ins vorangegangene Arbeitsverzeichnis zu gelangen: `cd -` -- If you are halfway through typing a command but change your mind, hit **alt-#** to add a `#` at the beginning and enter it as a comment (or use **ctrl-a**, **#**, **enter**). You can then return to it later via command history. +- Wenn du einen Befehl eingibst und es dir auf halbem Wege anders überlegst, drücke **alt-#**, um am Zeilenanfang ein `#` einzufügen und ihn damit als Kommentar auszuweisen (oder benutze **ctrl-a**, **#**, **enter**). Du kannst später über die Befehlsgeschichte zurückgelangen. - Verwende `xargs` (oder `parallel`). Es ist sehr mächtig. Beachte, wie du viele Dinge pro Zeile (`-L`) als auch parallel (`-P`) ausführen kannst. Wenn du dir nicht sicher bist, ob das Richtige dabei herauskommt, verwende zunächst `xargs echo`. Außerdem ist`-I{}` nützlich. Beispiele: ```bash @@ -104,7 +116,19 @@ Hinweise: - Verwende `alias`, um Verknüpfungen für gebräuchliche Befehle zu erstellen. So erstellt etwa `alias ll='ls -latr'` den neuen Alias `ll`. -- Verwende in Bash-Skripts `set -x` zur Fehlerbehebung. Benutze strict modes wann immer möglich. Verwende `set -e` zum Abbruch bei Fehlern. Benutze `set -o pipefail` ebenfalls, um mit Fehlern präzise zu arbeiten (auch wenn dieses Thema etwas heikel ist). Verwende für etwas komplexere Skripte weiterhin `trap`. +- Speichere Alternativnamen ("aliases"), Shelleinstellungen und häufig benutzte Funktionen in `~/.bashrc` und [stelle sie anderen Login-Shells zur Verfügung](http://superuser.com/a/183980/7106). So hast du auf dein Setup auch in allen anderen Shellsessions Zugriff. + +- Platziere Einstellungen von Umgebungsvariablen sowie Befehle, welche nach einer Anmeldung ausgeführt werden sollen, in `~/.bash_profile`. Eine separate Konfiguration ist notwendig für Shells, welche du von einer grafischen Benutzeroberfläche startest sowie für `cron`-Jobs. + +- Synchronisiere deine Konfigurationsdateien (etwa `.bashrc` und `.bash_profile`) zwischen mehreren Computern mit Git. + +- Verstehe, dass Vorsicht geboten ist, wenn Variablen und Dateinamen Leerzeichen enthalten. Setze deine Bashvariablen daher mit Anführungszeichen: `"$FOO"`. Bevorzuge die Optionen `-0` oder `-print0`, um ungültige Schriftzeichen zu aktivieren und so Dateinamen zu begrenzen, bspw. `locate -0 pattern | xargs -0 ls -al` oder `find / -print0 -type d | xargs -0 ls -al`. Um in einem "for loop" Dateinamen durchzugehen, die Leerzeichen enthalten, sorge mit `IFS=$'\n'` dafür, dass dein IFS immer auf einer neuen Zeile steht. + +- Benutze in Bash-Skripts `set -x` (oder die Abwandlung `set -v`, welche unverarbeiteten Input akzeptiert, einschließlich Kommentare und unexpandierte Variablen) zum Output der Fehlerbehebung. Benutze "strict modes", es sei denn, gute Gründe sprechen dagegen: Benutze `set -e`, um bei Fehlern abzubrechen ("nonzero exit code"). Benutze `set -u`, um die Verwendung nicht gesetzer Variablen aufzuspüren. Erwäge auch `set -o pipefail` für Fehler in Pipes (lies jedoch mehr zu diesem Thema, wenn du es vorhast, denn es ist ein wenig heikel). Benutze bei komplizierteren Skripts auch `trap` bei EXIT oder ERR. Es ist eine nützliche Angewohnheit, ein Skript folgendermaßen zu beginnen, um Fehler zu erkennen und sie ggf. mit einer entsprechenden Fehlermeldung abzubrechen: +```bash + set -euo pipefail + trap "echo 'error: Script failed: see failed command above'" ERR +``` - In Bash-Skripts stellen Subshells (geschrieben in runden Klammern) einen praktischen Weg dar, Befehle zusammenzufassen. Ein gebräuchliches Beispiel ist die vorübergehende Arbeit in einem anderen Arbeitsverzeichnis: ```bash @@ -115,14 +139,23 @@ Hinweise: - Beachte, dass es in Bash viele Möglichkeiten gibt, Variablen zu erweitern. Überprüfen, ob eine Variable existiert: `${name:?error message}`.Wenn bspw. ein Bash-Skript nur einen einzelnen Parameter benötigt, schreibe einfach `input_file=${1:?usage: $0 input_file}`. Arithmetische Erweiterung: `i=$(( (i + 1) % 5 ))`. Sequenzen: `{1..10}`. Zeichenkette kürzen: `${var%suffix}` und `${var#prefix}`. Wenn bspw. `var=foo.pdf`, dann gibt `echo ${var%.pdf}.txt` die Ausgabe `foo.txt` aus. -- Die Ausgabe eines Befehls kann wie eine Datei behandelt werden mit `<(irgendein befehl)`. Das Vergleichen der lokalen `/etc/hosts` mit einer entfernten: +- Klammererweiterung mittels `{`...`}` kann dafür sorgen, ähnlichen Text seltener wiederholen zu müssen und ermöglicht die Kombination von Objekten. Das ist etwa in Fällen nützlich wie `mv foo.{txt,pdf} zielverzeichnis` (verschiebt beide Dateien), `cp datei{,.bak}` (erweitert den Ausdruck um `cp datei datei.bak`) oder `mkdir -p test-{a,b,c}/subtest-{1,2,3}` (erweitert alle denkbaren Kombinationen und erstellt einen Verzeichnisbaum). + +- Die Ausgabe eines Befehls kann wie eine Datei behandelt werden mit `<(befehl)`. Das Vergleichen der lokalen `/etc/hosts` mit einer entfernten: ```sh diff /etc/hosts <(ssh andererhost cat /etc/hosts) ``` +- Beim Schreiben von Skripts wirst du deinen Code womöglich in geschweifte Klammern setzen wollen. Falls die schließende Klammer fehlt, wird dein Skript aufgrund eines Syntaxfehlers nicht ausgeführt. Das ist etwa dann sinnvoll, wenn es im Internet verfügbar ist, da ein unvollständig heruntergeladenes Skript so an der Ausführung gehindert wird: +```bash +{ + # Hier koennte dein Code stehen! +} +``` + - Kenne "here documents" in Bash, wie etwa in `cat <logfile 2>&1`. Oftmals ist es gute Praxis, einen Befehl an das verwendete Terminal zu binden, um keinen offenen Dateizugriff im standard input zu erzeugen, also `logfile 2>&1`. Oftmals ist es gute Praxis, einen Befehl an das verwendete Terminal zu binden, um keinen offenen Dateizugriff im standard input zu erzeugen, also ` + +- Benutze `sudo`, um einen Befehl als ein anderer Benutzer auszuführen. Standardmäßig ist dies die Ausführung als root; benutze `-u` zur Angabe eines anderen benutzers sowie `-i`, um dich als dieser anzumelden (du wirst nach _deinem_ Passwort gefragt). + +- Benutze `su benutzername` oder `su - benutzername`, um mit der Shell zu einem anderen Benutzer zu wechseln. Füge `-` hinzu, um eine Umgebung zu erhalten, als hättest du dich gerade mit diesem Benutzer angemeldet. Das Weglassen des Benutzernamens führt zur Anmeldung als root. Du wirst gefragt nach dem Passwort _des Benutzers, als der du dich anmelden willst_. + +- Kenne das [128K-Limit](https://wiki.debian.org/CommonErrorMessages/ArgumentListTooLong) der Kommandozeile. Der "Argument list too long"-Fehler erscheint häufig, wenn auf sehr viele Dateien über [Wildcards](https://de.wikipedia.org/wiki/Wildcard_(Informatik)) zugegriffen wird (wenn das passiert, können Alternativen wie `find` und `xargs` helfen). + +- Benutze den `python`-Interpreter als einfachen Taschenrechner (und natürlich für den Zugriff auf Python im Allgemeinen). Beispiel: +``` +>>> 2+3 +5 +``` ## Umgang mit Dateien und Daten @@ -203,7 +250,7 @@ Situationen (wie den Mengen oder Identitätsfunktionen unterhalb) kann man ruhig repren --full --preserve-case --from foo --to bar . ``` -- Nutze `shuf` zum Mischen oder um zufällige Zeilen aus einer Datei auszuwählen. +- Nutze `shuf` zum Mischen oder um zufällige Zeilen aus einer Datei auszuwählen. - Kenne die Optionen von `sort`. Benutze `-n` für Zahlen, oder `-h` um mit menschenlesbaren Zahlen umzugehen (wie z.B. von `du -h`). Sei Dir bewusst, wie Schlüssel funktionieren (`-t` und `-k`). Sei Dir insbesondere bewusst, dass Du `-k1,1` verwenden musst, um bezüglich des ersten Felds zu sortieren;`-k1 bedeutet, sortiere anhand der ganzen Zeile. Stabiles Suchen (`sort -s`) kann ebenfalls nützlich sein. Um beispielsweise primär nach Feld 2 und sekundär nach Feld 1 zu sortieren, kannst Du `sort -k1,1 | sort -s -k2,2` benutzen. @@ -329,7 +376,7 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: - `printenv`: Gebe Umgebungsvariablen aus (nützlich zum Debuggen und für Skripte) -- `look`: finde Englische Worte (oder Zeilen in einer Datei) die mit einer bestimmten Zeichenkette anfangen +- `look`: finde Englische Worte (oder Zeilen in einer Datei) die mit einer bestimmten Zeichenkette anfangen - `cut`, `paste` und `join`: Datenmanipulation @@ -443,7 +490,7 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: - `ss`: Socket Statistiken -- `dmesg`: Bootvorgang und System Fehlermeldungen +- `dmesg`: Bootvorgang und System Fehlermeldungen - `sysctl`: Anzeige und Konfiguration von Linux Kernel Parametern zur Laufzeit @@ -483,10 +530,9 @@ Diese Hinweise sind *nur* für MacOS relevant. - [shellcheck](https://github.com/koalaman/shellcheck) - Ein statisches Analysetool für Shell Skripte. Im Grunde lint für bash/sh/zsh. -## Haftungsausschluss +## Haftungsausschluss -Mit der Ausnahme einiger sehr kleiner Aufgaben ist der Code so geschrieben, dass andere ihn lesen können. Mit Macht kommt Verantwortung. Die Tatsache etwas in Bash tuen zu *können*, heißt nicht -zwangsläufig, dass Du es tuen solltest! +Mit der Ausnahme einiger sehr kleiner Aufgaben ist der Code so geschrieben, dass andere ihn lesen können. Mit Macht kommt Verantwortung. Die Tatsache etwas in Bash tun zu *können*, heißt nicht zwangsläufig, dass Du es tun solltest! ## Lizenz From 612f2f35f14ea16a550d0c224d62d2d3d18de976 Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Tue, 6 Sep 2016 11:41:43 +0200 Subject: [PATCH 16/26] Basics & everyday use sections are up-to-date with current english version --- README-de.md | 90 +++++++++++++++++++++++++++++----------------------- 1 file changed, 51 insertions(+), 39 deletions(-) diff --git a/README-de.md b/README-de.md index 3ec8633..14b69de 100644 --- a/README-de.md +++ b/README-de.md @@ -43,7 +43,7 @@ Umfang: Hinweise: -- Um eine Seite nicht zu sprengen, ist ihr Inhalt durchgängig anhand von Verweisen aufgelistet. Du bist schlau genug, anderswo zusätzliche Informationen nachzuschlagen, sobald du die Idee bzw. den Befehl dahinter kennst. Verwende `apt-get`, `yum`, `dnf`, `pacman`, `pip` oder `brew`, um ggf. neue Programme zu installieren. +- Um eine Seite nicht zu sprengen, ist ihr Inhalt durchgängig anhand von Verweisen aufgelistet. du bist schlau genug, anderswo zusätzliche Informationen nachzuschlagen, sobald du die Idee bzw. den Befehl dahinter kennst. Verwende `apt-get`, `yum`, `dnf`, `pacman`, `pip` oder `brew`, um ggf. neue Programme zu installieren. - Verwende [Explainshell](http://explainshell.com/), um einen hilfreichen Einblick zu erhalten, was es mit Befehlen, Optionen, Pipes etc. auf sich hat. @@ -53,7 +53,7 @@ Hinweise: - Lerne mindestens einen Text-basierten Editor zu benutzen. Idealerweise Vim (`vi`), da es letztlich keinen vergleichbaren Mitbewerber für gelegentliche Einsätze in einem Terminal gibt (selbst dann, wenn man eine große Entwicklungsumgebung wie Emacs oder die meiste Zeit einen modernen Hipster-Editor benutzt). -- Wisse, wie man Dokumentationen mit `man` liest (für Neugierige, `man man` listet Abschnittsnummern, bspw. stehen unter 1 "reguläre" Befehle, 5 beinhaltet Dateien/Konventionen und unter 8 solche zur Rechnerverwaltung). Finde man-Seiten mit `apropos`. Wisse, dass manche Befehle keine ausführbaren Dateien, sondern Bash-Builtins sind, und dass du Hilfe zu diesen mit `help` und `help -d` erhälst. +- Wisse, wie man Dokumentationen mit `man` liest (für Neugierige, `man man` listet Abschnittsnummern, bspw. stehen unter 1 "reguläre" Befehle, 5 beinhaltet Dateien/Konventionen und unter 8 solche zur Rechnerverwaltung). Finde `man`-Seiten ("man pages") mit `apropos`. Wisse, dass manche Befehle keine ausführbaren Dateien, sondern Bash-Builtins sind, und dass du Hilfe zu diesen mit `help` und `help -d` erhälst. - Lerne etwas über die Umleitung von Ein- und Ausgaben per `>` und `<` sowie `|` für Pipes. Wisse, dass `>` die Ausgabedatei überschreibt und `>>` etwas anhängt. Lerne etwas über stdout und stderr. @@ -71,7 +71,7 @@ Hinweise: - Kenne reguläre Ausdrücke gut, und die verschiedenen Statusindikatoren zu `grep`/`egrep`. Die Optionen `-i`, `-o`, `-v`, `-A`, `-B`, und `-C` sind gut zu wissen. -- Lerne den Umgang mit `apt-get`, `yum`, `dnf` oder `pacman` (je nach Distribution), um Pakete zu finden bzw. zu installieren. Und stell sicher, dass du `pip` hast, um Python-basierte Kommandozeilen-Werkzeuge nutzen zu können (einige der untenstehenden werden am einfachsten über `pip` installiert). +- Lerne den Umgang mit `apt-get`, `yum`, `dnf` oder `pacman` (je nach Linux-Distribution), um Pakete zu finden bzw. zu installieren. Und stell sicher, dass du `pip` hast, um Python-basierte Kommandozeilen-Werkzeuge nutzen zu können (einige der untenstehenden werden am einfachsten über `pip` installiert). ## Täglicher Gebrauch @@ -92,7 +92,7 @@ Hinweise: - Um ins vorangegangene Arbeitsverzeichnis zu gelangen: `cd -` -- Wenn du einen Befehl eingibst und es dir auf halbem Wege anders überlegst, drücke **alt-#**, um am Zeilenanfang ein `#` einzufügen und ihn damit als Kommentar auszuweisen (oder benutze **ctrl-a**, **#**, **enter**). Du kannst später über die Befehlsgeschichte zurückgelangen. +- Wenn du einen Befehl eingibst und es dir auf halbem Wege anders überlegst, drücke **alt-#**, um am Zeilenanfang ein `#` einzufügen und ihn damit als Kommentar auszuweisen (oder benutze **ctrl-a**, **#**, **enter**). du kannst später über die Befehlsgeschichte zurückgelangen. - Verwende `xargs` (oder `parallel`). Es ist sehr mächtig. Beachte, wie du viele Dinge pro Zeile (`-L`) als auch parallel (`-P`) ausführen kannst. Wenn du dir nicht sicher bist, ob das Richtige dabei herauskommt, verwende zunächst `xargs echo`. Außerdem ist`-I{}` nützlich. Beispiele: ```bash @@ -194,7 +194,7 @@ Hinweise: - Benutze `sudo`, um einen Befehl als ein anderer Benutzer auszuführen. Standardmäßig ist dies die Ausführung als root; benutze `-u` zur Angabe eines anderen benutzers sowie `-i`, um dich als dieser anzumelden (du wirst nach _deinem_ Passwort gefragt). -- Benutze `su benutzername` oder `su - benutzername`, um mit der Shell zu einem anderen Benutzer zu wechseln. Füge `-` hinzu, um eine Umgebung zu erhalten, als hättest du dich gerade mit diesem Benutzer angemeldet. Das Weglassen des Benutzernamens führt zur Anmeldung als root. Du wirst gefragt nach dem Passwort _des Benutzers, als der du dich anmelden willst_. +- Benutze `su benutzername` oder `su - benutzername`, um mit der Shell zu einem anderen Benutzer zu wechseln. Füge `-` hinzu, um eine Umgebung zu erhalten, als hättest du dich gerade mit diesem Benutzer angemeldet. Das Weglassen des Benutzernamens führt zur Anmeldung als root. du wirst gefragt nach dem Passwort _des Benutzers, als der du dich anmelden willst_. - Kenne das [128K-Limit](https://wiki.debian.org/CommonErrorMessages/ArgumentListTooLong) der Kommandozeile. Der "Argument list too long"-Fehler erscheint häufig, wenn auf sehr viele Dateien über [Wildcards](https://de.wikipedia.org/wiki/Wildcard_(Informatik)) zugegriffen wird (wenn das passiert, können Alternativen wie `find` und `xargs` helfen). @@ -209,19 +209,21 @@ Hinweise: - Um eine Datei im aktuellen Verzeichnis anhand des Namens zu finden, `find . -iname '*irgendwas*'`. Um eine Datei unabhängig vom Verzeichnis anhand des Namens zu finden, verwende `locate irgendwas` (bedenke jedoch, dass `updatedb` kürzlich erstellte Datein möglicherweise noch nicht indexiert hat). -- Für das allgemeine Durchsuchen von (Quell-)Dateien (fortgeschrttener als `grep -r`), verwende [`ag`](https://github.com/ggreer/the_silver_searcher). +- Für das allgemeine durchsuchen von (Quell-)Dateien (fortgeschrttener als `grep -r`), verwende [`ag`](https://github.com/ggreer/the_silver_searcher). - Um HTML in Text zu konvertieren: `lynx -dump -stdin` -- Für Markdown, HTML und viele andere Dokumentkonvertieren, versuch's mit [`pandoc`](http://pandoc.org/). +- Für Markdown, HTML und alle möglichen Arten von Dokumentkonvertierung, versuch's mit [`pandoc`](http://pandoc.org/). - Wenn du mit XML arbeiten musst, `xmlstarlet` ist alt, aber gut. - Für JSON, verwende [`jq`](http://stedolan.github.io/jq/). +- Für YAML gibt's [`shyaml`](https://github.com/0k/shyaml). + - Für Excel- bzw. CSV-Dateien hält [csvkit](https://github.com/onyxfish/csvkit) `in2csv`, `csvcut`, `csvjoin`, `csvgrep`, etc bereit. -- Für Amazon S3 ist [`s3cmd`](https://github.com/s3tools/s3cmd) praktisch und [`s4cmd`](https://github.com/bloomreach/s4cmd) schneller. Amazons [`aws`](https://github.com/aws/aws-cli) ist essentiell für andere AWS-bezogene Aufgaben. +- Für Amazon S3 ist [`s3cmd`](https://github.com/s3tools/s3cmd) praktisch und [`s4cmd`](https://github.com/bloomreach/s4cmd) schneller. Amazons [`aws`](https://github.com/aws/aws-cli) sowie das verbesserte [`saws`](https://github.com/donnemartin/saws) sind essentiell für andere AWS-bezogene Aufgaben. - Kenne `sort` und `uniq`, letzteres einschließlich der Optionen `-u` und `-d` -- siehe die Einzeiler unten. Siehe auch `comm`. @@ -231,49 +233,59 @@ Hinweise: - Kenne `tee`, um von stdin in eine Datei und sogar nach stdout zu kopieren, wie etwa mit `ls -al | tee datei.txt`. -- Sei Dir bewusst, dass die locale Einstellungen viele Kommandozeilenwerkzeuge auf subtile Art und Weise beeinflussen, inklusive der Sortierreihenfolge und ihrer Performanz. Die meisten Linux Installation setzen `LANG` oder andere lokale Variablen auf eine - lokale Einstellung wie z.B. US English. Aber sei Dir bewusst, dass sich das Sortierverhalten ändern wird, falls Du die locale Einstellung änderst. Und wisse, dass i18n Routinen sort und andere Kommandos *um ein Vielfaches* verlangsamen können. In manchen -Situationen (wie den Mengen oder Identitätsfunktionen unterhalb) kann man ruhigen Gewissens langsame i18n Routinen ignorieren und traditionelle byte-basierte Sortierreihenfolge nutzen, indem man `export LC_ALL=C` setzt. +- Bei komplexeren Berechnungen, einschließlich Gruppieren, Tauschen von Feldern und statistische Berechnungen, könnte [`datamash`](https://www.gnu.org/software/datamash/) passend sein. + +- Sei dir bewusst, dass die regionale Spracheinstellung ("locale") viele Kommandozeilenwerkzeuge auf subtile Art und Weise beeinflusst, inklusive der Sortierreihenfolge und ihrer Performance. Die meisten Linux Installation setzen `LANG` oder andere lokale Variablen auf eine lokale Einstellung wie z.B. "US English". Aber sei dir bewusst, dass sich das Sortierverhalten ändern wird, falls du die "locale" änderst. Und wisse, dass "i18n"-Routinen `sort` und andere Kommandos *stark* verlangsamen können. In manchen Situationen (wie den Mengen oder Identitätsfunktionen unterhalb) kann man ruhigen Gewissens langsame "i18n"-Routinen ignorieren und traditionelle byte-basierte Sortierreihenfolge nutzen, indem man `export LC_ALL=C` setzt. + +- Du kannst einem bestimmten Befehl eine Umgebung zuteilen, indem seinem Aufruf die Einstellung der Umgebungsvariable vorangestellt wird, wie hier: `TZ=Pacific/Fiji date`. - Kenne Grundlagen von`awk` und `sed` für einfache Datenverarbeitung. Um z.B. alle Zahlen in der dritten Spalte einer Textdatei aufzusummieren: `awk '{ x += $3 } END { print x }'`. Das ist wahrscheinlich 3X schneller und 3X kürzer als das Python Äquivalent. -- Um alle Vorkommen einer Zeichenkette in einem oder mehreren Dateien zu ersetzen: +- Um mehrere Dateien umzubenennen sowie innerhalb von Dateien zu suchen/ersetzen, probier [`repren`](https://github.com/jlevy/repren) aus (gelegentlich kann man auch mit `rename` mehrere Dateien umbenennen, aber sei vorsichtig, da dessen Funktionsweise je nach Linux-Distribution abweicht). ```sh - perl -pi.bak -e 's/old-string/new-string/g' my-files-*.txt + # Vollständige Umbenennung von Dateinamen, Ordnern und Inhalten - foo -> bar: + repren --full --preserve-case --from foo --to bar . + # Backupdateien wiederherstellen - whatever.bak -> whatever: + repren --renames --from '(.*)\.bak' --to '\1' *.bak + # Wie oben, aber mit rename, sofern verfügbar: + rename 's/\.bak$//' *.bak ``` -- Um mehrere Dateien auf einmal anhand eines Musters umzubennen, nutze `rename`. Für komplexe Umbenennungen könnte [`repren`](https://github.com/jlevy/repren) helfen. +- Wie die `man`-Seite richtig sagt, ist `rsync` ein schnelles und vielseitiges Werkzeug zum Kopieren von Dateien. Es ist bekannt für das Synchronisieren zwischen Rechnern, ist lokal aber ebenso nützlich. Wenn es die Sicherheitsbestimmungen zulassen, erlaubt `rsync` im Gegensatz zu `scp` die Wiederaufnahme einer Übertragung, ohne nochmal von vorn beginnen zu müssen. Es ist zudem einer der [schnellsten Wege](https://web.archive.org/web/20130929001850/http://linuxnote.net/jianingy/en/linux/a-fast-way-to-remove-huge-number-of-files.html), um große Mengen an Dateien zu löschen: ```sh - # Stelle backup Dateien wieder her: foo.bak -> foo: - rename 's/\.bak$//' *.bak - # Komplette Umbenennung von Dateinamen, Verzeichnissen und Inhalten foo -> bar: - repren --full --preserve-case --from foo --to bar . +mkdir leeres-verzeichnis && rsync -r --delete leeres-verzeichnis/ verzeichnis && rmdir verzeichnis ``` -- Nutze `shuf` zum Mischen oder um zufällige Zeilen aus einer Datei auszuwählen. +- Benutze `shuf` zum Mischen oder um zufällige Zeilen aus einer Datei auszuwählen. -- Kenne die Optionen von `sort`. Benutze `-n` für Zahlen, oder `-h` um mit menschenlesbaren Zahlen umzugehen (wie z.B. von `du -h`). Sei Dir bewusst, wie Schlüssel funktionieren (`-t` und `-k`). Sei Dir insbesondere bewusst, dass Du `-k1,1` verwenden musst, um bezüglich des ersten Felds zu sortieren;`-k1 bedeutet, sortiere anhand der ganzen Zeile. Stabiles Suchen (`sort -s`) kann ebenfalls nützlich sein. Um beispielsweise primär nach Feld 2 und sekundär nach Feld 1 zu sortieren, kannst Du `sort -k1,1 | sort -s -k2,2` benutzen. +- Kenne die Optionen von `sort`. Benutze `-n` für Zahlen, oder `-h` um mit menschenlesbaren Zahlen umzugehen (wie z.B. von `du -h`). Sei dir bewusst, wie Schlüssel funktionieren (`-t` und `-k`). Sei dir insbesondere bewusst, dass du `-k1,1` verwenden musst, um bezüglich des ersten Felds zu sortieren;`-k1` bedeutet, sortiere anhand der ganzen Zeile. Stabiles Suchen (`sort -s`) kann ebenfalls nützlich sein. Um bspw. primär nach Feld 2 und sekundär nach Feld 1 zu sortieren, kannst du `sort -k1,1 | sort -s -k2,2` benutzen. -- Falls Du jemals ein Tabulator Literal in eine Kommandozeile in Bash schreiben musst (z.B. für das -t Argument für sort), drücke **ctrl-v** **[Tab]** oder schreibe `$'\t'` (letzteres ist besser, da man es Kopieren/Einfügen kann). +- Falls du jemals ein Tabulator Literal in eine Kommandozeile in Bash schreiben musst (etwa den Parameter `-t` für `sort`), drücke **ctrl-v** **[Tab]** oder schreibe `$'\t'` (letzteres ist besser, da man es Kopieren/Einfügen kann). -- Die Standardwerkzeuge für das Patchen von Quellcode sind `diff` und `patch`. Siehe auch `diffstat`, um zusammenfassende Statistiken eines diffs zu erhalten. Beachte, dass `diff -r` für komplette Verzeichnisse funktioniert. Nutze `diff -r tree1 tree2 | diffstat`, um eine Übersicht aller Änderungen zu bekommen. +- Die Standardwerkzeuge für das Patchen von Quellcode sind `diff` und `patch`. Siehe auch `diffstat`, um zusammenfassende Statistiken eines diffs zu erhalten. Beachte, dass `diff -r` für komplette Verzeichnisse funktioniert. Nutze `diff -r tree1 tree2 | diffstat`, um eine Übersicht aller Änderungen zu bekommen. Benutze `vimdiff`, um Dateien zu vergleichen und zu bearbeiten. -- Für Binärdateien, nutze `hd` für einfache HexDumps und `bvi`, um Binärdateien zu editieren +- Benutze für Binärdateien `hd`, `hexdump` or `xxd` zur Erstellung einfacher [Hexdumps](https://de.wikipedia.org/wiki/Dump#Hexdump) und `bvi` oder `biew` zur binären Bearbeitung. -- Ebenfalls für Binärdateien, `kann strings` (und `grep`, etc.) benutzt werden, um Textpassagen zu finden. +- Ebenfalls für Binärdateien kann `strings` (und `grep`, etc.) benutzt werden, um Textpassagen zu finden. - Um Diffs für Binärdateien zu erstellen (Delta Kompression), nutze `xdelta3`. -- Um zwischen Text Kodierungen zu konvertieren, solltest Du `iconv` probieren. Oder `uconv` für fortgeschrittene Anwendungsfälle; es - unterstüzt einige fortgeschrittene Unicode Dinge. Dieses Kommando beispielsweise wandelt alle Buchstaben in Kleinbuchstaben um und -entfernt alle Akzente (indem sie erweitert und verworfen werden): +- Um zwischen Textkodierungen zu konvertieren, solltest du `iconv` probieren, oder aber `uconv` für fortgeschrittene Anwendungsfälle; es unterstüzt einige fortgeschrittene Unicode-Dinge. Dieses Kommando bspw. wandelt alle Buchstaben in Kleinbuchstaben um und entfernt alle Akzente (indem sie erweitert und verworfen werden): ```sh uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt ``` -- Um Dateien aufzuteilen, siehe `split` (um anhand einer bestimmten Größe zu teilen) und `csplit` (um Anhand eines gewissen Patterns zu teilen). +- Um Dateien aufzuteilen, siehe `split` (Teilung anhand einer bestimmten Größe) und `csplit` (Teilung anhand eines bestimmten Musters). + +- Benutze `zless`, `zmore`, `zcat`, und `zgrep` um mit komprimierten Dateien zu arbeiten. + +- File attributes are settable via `chattr` and offer a lower-level alternative to file permissions. For example, to protect against accidental file deletion the immutable flag: `sudo chattr +i /critical/directory/or/file` -- Benutze `zless`, `zmore`, `zcat`, und `zgrep` um mit komprimierten Dateien zu arbeiten +- Use `getfacl` and `setfacl` to save and restore file permissions. For example: +```sh + getfacl -R /some/path > permissions.txt + setfacl --restore=permissions.txt +``` ## Fehlerbehebung auf Systemebene @@ -282,9 +294,9 @@ entfernt alle Akzente (indem sie erweitert und verworfen werden): - Um den Festplatten/CPU/Netzwerk Status zu erfahren, nutze `iostat`, `netstat`, `top` (oder das bessere `htop`), und (besonders) `dstat`. Gut um eine grobe Übersicht darüber zu bekommen, was sich auf einem System abspielt. -- Für eine tiefgreifendere Systemübersicht, nutze [`glances`](https://github.com/nicolargo/glances). Es zeigt Dir einige System Statistiken in einem Terminalfenster an. Sehr hilfreich, um schnell mehrere Subsysteme überprüfen zu können. +- Für eine tiefgreifendere Systemübersicht, nutze [`glances`](https://github.com/nicolargo/glances). Es zeigt dir einige System Statistiken in einem Terminalfenster an. Sehr hilfreich, um schnell mehrere Subsysteme überprüfen zu können. -- Um den Zustand des Speichers zu kennen, solltest Du `free` und `vmstat` ausführen und die Ausgabe verstehen. Sei Dir insbesondere bewusst, dass der "cached" Wert, der Wert ist, der vom Linux Kernel als Datei Cache genutzt wird, so dieser effektiv als zum +- Um den Zustand des Speichers zu kennen, solltest du `free` und `vmstat` ausführen und die Ausgabe verstehen. Sei dir insbesondere bewusst, dass der "cached" Wert, der Wert ist, der vom Linux Kernel als Datei Cache genutzt wird, so dieser effektiv als zum Wert "free" addiert werden kann. - Java Systeme zu debuggen ist ein anderes Paar Schuhe, aber ein simpler Trick für die Oracle JVM (der teilweise auch für andere JVMs funktioniert) ist `kill -3 `, so dass ein vollständiger Strack trace und Heap Informationen (inklusive Garbage Collection @@ -294,13 +306,13 @@ entfernt alle Akzente (indem sie erweitert und verworfen werden): - Beim Nachsehen, warum die Festplatte voll ist, spart `ncdu` Zeit gegenüber den üblichen Kommandos wie `du -sh *`. -- Um herauszufunden, welcher Socket oder Prozess Bandbreite verbraucht, solltest Du `iftop` oder `nethogs` verwenden. +- Um herauszufunden, welcher Socket oder Prozess Bandbreite verbraucht, solltest du `iftop` oder `nethogs` verwenden. -- Das `ab` Werkzeug (ein Teil vom Apache) ist hilfreich, um schnell und pragmatisch die Performanz eines Webservers zu messen. Für komplexere Messungen solltest Du`siege` ausprobieren. +- Das `ab` Werkzeug (ein Teil vom Apache) ist hilfreich, um schnell und pragmatisch die Performanz eines Webservers zu messen. Für komplexere Messungen solltest du`siege` ausprobieren. - Für eine tiefergehende Netzwerk Problemsuche, `wireshark`, `tshark`, oder `ngrep`. -- Kenne `strace` und `ltrace`. Diese können hilfreich sein, falls ein Programm fehlschlägt, hängt, oder abstürzt und Du weißt nicht warum, oder um einen generellen Eindruck von der Performanz zu bekommen. Beachte die Profiling Option(`-c`), und die Fähigkeit, +- Kenne `strace` und `ltrace`. Diese können hilfreich sein, falls ein Programm fehlschlägt, hängt, oder abstürzt und du weißt nicht warum, oder um einen generellen Eindruck von der Performanz zu bekommen. Beachte die Profiling Option(`-c`), und die Fähigkeit, sich zu laufen Prozessen zu verbinden (`-p`). - Kenne `ldd` um Shared Libraries zu überprüfen. @@ -311,9 +323,9 @@ entfernt alle Akzente (indem sie erweitert und verworfen werden): - Bei der Problemfindung, warum etwas in der Vergangenheit schief gelaufen ist, kann `sar` sehr hilfreich sein. Es zeigt historische Statistiken über CPU, Speicher, Netzwerk, etc. -- Für eine genauere System und Performanceanalyse, solltest Du Dir `stap` ([SystemTap](https://sourceware.org/systemtap/wiki)), [`perf`](http://en.wikipedia.org/wiki/Perf_(Linux)), und [`sysdig`](https://github.com/draios/sysdig) ansehen. +- Für eine genauere System und Performanceanalyse, solltest du dir `stap` ([SystemTap](https://sourceware.org/systemtap/wiki)), [`perf`](http://en.wikipedia.org/wiki/Perf_(Linux)), und [`sysdig`](https://github.com/draios/sysdig) ansehen. -- Finde heraus, welches Betriebssystem Du nutzt mittels `uname` oder `uname -a` (allgemeine Unix/Kernelinformationen) oder `lsb_release -a` (Linux Distribution Informationen) +- Finde heraus, welches Betriebssystem du nutzt mittels `uname` oder `uname -a` (allgemeine Unix/Kernelinformationen) oder `lsb_release -a` (Informationen zur verwendeten Linux-Distribution) - Benutze `dmesg` wenn sich etwas merkdwürdig verhält (es könnte ein Hardware oder Treiber Problem sein) @@ -348,7 +360,7 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: cat access.log | egrep -o 'acct_id=[0-9]+' | cut -d= -f2 | sort | uniq -c | sort -rn ``` -- Um durchgehend Änderungen zu überwachen, solltest Du "watch" benutzen; z.B. Dateiänderungen in einem Verzeichnis können mittels `watch -d -n 2 'ls -rtlh | tail'` überwacht werden, während Du Deine Wifi Einstellungen mittels `watch -d -n 2 ifconfig` auf Fehler überprüfen kannst. +- Um durchgehend Änderungen zu überwachen, solltest du "watch" benutzen; z.B. Dateiänderungen in einem Verzeichnis können mittels `watch -d -n 2 'ls -rtlh | tail'` überwacht werden, während du Deine Wifi Einstellungen mittels `watch -d -n 2 ifconfig` auf Fehler überprüfen kannst. - Führe diese Funktion aus, um einen zufälligen Tip aus diesem Dokument zu erhalten(parst das Markdown Dokument und extrahiert ein Element) ```sh @@ -496,7 +508,7 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: - `hdparm`: SATA/ATA Festplatten Manipulation/Performanceinformationen -- `lsb_release`: Informationen über die Linux Distribution +- `lsb_release`: Informationen über die verwendete Linux-Distribution - `lsblk`: Auflisten von block devices: eine Baumansicht deiner Festplatten und Partitionen @@ -532,7 +544,7 @@ Diese Hinweise sind *nur* für MacOS relevant. ## Haftungsausschluss -Mit der Ausnahme einiger sehr kleiner Aufgaben ist der Code so geschrieben, dass andere ihn lesen können. Mit Macht kommt Verantwortung. Die Tatsache etwas in Bash tun zu *können*, heißt nicht zwangsläufig, dass Du es tun solltest! +Mit der Ausnahme einiger sehr kleiner Aufgaben ist der Code so geschrieben, dass andere ihn lesen können. Mit Macht kommt Verantwortung. Die Tatsache etwas in Bash tun zu *können*, heißt nicht zwangsläufig, dass du es tun solltest! ## Lizenz From a06c3396dcffaa90b5b80d8936c687617f8f5a4c Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Tue, 6 Sep 2016 12:08:51 +0200 Subject: [PATCH 17/26] System debugging section is up-to-date with current english version --- README-de.md | 39 +++++++++++++++++++-------------------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/README-de.md b/README-de.md index 14b69de..842b60a 100644 --- a/README-de.md +++ b/README-de.md @@ -190,8 +190,6 @@ Hinweise: - Verwende für einen einfachen Webserver für alle Dateien im aktuellen Verzeichnis (sowie Unterverzeichnisse), der für alle in deinem Netzwerk abrufbar ist: `python -m SimpleHTTPServer 7777` (für Port 7777 und Python 2) sowie `python -m http.server 7777` (für Port 7777 und Python 3). - - - Benutze `sudo`, um einen Befehl als ein anderer Benutzer auszuführen. Standardmäßig ist dies die Ausführung als root; benutze `-u` zur Angabe eines anderen benutzers sowie `-i`, um dich als dieser anzumelden (du wirst nach _deinem_ Passwort gefragt). - Benutze `su benutzername` oder `su - benutzername`, um mit der Shell zu einem anderen Benutzer zu wechseln. Füge `-` hinzu, um eine Umgebung zu erhalten, als hättest du dich gerade mit diesem Benutzer angemeldet. Das Weglassen des Benutzernamens führt zur Anmeldung als root. du wirst gefragt nach dem Passwort _des Benutzers, als der du dich anmelden willst_. @@ -292,43 +290,44 @@ mkdir leeres-verzeichnis && rsync -r --delete leeres-verzeichnis/ verzeichnis && - Zur Fehlersuche bei Webanwendungen sind `curl` und `curl -I` hilfreich, ebenso wie ihre `wget` Äquivalente oder das modernere [`httpie`](https://github.com/jakubroztocil/httpie). -- Um den Festplatten/CPU/Netzwerk Status zu erfahren, nutze `iostat`, `netstat`, `top` (oder das bessere `htop`), und (besonders) `dstat`. Gut um eine grobe Übersicht darüber zu bekommen, was sich auf einem System abspielt. +- Um den aktuellen CPU-/Festplattenstatus zu erfahren, sind die Klassiker `top` (oder das bessere `htop`), `iostat` und `iotop`. Benutze `iostat -mxz 15` for basic CPU and detailed per-partition disk stats and performance insight. + +- Benutze für Informationen zu Netzwerkverbindungen `netstat` und `ss`. -- Für eine tiefgreifendere Systemübersicht, nutze [`glances`](https://github.com/nicolargo/glances). Es zeigt dir einige System Statistiken in einem Terminalfenster an. Sehr hilfreich, um schnell mehrere Subsysteme überprüfen zu können. +- Für eine schnelle Übersicht, was sich auf einem System abspielt, ist `dstat` sehr nützlich. Für einen guten Gesamtüberblick bietet sich zudem [`glances`](https://github.com/nicolargo/glances) an. -- Um den Zustand des Speichers zu kennen, solltest du `free` und `vmstat` ausführen und die Ausgabe verstehen. Sei dir insbesondere bewusst, dass der "cached" Wert, der Wert ist, der vom Linux Kernel als Datei Cache genutzt wird, so dieser effektiv als zum - Wert "free" addiert werden kann. +- Um den Zustand des Speichers zu erfahren, führst du am besten `free` und `vmstat` aus und verstehst deren Ausgabe. Sei dir insbesondere bewusst, dass der "cached"-Wert jener Wert ist, der vom Linux-Kernel als Dateicache genutzt wird, da dieser effektiv als zum "free"-Wert addiert werden kann. -- Java Systeme zu debuggen ist ein anderes Paar Schuhe, aber ein simpler Trick für die Oracle JVM (der teilweise auch für andere JVMs funktioniert) ist `kill -3 `, so dass ein vollständiger Strack trace und Heap Informationen (inklusive Garbage Collection - Details, die sehr informativ sein können) nach stderr/logs ausgegeben werden. Die JDK Befehle `jps`, `jstat`, `jstack`, `jmap` are useful. [SJK tools](https://github.com/aragozin/jvm-tools) sind noch weiter fortgeschritten. +- Fehlerbehebung ("debugging") auf Java-Systemen ist ein anderes Paar Schuhe, aber ein simpler Trick für die Oracle JVM (der teilweise auch für andere JVMs funktioniert) ist `kill -3 `, sodass ein vollständiger Strack trace und Heap Informationen (inklusive Garbage Collection Details, die sehr informativ sein können) nach stderr/logs ausgegeben werden. Die JDK-Befehle `jps`, `jstat`, `jstack`, `jmap` sind ebenfalls nützlich. [SJK-Werkzeuge](https://github.com/aragozin/jvm-tools) sind noch weiter fortgeschritten. -- Benutze `mtr` als ein besseres traceroute, um Netzwerk Probleme zu identifizieren. +- Benutze [`mtr`](http://www.bitwizard.nl/mtr/) als ein besseres traceroute, um Netzwerkprobleme zu identifizieren. -- Beim Nachsehen, warum die Festplatte voll ist, spart `ncdu` Zeit gegenüber den üblichen Kommandos wie `du -sh *`. +- Willst du wissen, warum eine Festplatte voll ist, dann spart [`ncdu`](https://dev.yorhel.nl/ncdu) Zeit gegenüber den üblichen Befehlen wie `du -sh *`. -- Um herauszufunden, welcher Socket oder Prozess Bandbreite verbraucht, solltest du `iftop` oder `nethogs` verwenden. +- Um herauszufunden, welcher Socket oder Prozess Bandbreite verbraucht, kannst du [`iftop`](http://www.ex-parrot.com/~pdw/iftop/) oder [`nethogs`](https://github.com/raboof/nethogs) verwenden. -- Das `ab` Werkzeug (ein Teil vom Apache) ist hilfreich, um schnell und pragmatisch die Performanz eines Webservers zu messen. Für komplexere Messungen solltest du`siege` ausprobieren. +- Das `ab`-Werkzeug (ein Teil vom Apache) ist hilfreich, um schnell und pragmatisch die Performance eines Webservers zu messen. Für komplexere Messungen kannst du `siege` ausprobieren. -- Für eine tiefergehende Netzwerk Problemsuche, `wireshark`, `tshark`, oder `ngrep`. +- Für eine tiefergehende Netzwerk Problemsuche, [`wireshark`](https://wireshark.org/), [`tshark`](https://www.wireshark.org/docs/wsug_html_chunked/AppToolstshark.html), oder [`ngrep`](http://ngrep.sourceforge.net/). -- Kenne `strace` und `ltrace`. Diese können hilfreich sein, falls ein Programm fehlschlägt, hängt, oder abstürzt und du weißt nicht warum, oder um einen generellen Eindruck von der Performanz zu bekommen. Beachte die Profiling Option(`-c`), und die Fähigkeit, - sich zu laufen Prozessen zu verbinden (`-p`). +- Kenne `strace` und `ltrace`. Diese können hilfreich sein, falls ein Programm fehlschlägt, hängt oder abstürzt und du weißt nicht warum, oder um einen generellen Eindruck von der Performance zu bekommen. Beachte die Profiling-Option (`-c`) und die Fähigkeit, sich mit laufenden Prozessen zu verbinden (`-p`). -- Kenne `ldd` um Shared Libraries zu überprüfen. +- Kenne `ldd`, um "shared libraries" zu überprüfen. -- Sei in der Lage, sich zu einem laufenden Prozess mittels `gdb` zu verbinden und die Stack Traces zu holen. +- Sei in der Lage, dich mittels `gdb` mit einem laufenden Prozess zu verbinden und dessen "stack traces" zu holen. -- Benutze `/proc`. Es ist manchmal unglaublich hilfreich, um Probleme in Echtzeit zu debuggen. Beispiele: `/proc/cpuinfo`, `/proc/meminfo`, `/proc/cmdline`, `/proc/xxx/cwd`, `/proc/xxx/exe`, `/proc/xxx/fd/`, `/proc/xxx/smaps` (wobei `xxx` die Prozess Id /pid ist). +- Benutze `/proc`. Es ist manchmal unglaublich hilfreich, um Probleme in Echtzeit zu debuggen. Beispiele: `/proc/cpuinfo`, `/proc/meminfo`, `/proc/cmdline`, `/proc/xxx/cwd`, `/proc/xxx/exe`, `/proc/xxx/fd/`, `/proc/xxx/smaps` (wobei `xxx` die Prozess-ID / pid ist). -- Bei der Problemfindung, warum etwas in der Vergangenheit schief gelaufen ist, kann `sar` sehr hilfreich sein. Es zeigt historische Statistiken über CPU, Speicher, Netzwerk, etc. +- Bei der Frage, warum in der Vergangenheit etwas schief gelaufen ist, kann [`sar`](http://sebastien.godard.pagesperso-orange.fr/) sehr hilfreich sein. Es zeigt historische Statistiken über CPU, Speicher, Netzwerk, etc. - Für eine genauere System und Performanceanalyse, solltest du dir `stap` ([SystemTap](https://sourceware.org/systemtap/wiki)), [`perf`](http://en.wikipedia.org/wiki/Perf_(Linux)), und [`sysdig`](https://github.com/draios/sysdig) ansehen. -- Finde heraus, welches Betriebssystem du nutzt mittels `uname` oder `uname -a` (allgemeine Unix/Kernelinformationen) oder `lsb_release -a` (Informationen zur verwendeten Linux-Distribution) +- Finde heraus, welches Betriebssystem du nutzt mittels `uname` oder `uname -a` (allgemeine Unix-/Kernelinformationen) oder `lsb_release -a` (Informationen zur verwendeten Linux-Distribution) - Benutze `dmesg` wenn sich etwas merkdwürdig verhält (es könnte ein Hardware oder Treiber Problem sein) +- Wenn du eine Datei löschst, jedoch laut `du` nicht der erwartete Festplattenspeicher frei wird, dann überprüfe, ob die Datei von einem Prozess verwendet wird: `lsof | grep deleted | grep "dateiname"` + ## Einzeiler From 618e3f8dbb9099de394d0e08fa3edabcbc508e14 Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Tue, 6 Sep 2016 12:27:32 +0200 Subject: [PATCH 18/26] One-liner section is up-to-date with current english version --- README-de.md | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/README-de.md b/README-de.md index 842b60a..fb5d687 100644 --- a/README-de.md +++ b/README-de.md @@ -333,20 +333,18 @@ mkdir leeres-verzeichnis && rsync -r --delete leeres-verzeichnis/ verzeichnis && Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: -- Manchmal ist es unglaublich hilfreich, dass man die Schnittmenge, Vereinigung und den Unterschied zwischen Textdateien via `sort`/`uniq` bilden kann. Angenommen a und b sind Textdateien, die bereits "unique" sind. Diese Herangehensweise ist schnell, funktioniert mit Dateien beliebiger Größe, bis zu mehreren Gigabytes (Sort ist nicht durch Speicher beschränkt, obwohl man eventuell die `-T` Option nutzen muss, falls `/tmp` auf einer kleinen root partition liegt.) Siehe auch die Bemerkung über `LC_ALL` weiter oben und die `sort`'s `-u` Option (wurde oben aus Gründen der Übersichtlichkeit ausgelassen). +- Manchmal ist es unglaublich hilfreich, dass man die Schnittmenge, Vereinigung und den Unterschied zwischen Textdateien via `sort`/`uniq` bilden kann. Angenommen, a und b sind Textdateien, die bereits "unique" sind. Diese Herangehensweise ist schnell und funktioniert mit Dateien beliebiger Größe, bis zu mehreren Gigabytes (`sort` ist nicht durch Speicher beschränkt, obwohl man eventuell die `-T`-Option nutzen muss, falls `/tmp` auf einer kleinen Root-Partition liegt). Siehe auch die Bemerkung über `LC_ALL` weiter oben und die `-u`-Option von `sort` (wurde oben aus Gründen der Übersichtlichkeit ausgelassen). ```sh cat a b | sort | uniq > c # c ist a vereint mit b cat a b | sort | uniq -d > c # c ist a geschnitten b cat a b b | sort | uniq -u > c # c ist die Menge mit unterschiedlichen Elementen a - b ``` -- Benutze `grep . *` um alle Inhalte aller Dateien in einem Verzeichnis anzuzeigen, z.B. für Verzeichnisse, die mit Konfigurationen - gefüllt sind wie `/sys`, `/proc`, `/etc`. +- Eine schnelle Überprüfung der Inhalte aller Dateien in einem Verzeichnis erreichst du mit `grep . *` (damit enthält jede Zeile den Dateinamen) oder `head -100 *` (damit erhält jede Datei eine Überschrift). Dies kann nützlich sein für Verzeichnisse, die Konfigurationsdateien enthalten wie jene in `/sys`, `/proc` und `/etc`. -- Alle Zahlen in der dritten Spalte einer Textdatei aufsummieren(dieser Ansatz ist wahrscheinlich 3x schneller und 3x weniger Code als - das Äquivalent in python): +- Alle Zahlen in der dritten Spalte einer Textdatei aufsummieren (dieser Ansatz ist wahrscheinlich dreimal schneller und enthält dreimal weniger Code als dessen Entsprechung in Python): ```sh - awk '{ x += $3 } END { print x }' myfile + awk '{ x += $3 } END { print x }' meinedatei ``` - Falls man die Größen/Datumsangaben von einem Dateibaum wissen möchte, funktioniert das Folgende wie ein rekursives `ls -l`, aber ist @@ -354,6 +352,12 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: ```sh find . -type f -ls ``` + +- Um Größen/Datumsangaben in einem Verzeichnisbaum zu sehen, wirkt dies wie ein umgedrehtes `ls -l`, ist aber einfacher zu lesen als `ls -lR`: +```sh + find . -type f -ls +``` + - Angenommen innerhalb einer Textdatei, so wie ein server web log, tauch ein gewisser Wert in manchen Zeilen auf, wie z.B. ein `acct_id` Parameter in der URL. Falls eine Aufzählung gewünscht ist, wie viele Anfragen es jeweils für eine `acct_id` gibt: ```sh cat access.log | egrep -o 'acct_id=[0-9]+' | cut -d= -f2 | sort | uniq -c | sort -rn From 04ca2e85092ddd0dd0e3ff04bc87ec85363e91fa Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Tue, 6 Sep 2016 13:13:47 +0200 Subject: [PATCH 19/26] Obscure, MACOSX and Windows sections are up-to-date with current english version --- README-de.md | 114 ++++++++++++++++++++++++++++++++++----------------- 1 file changed, 77 insertions(+), 37 deletions(-) diff --git a/README-de.md b/README-de.md index fb5d687..470b6bb 100644 --- a/README-de.md +++ b/README-de.md @@ -379,19 +379,19 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: ## Eigenartig aber hilfreich -- `expr`: Führe arithmetische oder boolsche Operationen aus oder werte reguläre Ausdrücke aus +- `expr`: Führe arithmetische oder bool'sche Operationen aus oder werte reguläre Ausdrücke aus - `m4`: Simpler Macro Auswerter - `yes`: Gebe eine Zeichenkette sehr oft aus -- `cal`: netter Kalender +- `cal`: Netter Kalender - `env`: Führe ein Kommando aus (nützlich für Skripte) - `printenv`: Gebe Umgebungsvariablen aus (nützlich zum Debuggen und für Skripte) -- `look`: finde Englische Worte (oder Zeilen in einer Datei) die mit einer bestimmten Zeichenkette anfangen +- `look`: Finde englische Worte (oder Zeilen in einer Datei), die mit einer bestimmten Zeichenkette anfangen - `cut`, `paste` und `join`: Datenmanipulation @@ -403,7 +403,7 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: - `column`: Formatiere Textfelder als bündige Spalten oder Tabellen mit fester Größe -- `expand` and `unexpand`: Konvertiere zwischen Tabs und Spaces +- `expand` und `unexpand`: Konvertiere zwischen Tabs und Spaces - `nl`: Füge Zeilennummern hinzu @@ -427,13 +427,19 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: - `file`: Identifiziere den Typ einer Datei -- `tree`: Zeige Verzeichnisse und Unterverzeichnisse als verschachtelten Baum; wie 'ls' aber rekursiv +- `tree`: Zeige Verzeichnisse und Unterverzeichnisse als verschachtelten Baum; wie `ls` aber rekursiv - `stat`: Datei Infomationen -- `time`: Führe ein Kommando aus und messe die Zeit +- `time`: Führe einen Befehl aus und messe die Zeit -- `watch`: führe ein Kommando wiederholt aus, wobei die Ergebnisse angezeigt und/oder Änderungen hervorgehoben werden +- `timeout`: Führe einen Befehl für eine bestimmte Zeit aus und beende ihn anschließend wieder + +- `lockfile`: Erstelle eine Semaphordatei, die nur gelöscht werden kann mit `rm -f` + +- `logrotate`: Rotiert, komprimiert und mailt System-Log-Dateien + +- `watch`: Führe einen Befehl wiederholt aus, wobei die Ergebnisse angezeigt und/oder Änderungen hervorgehoben werden - `tac`: Gebe Dateien in umgekehrter Reihenfolge aus @@ -443,45 +449,47 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: - `pv`: Überwache den Fortschritt von Daten durch eine Pipe -- `hd` und `bvi`: Ausgabe und Editieren von Binärdateien +- `hd`, `hexdump`, `xxd`, `biew` und `bvi`: Ausgabe und Editieren von Binärdateien - `strings`: Text aus Binärdateien extrahieren -- `tr`: Buchstabenübersetzung und Manipulation +- `tr`: Buchstabenübersetzung und -manipulation - `iconv` oder `uconv`: Konvertierung von Zeichensätzen - `split` und `csplit`: Dateien aufteilen -- `sponge`: liest die gesamte Eingabe, bevor sie wieder ausgegeben wird. Nützlich um aus der selben Datei zu lesen und in diese zu schreiben, z.B. `grep -v irgendwas irgendeine-datei | sponge irgendeine-datei` +- `sponge`: Liest die gesamte Eingabe, bevor sie wieder ausgegeben wird. Nützlich, um aus derselben Datei zu lesen und in diese zu schreiben, bspw. `grep -v irgendwas irgendeine-datei | sponge irgendeine-datei` - `units`: Einheiten Konvertierungen und Berechnungen; konvertiert Furlong(Achtelmeile)/Fortnights(2 Wochen) zu twips/blink (siehe `/usr/share/units/definitions.units`) -- `7z`: hochperformante Dateikomprimierung +- `apg`: Generiert zufällige Passwörter + +- `xz`: Hochgradige Dateikompression - `ldd`: Informationen zu dynamisch gelinkten Bibliotheken - `nm`: Symbole aus Objektdateien anzeigen -- `ab`: Web Server benchmarken +- `ab`: Webserver benchmarken - `strace`: Debugging von Syscalls -- `mtr`: ein besseres "traceroute" zum Netzwerk debuggen +- [`mtr`](http://www.bitwizard.nl/mtr/): Ein besseres "traceroute" zum Netzwerk-Debugging -- `cssh`: visuelle, nebenläufige Shell +- `cssh`: Visuelle, nebenläufige Shell -- `rsync`: synchronisiere Dateien und Ordner über SSH oder im lokalen Dateisystem +- `rsync`: Synchronisiere Dateien und Ordner über SSH oder im lokalen Dateisystem -- `wireshark` und `tshark`: Pakete aufzeichnen und Netzwerk Debugging +- [`wireshark`](https://wireshark.org/) and [`tshark`](https://www.wireshark.org/docs/wsug_html_chunked/AppToolstshark.html): Pakete aufzeichnen und Netzwerk-Debugging -- `ngrep`: grep für die Netzwerk Schicht +- [`ngrep`](http://ngrep.sourceforge.net/): grep für die Netzwerkschicht -- `host` und `dig`: DNS Auflösung +- `host` und `dig`: DNS-Auflösung - `lsof`: Prozess Datei Deskriptor und Socket Informationen -- `dstat`: nützliche Systemstatistiken +- `dstat`: Nützliche Systemstatistiken - [`glances`](https://github.com/nicolargo/glances): Grobe Übersicht über zahlreiche Subsysteme @@ -491,36 +499,35 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: - `vmstat`: Speicher Nutzungsstatistiken -- `htop`: eine verbesserte Version von top +- `htop`: Verbesserte Version von `top` -- `last`: Login Verlauf +- `last`: Loginverlauf -- `who`: wer ist gerade angemeldet +- `who`: Wer gerade angemeldet ist -- `id`: Benutzer/Gruppen Identitätsinformationen +- `id`: Identitätsinformationen zu Benutzern/Gruppen -- `sar`: Historische System Statistiken +- [`sar`](http://sebastien.godard.pagesperso-orange.fr/): Historische Systemstatistiken -- `iftop` oder `nethogs`: Netzwerknutzung durch Sockets oder Prozesse +- [`iftop`](http://www.ex-parrot.com/~pdw/iftop/) or [`nethogs`](https://github.com/raboof/nethogs): Netzwerknutzung durch Sockets oder Prozesse -- `ss`: Socket Statistiken +- `ss`: Socket-Statistiken - `dmesg`: Bootvorgang und System Fehlermeldungen - `sysctl`: Anzeige und Konfiguration von Linux Kernel Parametern zur Laufzeit -- `hdparm`: SATA/ATA Festplatten Manipulation/Performanceinformationen - -- `lsb_release`: Informationen über die verwendete Linux-Distribution +- `hdparm`: SATA/ATA-Festplattenmanipulation/-performanceinformationen -- `lsblk`: Auflisten von block devices: eine Baumansicht deiner Festplatten und Partitionen +- `lsblk`: Auflisten von block devices: eine Baumansicht deiner Festplatten und Partitionen -- `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: hardware informationen, inklusive CPU, BIOS, RAID, Grafikkarten, Geräte, etc. +- `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: Hardware-Informationen, inklusive CPU, BIOS, RAID, Grafikkarten, Geräte, etc. - `lsmod` und `modinfo`: Auflisten und Details anzeigen von Kernel Modulen - `fortune`, `ddate`, und `sl`: ähm ja, kommt darauf an, ob man Dampflokomotiven und flotte Zitate "nützlich" findet + ## Nur MacOS X Diese Hinweise sind *nur* für MacOS relevant. @@ -529,26 +536,59 @@ Diese Hinweise sind *nur* für MacOS relevant. - Kopiere die Ausgabe jedes Kommandos an eine Desktop App mit `pbcopy` und füge die Eingabe von einer solchen ein mit `pbpaste`. -- Um die Option Taste als alt Taste in einer Mac OS Konsole zu nutzen (so wie in den obrigen Kommandos wie **alt-b**, **alt-f**, etc.), öffne Einstellungen -> Profile -> Tastatur und aktiviere - "Benutze Option Taste als Meta Taste" +- Um die Option Taste als alt-Taste in einer Mac OS Konsole zu nutzen (so wie in den obrigen Befehle wie **alt-b**, **alt-f**, etc.), öffne Einstellungen -> Profile -> Tastatur und aktiviere "Benutze Option Taste als Meta Taste" - Um eine Datei mit einer Desktopanwendung zu öffnen, kann man `open` oder `open -a /Applications/Whatever.app` benutzen. - Spotlight: Dateisuche mit `mdfind` und Ausgabe von Metadaten (wie z.B. photo EXIF info) mit `mdls`. -- Man sollte sich bewusst sein, dass MacOS auf BSD Unix basiert und sich viele Kommandos (wie z.B. `ps`, `ls`, `tail`, `awk`, `sed`) bezüglich subtiler Kleinigkeiten von Linux, dass stark von System V-style Unix und GNU tools beeinflusst ist, unterscheiden. Oft kann man den Unterschied daran erkennen, dass eine man page die Überschrift "BSD General Commands Manual" trägt. In manchen Fällen kann auch die GNU version installiert werden (wie z.B. bei `gawk` und `gsed` für GNU awk und sed). Falls man cross-platform Bash Skripte schreiben möchte, sollte man solche Kommandos vermeiden (und z.B. Python oder `perl` in Betracht ziehen) oder sorgfätig testen. +- Man sollte sich bewusst sein, dass MacOS auf BSD Unix basiert und sich viele Befehle (wie z.B. `ps`, `ls`, `tail`, `awk`, `sed`) bezüglich subtiler Kleinigkeiten von Linux, das stark von System V-style Unix und GNU tools beeinflusst ist, unterscheiden. Oft kann man den Unterschied daran erkennen, dass eine `man`-Seite die Überschrift "BSD General Commands Manual" trägt. In manchen Fällen kann auch die GNU-Version installiert werden (wie z.B. bei `gawk` und `gsed` für GNU awk und sed). Falls manplattformübergreifende Bash-Skripte schreiben möchte, sollte man solche Kommandos vermeiden (und z.B. Python oder `perl` in Betracht ziehen) oder sorgfätig testen. + +- Benutze `sw_vers` für OS X Systeminformationen. + + +## Nur Windows + +Diese Hinweise sind *nur* für Windows relevant. + +- Mit Windows 10 kannst du [Bash on Ubuntu on Windows](https://msdn.microsoft.com/commandline/wsl/about) benutzen, das eine vertraute Bash-Umgebung mit Unix-Kommandozeilenwerkzeugen. Dies erlaubt einerseits die Nutzung von Linux-Programmen auf Windows, unterstützt andererseits jedoch nicht die Ausführung von Windows-Programmen von der Bash-Konsole. + +- Zugriff auf die Macht der Unix-Shell erhälst du unter Microsoft Windows durch die Installation von [Cygwin](https://cygwin.com/). Die meisten hier beschriebenen Dinge funktionieren damit ohne weiteren Aufwand. + +- Installiere zusätzliche Unix-Programme mit Cygwins Paketmanager. + +- Benutze `mintty` als dein Kommandozeilenfenster. + +- Greife mit `/dev/clipboard` auf die Zwischenablage von Windows zu. + +- Öffne beliebige Dateien über `cygstart` mit deren Standardprogramm. + +- Greife mit `regtool` auf die Windows-Registry zu. + +- Beachte, dass der Windows-Pfad `C:\` unter Cygwin zu `/cygdrive/c` wird und dass Cygwins `/` unter Windows als `C:\cygwin` verfügbar ist. Für die Umwandlung zwischen Cygwin- und Windows-Pfaden steht `cygpath` zur Verfügung. Dies ist inbesondere für Skripte nützlich, welche Windows-Programme ausführen. + +- Du kannst die meisten Aufgaben der Windows-Systemverwaltung von der Kommandozeile ausführen und skripten, indem du den Umgang mit `wmic` lernst. + +- Eine andere Möglichkeit, ein wenig Unix auf dein Windows-System zu bringen, bietet [Cash](https://github.com/dthree/cash). Beachte allerdings, dass nur sehr wenige Unix-Befehle und Kommandozeilen-Optionen in dieser Umgebung zur Verfügung stehen. + +- Eine weitere Option, GNU-Entwicklerwerkzeuge (etwa GCC) auf Windows zu nutzen, besteht darin, [MinGW](http://www.mingw.org/) und dessen Paket [MSYS](http://www.mingw.org/wiki/msys), das Hilfsprogramme wie bash, gawk, make and grep beinhaltet, zu installieren. MSYS bringt allerdings nicht so viele Features mit wie etwa Cygwin. MinGW ist besonders nützlich für die Erstellung nativer Windows-Ports von Unix-Werkzeugen. + ## Weitere Quellen -- [awesome-shell](https://github.com/alebcay/awesome-shell): Eine hilfreiche Liste von Shell Werkzeugen und Quellen -- [Strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/) um bessere Shell Skripte zu schreiben -- [shellcheck](https://github.com/koalaman/shellcheck) - Ein statisches Analysetool für Shell Skripte. Im Grunde lint für bash/sh/zsh. +- [awesome-shell](https://github.com/alebcay/awesome-shell): Eine hilfreiche Liste von Shell-Werkzeugen und Quellen. +- [awesome-osx-command-line](https://github.com/herrbischoff/awesome-osx-command-line): A more in-depth guide for the OS X command line. +- [Strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/), um bessere Shell-Skripte zu schreiben. +- [shellcheck](https://github.com/koalaman/shellcheck) - Ein statisches Analysetool für Shell-Skripte. Im Grunde lint für bash/sh/zsh. +- [Filenames and Pathnames in Shell](http://www.dwheeler.com/essays/filenames-in-shell.html): The sadly complex minutiae on how to handle filenames correctly in shell scripts. +- [Data Science at the Command Line](http://datascienceatthecommandline.com/#tools): More commands and tools helpful for doing data science, from the book of the same name ## Haftungsausschluss Mit der Ausnahme einiger sehr kleiner Aufgaben ist der Code so geschrieben, dass andere ihn lesen können. Mit Macht kommt Verantwortung. Die Tatsache etwas in Bash tun zu *können*, heißt nicht zwangsläufig, dass du es tun solltest! + ## Lizenz [![Creative Commons License](https://i.creativecommons.org/l/by-sa/4.0/88x31.png)](http://creativecommons.org/licenses/by-sa/4.0/) From d1f387715dc6b344b0e0b2bd3b252e4ee69cb7ed Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Tue, 6 Sep 2016 14:24:16 +0200 Subject: [PATCH 20/26] Final step taken - everything is now up-to-date with current english version (hopefully) --- README-de.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README-de.md b/README-de.md index 470b6bb..5a14605 100644 --- a/README-de.md +++ b/README-de.md @@ -580,8 +580,8 @@ Diese Hinweise sind *nur* für Windows relevant. - [awesome-osx-command-line](https://github.com/herrbischoff/awesome-osx-command-line): A more in-depth guide for the OS X command line. - [Strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/), um bessere Shell-Skripte zu schreiben. - [shellcheck](https://github.com/koalaman/shellcheck) - Ein statisches Analysetool für Shell-Skripte. Im Grunde lint für bash/sh/zsh. -- [Filenames and Pathnames in Shell](http://www.dwheeler.com/essays/filenames-in-shell.html): The sadly complex minutiae on how to handle filenames correctly in shell scripts. -- [Data Science at the Command Line](http://datascienceatthecommandline.com/#tools): More commands and tools helpful for doing data science, from the book of the same name +- [Filenames and Pathnames in Shell](http://www.dwheeler.com/essays/filenames-in-shell.html): Entmutigend komplexe Einzelheiten darüber, wie Dateinamen in Shell-Skripts richtig eingesetzt werden. +- [Data Science at the Command Line](http://datascienceatthecommandline.com/#tools): Mehr Befehle und Werkzeuge, die für ["data science"](https://de.wikipedia.org/wiki/Data_Science) hilfreich sind, aus dem gleichnamigen Buch. ## Haftungsausschluss From d9e7de76897e4292abf1caeffe7f2296ebbbe0b9 Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Wed, 7 Sep 2016 07:01:17 +0200 Subject: [PATCH 21/26] Minor fixes --- README-de.md | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/README-de.md b/README-de.md index 5a14605..8790fc6 100644 --- a/README-de.md +++ b/README-de.md @@ -24,7 +24,7 @@ ![curl -s 'https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README.md' | egrep -o '`\w+`' | tr -d '`' | cowsay -W50](cowsay.png) -Der flüssige Umgang mit der Kommandozeile ist eine oft vernachlässigte oder als undurchsichtig empfundene Fähigkeit, steigert jedoch Flexibilität und Produktivität eines Informatikers auf offensichtliche als auch subtile Weise. Was folgt, ist eine Auswahl an Notizen und Tipps im Umgang mit der Kommandozeile, welche ich beim Arbeiten mit Linux zu schätzen gelernt habe. Manche dieser Hinweise beinhalten Grundwissen, andere sind sehr spezifisch, fortgeschritten oder auch eigenartig. Die Seite ist nicht lang, aber wenn du alle Punkte verstanden hast und anwenden kannst, weißt du eine ganze Menge. +Der flüssige Umgang mit der Befehlszeile (auch Kommandozeile, engl. "command line") ist eine oft vernachlässigte oder als undurchsichtig empfundene Fähigkeit, steigert jedoch Flexibilität und Produktivität eines Informatikers auf offensichtliche als auch subtile Weise. Was folgt, ist eine Auswahl an Notizen und Tipps im Umgang mit der Befehlszeile, welche ich beim Arbeiten mit Linux zu schätzen gelernt habe. Manche dieser Hinweise beinhalten Grundwissen, andere sind sehr spezifisch, fortgeschritten oder auch eigenartig. Die Seite ist nicht lang, aber wenn du alle Punkte verstanden hast und anwenden kannst, weißt du eine ganze Menge. Vieles davon [erschien](http://www.quora.com/What-are-the-most-useful-Swiss-army-knife-one-liners-on-Unix) @@ -71,7 +71,7 @@ Hinweise: - Kenne reguläre Ausdrücke gut, und die verschiedenen Statusindikatoren zu `grep`/`egrep`. Die Optionen `-i`, `-o`, `-v`, `-A`, `-B`, und `-C` sind gut zu wissen. -- Lerne den Umgang mit `apt-get`, `yum`, `dnf` oder `pacman` (je nach Linux-Distribution), um Pakete zu finden bzw. zu installieren. Und stell sicher, dass du `pip` hast, um Python-basierte Kommandozeilen-Werkzeuge nutzen zu können (einige der untenstehenden werden am einfachsten über `pip` installiert). +- Lerne den Umgang mit `apt-get`, `yum`, `dnf` oder `pacman` (je nach Linux-Distribution), um Pakete zu finden bzw. zu installieren. Und stell sicher, dass du `pip` hast, um Python-basierte Befehlszeilen-Werkzeuge nutzen zu können (einige der untenstehenden werden am einfachsten über `pip` installiert). ## Täglicher Gebrauch @@ -88,7 +88,7 @@ Hinweise: - Um kürzlich verwendete Befehle anzuzeigen, benutze `history`. Anschließend `!n` (wobei `n` die Nummer des Befehls ist), um es erneut auszuführen. Es gibt zudem zahlreiche Abkürzungen, die man verwenden kann, die nützlichste ist wahrscheinlich `!$` für den letzten Parameter und `!!` für den letzten Befehl (siehe "HISTORY EXPANSION" in der `man`-Seite). Diese werden allerdings oft einfach ersetzt durch **ctrl-r** und **alt-.**. -- Go to your home directory with `cd`. Access files relative to your home directory with the `~` prefix (e.g. `~/.bashrc`). In `sh` scripts refer to the home directory as `$HOME`. +- In dein Benutzerverzeichnis gelangst du mit `cd`. Auf Dateien relativ zu diesem kannst du mit dem Präfix `~` zugreifen (etwa so `~/.bashrc`). In `sh`-Skripts heißt das Benutzerverzeichnis `$HOME`. - Um ins vorangegangene Arbeitsverzeichnis zu gelangen: `cd -` @@ -194,7 +194,7 @@ Hinweise: - Benutze `su benutzername` oder `su - benutzername`, um mit der Shell zu einem anderen Benutzer zu wechseln. Füge `-` hinzu, um eine Umgebung zu erhalten, als hättest du dich gerade mit diesem Benutzer angemeldet. Das Weglassen des Benutzernamens führt zur Anmeldung als root. du wirst gefragt nach dem Passwort _des Benutzers, als der du dich anmelden willst_. -- Kenne das [128K-Limit](https://wiki.debian.org/CommonErrorMessages/ArgumentListTooLong) der Kommandozeile. Der "Argument list too long"-Fehler erscheint häufig, wenn auf sehr viele Dateien über [Wildcards](https://de.wikipedia.org/wiki/Wildcard_(Informatik)) zugegriffen wird (wenn das passiert, können Alternativen wie `find` und `xargs` helfen). +- Kenne das [128K-Limit](https://wiki.debian.org/CommonErrorMessages/ArgumentListTooLong) der Befehlszeile. Der "Argument list too long"-Fehler erscheint häufig, wenn auf sehr viele Dateien über [Wildcards](https://de.wikipedia.org/wiki/Wildcard_(Informatik)) zugegriffen wird (wenn das passiert, können Alternativen wie `find` und `xargs` helfen). - Benutze den `python`-Interpreter als einfachen Taschenrechner (und natürlich für den Zugriff auf Python im Allgemeinen). Beispiel: ``` @@ -233,7 +233,7 @@ Hinweise: - Bei komplexeren Berechnungen, einschließlich Gruppieren, Tauschen von Feldern und statistische Berechnungen, könnte [`datamash`](https://www.gnu.org/software/datamash/) passend sein. -- Sei dir bewusst, dass die regionale Spracheinstellung ("locale") viele Kommandozeilenwerkzeuge auf subtile Art und Weise beeinflusst, inklusive der Sortierreihenfolge und ihrer Performance. Die meisten Linux Installation setzen `LANG` oder andere lokale Variablen auf eine lokale Einstellung wie z.B. "US English". Aber sei dir bewusst, dass sich das Sortierverhalten ändern wird, falls du die "locale" änderst. Und wisse, dass "i18n"-Routinen `sort` und andere Kommandos *stark* verlangsamen können. In manchen Situationen (wie den Mengen oder Identitätsfunktionen unterhalb) kann man ruhigen Gewissens langsame "i18n"-Routinen ignorieren und traditionelle byte-basierte Sortierreihenfolge nutzen, indem man `export LC_ALL=C` setzt. +- Sei dir bewusst, dass die regionale Spracheinstellung ("locale") viele Befehlszeilen-Werkzeuge auf subtile Art und Weise beeinflusst, inklusive der Sortierreihenfolge und ihrer Performance. Die meisten Linux Installation setzen `LANG` oder andere lokale Variablen auf eine lokale Einstellung wie z.B. "US English". Aber sei dir bewusst, dass sich das Sortierverhalten ändern wird, falls du die "locale" änderst. Und wisse, dass "i18n"-Routinen `sort` und andere Befehle *stark* verlangsamen können. In manchen Situationen (wie den Mengen oder Identitätsfunktionen unterhalb) kann man ruhigen Gewissens langsame "i18n"-Routinen ignorieren und traditionelle byte-basierte Sortierreihenfolge nutzen, indem man `export LC_ALL=C` setzt. - Du kannst einem bestimmten Befehl eine Umgebung zuteilen, indem seinem Aufruf die Einstellung der Umgebungsvariable vorangestellt wird, wie hier: `TZ=Pacific/Fiji date`. @@ -258,7 +258,7 @@ mkdir leeres-verzeichnis && rsync -r --delete leeres-verzeichnis/ verzeichnis && - Kenne die Optionen von `sort`. Benutze `-n` für Zahlen, oder `-h` um mit menschenlesbaren Zahlen umzugehen (wie z.B. von `du -h`). Sei dir bewusst, wie Schlüssel funktionieren (`-t` und `-k`). Sei dir insbesondere bewusst, dass du `-k1,1` verwenden musst, um bezüglich des ersten Felds zu sortieren;`-k1` bedeutet, sortiere anhand der ganzen Zeile. Stabiles Suchen (`sort -s`) kann ebenfalls nützlich sein. Um bspw. primär nach Feld 2 und sekundär nach Feld 1 zu sortieren, kannst du `sort -k1,1 | sort -s -k2,2` benutzen. -- Falls du jemals ein Tabulator Literal in eine Kommandozeile in Bash schreiben musst (etwa den Parameter `-t` für `sort`), drücke **ctrl-v** **[Tab]** oder schreibe `$'\t'` (letzteres ist besser, da man es Kopieren/Einfügen kann). +- Falls du jemals ein Tabulator Literal in eine Befehlszeile in Bash schreiben musst (etwa den Parameter `-t` für `sort`), drücke **ctrl-v** **[Tab]** oder schreibe `$'\t'` (letzteres ist besser, da man es Kopieren/Einfügen kann). - Die Standardwerkzeuge für das Patchen von Quellcode sind `diff` und `patch`. Siehe auch `diffstat`, um zusammenfassende Statistiken eines diffs zu erhalten. Beachte, dass `diff -r` für komplette Verzeichnisse funktioniert. Nutze `diff -r tree1 tree2 | diffstat`, um eine Übersicht aller Änderungen zu bekommen. Benutze `vimdiff`, um Dateien zu vergleichen und zu bearbeiten. @@ -268,7 +268,7 @@ mkdir leeres-verzeichnis && rsync -r --delete leeres-verzeichnis/ verzeichnis && - Um Diffs für Binärdateien zu erstellen (Delta Kompression), nutze `xdelta3`. -- Um zwischen Textkodierungen zu konvertieren, solltest du `iconv` probieren, oder aber `uconv` für fortgeschrittene Anwendungsfälle; es unterstüzt einige fortgeschrittene Unicode-Dinge. Dieses Kommando bspw. wandelt alle Buchstaben in Kleinbuchstaben um und entfernt alle Akzente (indem sie erweitert und verworfen werden): +- Um zwischen Textkodierungen zu konvertieren, solltest du `iconv` probieren, oder aber `uconv` für fortgeschrittene Anwendungsfälle; es unterstüzt einige fortgeschrittene Unicode-Dinge. Dieser Befehl bspw. wandelt alle Buchstaben in Kleinbuchstaben um und entfernt alle Akzente (indem sie erweitert und verworfen werden): ```sh uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt ``` @@ -331,7 +331,7 @@ mkdir leeres-verzeichnis && rsync -r --delete leeres-verzeichnis/ verzeichnis && ## Einzeiler -Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: +Ein paar Beispiele, wie man Befehle zusammen benutzen kann: - Manchmal ist es unglaublich hilfreich, dass man die Schnittmenge, Vereinigung und den Unterschied zwischen Textdateien via `sort`/`uniq` bilden kann. Angenommen, a und b sind Textdateien, die bereits "unique" sind. Diese Herangehensweise ist schnell und funktioniert mit Dateien beliebiger Größe, bis zu mehreren Gigabytes (`sort` ist nicht durch Speicher beschränkt, obwohl man eventuell die `-T`-Option nutzen muss, falls `/tmp` auf einer kleinen Root-Partition liegt). Siehe auch die Bemerkung über `LC_ALL` weiter oben und die `-u`-Option von `sort` (wurde oben aus Gründen der Übersichtlichkeit ausgelassen). ```sh @@ -387,7 +387,7 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: - `cal`: Netter Kalender -- `env`: Führe ein Kommando aus (nützlich für Skripte) +- `env`: Führe einen Befehl aus (nützlich für Skripte) - `printenv`: Gebe Umgebungsvariablen aus (nützlich zum Debuggen und für Skripte) @@ -493,11 +493,11 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: - [`glances`](https://github.com/nicolargo/glances): Grobe Übersicht über zahlreiche Subsysteme -- `iostat`: Fesplatten Nutzungsstatistiken +- `iostat`: Fesplatten-Nutzungsstatistiken -- `mpstat`: CPU Nutzungsstatistiken +- `mpstat`: CPU-Nutzungstatistiken -- `vmstat`: Speicher Nutzungsstatistiken +- `vmstat`: Speicher-Nutzungsstatistiken - `htop`: Verbesserte Version von `top` @@ -513,7 +513,7 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: - `ss`: Socket-Statistiken -- `dmesg`: Bootvorgang und System Fehlermeldungen +- `dmesg`: Bootvorgang und System-Fehlermeldungen - `sysctl`: Anzeige und Konfiguration von Linux Kernel Parametern zur Laufzeit @@ -523,9 +523,9 @@ Ein paar Beispiele, wie man Kommandos zusammen benutzen kann: - `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: Hardware-Informationen, inklusive CPU, BIOS, RAID, Grafikkarten, Geräte, etc. -- `lsmod` und `modinfo`: Auflisten und Details anzeigen von Kernel Modulen +- `lsmod` und `modinfo`: Auflisten und Details anzeigen von Kernelmodulen -- `fortune`, `ddate`, und `sl`: ähm ja, kommt darauf an, ob man Dampflokomotiven und flotte Zitate "nützlich" findet +- `fortune`, `ddate`, und `sl`: Ähm ja, kommt darauf an, ob man Dampflokomotiven und flotte Zitate "nützlich" findet ## Nur MacOS X @@ -534,7 +534,7 @@ Diese Hinweise sind *nur* für MacOS relevant. - Paketverwaltung mit `brew` (Homebrew) und/oder `port` (MacPorts). Mit diesen Werkzeugen kann man viele der obrigen Programme für MacOs installieren. -- Kopiere die Ausgabe jedes Kommandos an eine Desktop App mit `pbcopy` und füge die Eingabe von einer solchen ein mit `pbpaste`. +- Kopiere die Ausgabe eines beliebigen Befehls an eine Desktop App mit `pbcopy` und füge die Eingabe von einer solchen ein mit `pbpaste`. - Um die Option Taste als alt-Taste in einer Mac OS Konsole zu nutzen (so wie in den obrigen Befehle wie **alt-b**, **alt-f**, etc.), öffne Einstellungen -> Profile -> Tastatur und aktiviere "Benutze Option Taste als Meta Taste" @@ -542,7 +542,7 @@ Diese Hinweise sind *nur* für MacOS relevant. - Spotlight: Dateisuche mit `mdfind` und Ausgabe von Metadaten (wie z.B. photo EXIF info) mit `mdls`. -- Man sollte sich bewusst sein, dass MacOS auf BSD Unix basiert und sich viele Befehle (wie z.B. `ps`, `ls`, `tail`, `awk`, `sed`) bezüglich subtiler Kleinigkeiten von Linux, das stark von System V-style Unix und GNU tools beeinflusst ist, unterscheiden. Oft kann man den Unterschied daran erkennen, dass eine `man`-Seite die Überschrift "BSD General Commands Manual" trägt. In manchen Fällen kann auch die GNU-Version installiert werden (wie z.B. bei `gawk` und `gsed` für GNU awk und sed). Falls manplattformübergreifende Bash-Skripte schreiben möchte, sollte man solche Kommandos vermeiden (und z.B. Python oder `perl` in Betracht ziehen) oder sorgfätig testen. +- Man sollte sich bewusst sein, dass MacOS auf BSD Unix basiert und sich viele Befehle (wie z.B. `ps`, `ls`, `tail`, `awk`, `sed`) bezüglich subtiler Kleinigkeiten von Linux, das stark von System V-style Unix und GNU tools beeinflusst ist, unterscheiden. Oft kann man den Unterschied daran erkennen, dass eine `man`-Seite die Überschrift "BSD General Commands Manual" trägt. In manchen Fällen kann auch die GNU-Version installiert werden (wie z.B. bei `gawk` und `gsed` für GNU awk und sed). Falls manplattformübergreifende Bash-Skripte schreiben möchte, sollte man solche Befehle vermeiden (und z.B. Python oder `perl` in Betracht ziehen) oder sorgfätig testen. - Benutze `sw_vers` für OS X Systeminformationen. @@ -551,13 +551,13 @@ Diese Hinweise sind *nur* für MacOS relevant. Diese Hinweise sind *nur* für Windows relevant. -- Mit Windows 10 kannst du [Bash on Ubuntu on Windows](https://msdn.microsoft.com/commandline/wsl/about) benutzen, das eine vertraute Bash-Umgebung mit Unix-Kommandozeilenwerkzeugen. Dies erlaubt einerseits die Nutzung von Linux-Programmen auf Windows, unterstützt andererseits jedoch nicht die Ausführung von Windows-Programmen von der Bash-Konsole. +- Mit Windows 10 kannst du [Bash on Ubuntu on Windows](https://msdn.microsoft.com/commandline/wsl/about) benutzen, das eine vertraute Bash-Umgebung mit Unix-Befehlszeilen-Werkzeugen. Dies erlaubt einerseits die Nutzung von Linux-Programmen auf Windows, unterstützt andererseits jedoch nicht die Ausführung von Windows-Programmen von der Bash-Konsole. - Zugriff auf die Macht der Unix-Shell erhälst du unter Microsoft Windows durch die Installation von [Cygwin](https://cygwin.com/). Die meisten hier beschriebenen Dinge funktionieren damit ohne weiteren Aufwand. - Installiere zusätzliche Unix-Programme mit Cygwins Paketmanager. -- Benutze `mintty` als dein Kommandozeilenfenster. +- Benutze `mintty` als dein Befehlszeilenfenster. - Greife mit `/dev/clipboard` auf die Zwischenablage von Windows zu. @@ -567,9 +567,9 @@ Diese Hinweise sind *nur* für Windows relevant. - Beachte, dass der Windows-Pfad `C:\` unter Cygwin zu `/cygdrive/c` wird und dass Cygwins `/` unter Windows als `C:\cygwin` verfügbar ist. Für die Umwandlung zwischen Cygwin- und Windows-Pfaden steht `cygpath` zur Verfügung. Dies ist inbesondere für Skripte nützlich, welche Windows-Programme ausführen. -- Du kannst die meisten Aufgaben der Windows-Systemverwaltung von der Kommandozeile ausführen und skripten, indem du den Umgang mit `wmic` lernst. +- Du kannst die meisten Aufgaben der Windows-Systemverwaltung von der Befehlszeile ausführen und skripten, indem du den Umgang mit `wmic` lernst. -- Eine andere Möglichkeit, ein wenig Unix auf dein Windows-System zu bringen, bietet [Cash](https://github.com/dthree/cash). Beachte allerdings, dass nur sehr wenige Unix-Befehle und Kommandozeilen-Optionen in dieser Umgebung zur Verfügung stehen. +- Eine andere Möglichkeit, ein wenig Unix auf dein Windows-System zu bringen, bietet [Cash](https://github.com/dthree/cash). Beachte allerdings, dass nur sehr wenige Unix-Befehle und Befehlszeilen-Optionen in dieser Umgebung zur Verfügung stehen. - Eine weitere Option, GNU-Entwicklerwerkzeuge (etwa GCC) auf Windows zu nutzen, besteht darin, [MinGW](http://www.mingw.org/) und dessen Paket [MSYS](http://www.mingw.org/wiki/msys), das Hilfsprogramme wie bash, gawk, make and grep beinhaltet, zu installieren. MSYS bringt allerdings nicht so viele Features mit wie etwa Cygwin. MinGW ist besonders nützlich für die Erstellung nativer Windows-Ports von Unix-Werkzeugen. @@ -577,7 +577,7 @@ Diese Hinweise sind *nur* für Windows relevant. ## Weitere Quellen - [awesome-shell](https://github.com/alebcay/awesome-shell): Eine hilfreiche Liste von Shell-Werkzeugen und Quellen. -- [awesome-osx-command-line](https://github.com/herrbischoff/awesome-osx-command-line): A more in-depth guide for the OS X command line. +- [awesome-osx-command-line](https://github.com/herrbischoff/awesome-osx-command-line): Eine ausführliche Anleitung für die Befehlszeile unter OS X. - [Strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/), um bessere Shell-Skripte zu schreiben. - [shellcheck](https://github.com/koalaman/shellcheck) - Ein statisches Analysetool für Shell-Skripte. Im Grunde lint für bash/sh/zsh. - [Filenames and Pathnames in Shell](http://www.dwheeler.com/essays/filenames-in-shell.html): Entmutigend komplexe Einzelheiten darüber, wie Dateinamen in Shell-Skripts richtig eingesetzt werden. From 8b4744c038fabab4ce2ab5f191073172cc8103ce Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Wed, 7 Sep 2016 07:37:17 +0200 Subject: [PATCH 22/26] finishing touch --- README-de.md | 111 ++++++++++++++++++++++++++------------------------- 1 file changed, 56 insertions(+), 55 deletions(-) diff --git a/README-de.md b/README-de.md index 8790fc6..54bc4a9 100644 --- a/README-de.md +++ b/README-de.md @@ -32,6 +32,7 @@ Vieles davon auf [Quora](http://www.quora.com/What-are-some-time-saving-tips-that-every-Linux-user-should-know), aber angesichts des Interesses scheint es vielversprechend, Github zu nutzen, wo talentiertere Menschen als ich es bin kontinuierlich Verbesserungen vorschlagen können. Wenn du einen Fehler entdeckst oder etwas, das man besser machen könnte, erstelle ein Issue oder einen PR! (Lies aber bitte zuerst die Kurzbeschreibung und überprüfe bereits vorhandene Issues/PRs.) + ## Kurzbeschreibung Umfang: @@ -96,15 +97,15 @@ Hinweise: - Verwende `xargs` (oder `parallel`). Es ist sehr mächtig. Beachte, wie du viele Dinge pro Zeile (`-L`) als auch parallel (`-P`) ausführen kannst. Wenn du dir nicht sicher bist, ob das Richtige dabei herauskommt, verwende zunächst `xargs echo`. Außerdem ist`-I{}` nützlich. Beispiele: ```bash - find . -name '*.py' | xargs grep irgendeine_funktion - cat hosts | xargs -I{} ssh root@{} hostname + find . -name '*.py' | xargs grep irgendeine_funktion + cat hosts | xargs -I{} ssh root@{} hostname ``` - `pstree -p` liefert eine hilfreiche Anzeige des Prozessbaums. - Verwende `pgrep` und `pkill`, um Prozesse anhand eines Namens zu finden oder festzustellen (`-f` ist hilfreich). -- Kenne die verschiedenen Signale, die du Prozessen senden kannst. Um einen Prozess etwa zu unterbrechen, verwende `kill -STOP [pid]`. Für die vollständige Liste, siehe `man 7 signal` +- Kenne die verschiedenen Signale, welche du Prozessen senden kannst. Um einen Prozess etwa zu unterbrechen, verwende `kill -STOP [pid]`. Für die vollständige Liste, siehe `man 7 signal` - Verwende `nohup` oder `disown`, wenn du einen Hintergrundprozess für immer laufen lassen willst. @@ -126,15 +127,15 @@ Hinweise: - Benutze in Bash-Skripts `set -x` (oder die Abwandlung `set -v`, welche unverarbeiteten Input akzeptiert, einschließlich Kommentare und unexpandierte Variablen) zum Output der Fehlerbehebung. Benutze "strict modes", es sei denn, gute Gründe sprechen dagegen: Benutze `set -e`, um bei Fehlern abzubrechen ("nonzero exit code"). Benutze `set -u`, um die Verwendung nicht gesetzer Variablen aufzuspüren. Erwäge auch `set -o pipefail` für Fehler in Pipes (lies jedoch mehr zu diesem Thema, wenn du es vorhast, denn es ist ein wenig heikel). Benutze bei komplizierteren Skripts auch `trap` bei EXIT oder ERR. Es ist eine nützliche Angewohnheit, ein Skript folgendermaßen zu beginnen, um Fehler zu erkennen und sie ggf. mit einer entsprechenden Fehlermeldung abzubrechen: ```bash - set -euo pipefail - trap "echo 'error: Script failed: see failed command above'" ERR + set -euo pipefail + trap "echo 'error: Script failed: see failed command above'" ERR ``` - In Bash-Skripts stellen Subshells (geschrieben in runden Klammern) einen praktischen Weg dar, Befehle zusammenzufassen. Ein gebräuchliches Beispiel ist die vorübergehende Arbeit in einem anderen Arbeitsverzeichnis: ```bash - # erledige etwas im aktuellen Verzeichnis - (cd /irgendein/anderes/verzeichnis && anderer-befehl) - # fahre fort im aktuellen Verzeichnis + # erledige etwas im aktuellen Verzeichnis + (cd /irgendein/anderes/verzeichnis && anderer-befehl) + # fahre fort im aktuellen Verzeichnis ``` - Beachte, dass es in Bash viele Möglichkeiten gibt, Variablen zu erweitern. Überprüfen, ob eine Variable existiert: `${name:?error message}`.Wenn bspw. ein Bash-Skript nur einen einzelnen Parameter benötigt, schreibe einfach `input_file=${1:?usage: $0 input_file}`. Arithmetische Erweiterung: `i=$(( (i + 1) % 5 ))`. Sequenzen: `{1..10}`. Zeichenkette kürzen: `${var%suffix}` und `${var#prefix}`. Wenn bspw. `var=foo.pdf`, dann gibt `echo ${var%.pdf}.txt` die Ausgabe `foo.txt` aus. @@ -143,13 +144,13 @@ Hinweise: - Die Ausgabe eines Befehls kann wie eine Datei behandelt werden mit `<(befehl)`. Das Vergleichen der lokalen `/etc/hosts` mit einer entfernten: ```sh - diff /etc/hosts <(ssh andererhost cat /etc/hosts) + diff /etc/hosts <(ssh andererhost cat /etc/hosts) ``` - Beim Schreiben von Skripts wirst du deinen Code womöglich in geschweifte Klammern setzen wollen. Falls die schließende Klammer fehlt, wird dein Skript aufgrund eines Syntaxfehlers nicht ausgeführt. Das ist etwa dann sinnvoll, wenn es im Internet verfügbar ist, da ein unvollständig heruntergeladenes Skript so an der Ausführung gehindert wird: ```bash { - # Hier koennte dein Code stehen! + # Hier koennte dein Code stehen! } ``` @@ -159,28 +160,28 @@ Hinweise: - Verwende `man ascii` für eine gute ASCII-Tabelle, Mit Dezimal- und Hexadezimalwerten. Für allgemeine Informationen zu Kodierung sind `man unicode`, `man utf-8` und `man latin1` hilfreich. -- Verwende `screen` oder [`tmux`](https://tmux.github.io/), um einen Bildschirm zu multiplexen, besonders hilfreich ist dies für Fernzugriffe per ssh und zur Trennung und Neuverbindung mit einer Session. Eine minimalistische Alternative allein zur Aufrechterhaltung einer Session ist `dtach`. +- Verwende `screen` oder [`tmux`](https://tmux.github.io/), um einen Bildschirm zu multiplexen, besonders hilfreich ist dies für Fernzugriffe per `ssh` und zur Trennung und Neuverbindung mit einer Session. Eine minimalistische Alternative allein zur Aufrechterhaltung einer Session ist `dtach`. - Bei SSH ist es hilfreich zu wissen, wie man einen Porttunnel mit `-L` oder `-D` (gelegentlich auch `-R`) einrichtet, etwa beim Zugriff auf Webseiten von einem Remote-Server. - Es kann nützlich sein, ein paar Verbesserungen an den SSH-Einstellungen vorzunehmen; so enthält bspw. diese `~/.ssh/config` Einstellungen, um das Abreißen der Verbindung in bestimmten Netzwerkumgebungen zu vermeiden, verwendet Kompression (was hilfreich ist bei SCP über Verbindungen mit niedriger Bandbreite) und Multiplex-Kanäle zu demselben Server mithilfe einer lokalen Kontrolldatei: ``` - TCPKeepAlive=yes - ServerAliveInterval=15 - ServerAliveCountMax=6 - Compression=yes - ControlMaster auto - ControlPath /tmp/%r@%h:%p - ControlPersist yes + TCPKeepAlive=yes + ServerAliveInterval=15 + ServerAliveCountMax=6 + Compression=yes + ControlMaster auto + ControlPath /tmp/%r@%h:%p + ControlPersist yes ``` - Einige andere Optionen im Zusammenhang mit SSH sind sicherheitsrelevant und sollten nur mit Bedacht aktiviert werden, etwa Zugriff per Subnet oder Host sowie in vertrauenswürdigen Netzwerken: `StrictHostKeyChecking=no`, `ForwardAgent=yes` -- Erwäge [`mosh`](https://mosh.mit.edu/) als Alternative zu ssh, die UDP benutzt, um so abgebrochene Verbindungen zu vermeiden, was ja in gewisser Hinsicht auch komfortabel ist (benötigt Server-seitiges Setup). +- Erwäge [`mosh`](https://mosh.mit.edu/) als Alternative zu `ssh`, die UDP benutzt, um so abgebrochene Verbindungen zu vermeiden, was ja in gewisser Hinsicht auch komfortabel ist (benötigt Server-seitiges Setup). - Um Zugriff auf eine Datei in Oktalform zu erhalten, was zur Systemkonfiguration zwar nützlich, jedoch über `ls` nicht verfügbar und leicht zu vermasseln ist, verwende etwas wie ```sh - stat -c '%A %a %n' /etc/timezone + stat -c '%A %a %n' /etc/timezone ``` - Verwende zur interaktiven Auswahl von Werten aus dem Output eines anderen Befehls [`percol`](https://github.com/mooz/percol) oder [`fzf`](https://github.com/junegunn/fzf). @@ -198,8 +199,8 @@ Hinweise: - Benutze den `python`-Interpreter als einfachen Taschenrechner (und natürlich für den Zugriff auf Python im Allgemeinen). Beispiel: ``` ->>> 2+3 -5 + >>> 2+3 + 5 ``` @@ -241,12 +242,12 @@ Hinweise: - Um mehrere Dateien umzubenennen sowie innerhalb von Dateien zu suchen/ersetzen, probier [`repren`](https://github.com/jlevy/repren) aus (gelegentlich kann man auch mit `rename` mehrere Dateien umbenennen, aber sei vorsichtig, da dessen Funktionsweise je nach Linux-Distribution abweicht). ```sh - # Vollständige Umbenennung von Dateinamen, Ordnern und Inhalten - foo -> bar: - repren --full --preserve-case --from foo --to bar . - # Backupdateien wiederherstellen - whatever.bak -> whatever: - repren --renames --from '(.*)\.bak' --to '\1' *.bak - # Wie oben, aber mit rename, sofern verfügbar: - rename 's/\.bak$//' *.bak + # Vollständige Umbenennung von Dateinamen, Ordnern und Inhalten - foo -> bar: + repren --full --preserve-case --from foo --to bar . + # Backupdateien wiederherstellen - whatever.bak -> whatever: + repren --renames --from '(.*)\.bak' --to '\1' *.bak + # Wie oben, aber mit rename, sofern verfügbar: + rename 's/\.bak$//' *.bak ``` - Wie die `man`-Seite richtig sagt, ist `rsync` ein schnelles und vielseitiges Werkzeug zum Kopieren von Dateien. Es ist bekannt für das Synchronisieren zwischen Rechnern, ist lokal aber ebenso nützlich. Wenn es die Sicherheitsbestimmungen zulassen, erlaubt `rsync` im Gegensatz zu `scp` die Wiederaufnahme einer Übertragung, ohne nochmal von vorn beginnen zu müssen. Es ist zudem einer der [schnellsten Wege](https://web.archive.org/web/20130929001850/http://linuxnote.net/jianingy/en/linux/a-fast-way-to-remove-huge-number-of-files.html), um große Mengen an Dateien zu löschen: @@ -270,19 +271,19 @@ mkdir leeres-verzeichnis && rsync -r --delete leeres-verzeichnis/ verzeichnis && - Um zwischen Textkodierungen zu konvertieren, solltest du `iconv` probieren, oder aber `uconv` für fortgeschrittene Anwendungsfälle; es unterstüzt einige fortgeschrittene Unicode-Dinge. Dieser Befehl bspw. wandelt alle Buchstaben in Kleinbuchstaben um und entfernt alle Akzente (indem sie erweitert und verworfen werden): ```sh - uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt + uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt ``` - Um Dateien aufzuteilen, siehe `split` (Teilung anhand einer bestimmten Größe) und `csplit` (Teilung anhand eines bestimmten Musters). - Benutze `zless`, `zmore`, `zcat`, und `zgrep` um mit komprimierten Dateien zu arbeiten. -- File attributes are settable via `chattr` and offer a lower-level alternative to file permissions. For example, to protect against accidental file deletion the immutable flag: `sudo chattr +i /critical/directory/or/file` +- Dateieigenschaften können mit `chattr` gesetzt werden und stellen eine niederschwelligere Alternative zu Dateiberechtungen dar. So kann man etwa, um das versehentliche Löschen einer Datei zu verhindern, eine entsprechende Flag ("immutable flag") setzen: `sudo chattr +i /wichtiges/verzeichnis/oder/datei` -- Use `getfacl` and `setfacl` to save and restore file permissions. For example: +- Benutze `getfacl` und `setfacl`, um Dateiberechtigungen zu speichern und wiederherzustellen. Beispiel: ```sh - getfacl -R /some/path > permissions.txt - setfacl --restore=permissions.txt + getfacl -R /irgendein/pfad > berechtigungen.txt + setfacl --restore=berechtigungen.txt ``` @@ -335,45 +336,45 @@ Ein paar Beispiele, wie man Befehle zusammen benutzen kann: - Manchmal ist es unglaublich hilfreich, dass man die Schnittmenge, Vereinigung und den Unterschied zwischen Textdateien via `sort`/`uniq` bilden kann. Angenommen, a und b sind Textdateien, die bereits "unique" sind. Diese Herangehensweise ist schnell und funktioniert mit Dateien beliebiger Größe, bis zu mehreren Gigabytes (`sort` ist nicht durch Speicher beschränkt, obwohl man eventuell die `-T`-Option nutzen muss, falls `/tmp` auf einer kleinen Root-Partition liegt). Siehe auch die Bemerkung über `LC_ALL` weiter oben und die `-u`-Option von `sort` (wurde oben aus Gründen der Übersichtlichkeit ausgelassen). ```sh - cat a b | sort | uniq > c # c ist a vereint mit b - cat a b | sort | uniq -d > c # c ist a geschnitten b - cat a b b | sort | uniq -u > c # c ist die Menge mit unterschiedlichen Elementen a - b + cat a b | sort | uniq > c # c ist a vereint mit b + cat a b | sort | uniq -d > c # c ist a geschnitten b + cat a b b | sort | uniq -u > c # c ist die Menge mit unterschiedlichen Elementen a - b ``` - Eine schnelle Überprüfung der Inhalte aller Dateien in einem Verzeichnis erreichst du mit `grep . *` (damit enthält jede Zeile den Dateinamen) oder `head -100 *` (damit erhält jede Datei eine Überschrift). Dies kann nützlich sein für Verzeichnisse, die Konfigurationsdateien enthalten wie jene in `/sys`, `/proc` und `/etc`. - Alle Zahlen in der dritten Spalte einer Textdatei aufsummieren (dieser Ansatz ist wahrscheinlich dreimal schneller und enthält dreimal weniger Code als dessen Entsprechung in Python): ```sh - awk '{ x += $3 } END { print x }' meinedatei + awk '{ x += $3 } END { print x }' meinedatei ``` - Falls man die Größen/Datumsangaben von einem Dateibaum wissen möchte, funktioniert das Folgende wie ein rekursives `ls -l`, aber ist leichter zu lesen als `ls -lR`: ```sh - find . -type f -ls + find . -type f -ls ``` - Um Größen/Datumsangaben in einem Verzeichnisbaum zu sehen, wirkt dies wie ein umgedrehtes `ls -l`, ist aber einfacher zu lesen als `ls -lR`: ```sh - find . -type f -ls + find . -type f -ls ``` - Angenommen innerhalb einer Textdatei, so wie ein server web log, tauch ein gewisser Wert in manchen Zeilen auf, wie z.B. ein `acct_id` Parameter in der URL. Falls eine Aufzählung gewünscht ist, wie viele Anfragen es jeweils für eine `acct_id` gibt: ```sh - cat access.log | egrep -o 'acct_id=[0-9]+' | cut -d= -f2 | sort | uniq -c | sort -rn + cat access.log | egrep -o 'acct_id=[0-9]+' | cut -d= -f2 | sort | uniq -c | sort -rn ``` - Um durchgehend Änderungen zu überwachen, solltest du "watch" benutzen; z.B. Dateiänderungen in einem Verzeichnis können mittels `watch -d -n 2 'ls -rtlh | tail'` überwacht werden, während du Deine Wifi Einstellungen mittels `watch -d -n 2 ifconfig` auf Fehler überprüfen kannst. - Führe diese Funktion aus, um einen zufälligen Tip aus diesem Dokument zu erhalten(parst das Markdown Dokument und extrahiert ein Element) ```sh - function taocl() { - curl -s https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README-de.md | - pandoc -f markdown -t html | - xmlstarlet fo --html --dropdtd | - xmlstarlet sel -t -v "(html/body/ul/li[count(p)>0])[$RANDOM mod last()+1]" | - xmlstarlet unesc | fmt -80 - } + function taocl() { + curl -s https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README-de.md | + pandoc -f markdown -t html | + xmlstarlet fo --html --dropdtd | + xmlstarlet sel -t -v "(html/body/ul/li[count(p)>0])[$RANDOM mod last()+1]" | + xmlstarlet unesc | fmt -80 + } ``` @@ -407,21 +408,21 @@ Ein paar Beispiele, wie man Befehle zusammen benutzen kann: - `nl`: Füge Zeilennummern hinzu -- `seq`: Gebe Zahlen aus +- `seq`: Gib Zahlen aus - `bc`: Taschenrechner -- `factor`: faktorisiere Ganzzahlen +- `factor`: Faktorisiere Ganzzahlen -- [`gpg`](https://gnupg.org/): Verschlüssle und signiere Dateien +- [`gpg`](https://gnupg.org/): Verschlüsseln und Signieren von Dateien -- `toe`: Tabelle von terminfo Einträgen +- `toe`: Tabelle von `terminfo`-Einträgen -- `nc`: Netzwerk Debugging und Datentransfer +- `nc`: Netzwerk-Debugging und Datentransfer -- `socat`: Socket und TCP Port Weiterleitung (ähnlich wie `netcat`) +- `socat`: Socket- und TCP-Port-Weiterleitung (ähnlich wie `netcat`) -- [`slurm`](https://github.com/mattthias/slurm): Netzwerk Verkehr Visulaisierung +- [`slurm`](https://github.com/mattthias/slurm): Visulaisierung des Netzwerkverkehrs ("traffic") - `dd`: Daten zwischen Dateien und Geräten bewegen @@ -579,7 +580,7 @@ Diese Hinweise sind *nur* für Windows relevant. - [awesome-shell](https://github.com/alebcay/awesome-shell): Eine hilfreiche Liste von Shell-Werkzeugen und Quellen. - [awesome-osx-command-line](https://github.com/herrbischoff/awesome-osx-command-line): Eine ausführliche Anleitung für die Befehlszeile unter OS X. - [Strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/), um bessere Shell-Skripte zu schreiben. -- [shellcheck](https://github.com/koalaman/shellcheck) - Ein statisches Analysetool für Shell-Skripte. Im Grunde lint für bash/sh/zsh. +- [shellcheck](https://github.com/koalaman/shellcheck): Ein statisches Analysetool für Shell-Skripte. Im Grunde lint für bash/sh/zsh. - [Filenames and Pathnames in Shell](http://www.dwheeler.com/essays/filenames-in-shell.html): Entmutigend komplexe Einzelheiten darüber, wie Dateinamen in Shell-Skripts richtig eingesetzt werden. - [Data Science at the Command Line](http://datascienceatthecommandline.com/#tools): Mehr Befehle und Werkzeuge, die für ["data science"](https://de.wikipedia.org/wiki/Data_Science) hilfreich sind, aus dem gleichnamigen Buch. From 407c7adc265b96c6fef55fbf55cc62c0ebfde749 Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Wed, 7 Sep 2016 07:56:45 +0200 Subject: [PATCH 23/26] Double-checked --- README-de.md | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/README-de.md b/README-de.md index 54bc4a9..6e3d9ba 100644 --- a/README-de.md +++ b/README-de.md @@ -117,7 +117,7 @@ Hinweise: - Verwende `alias`, um Verknüpfungen für gebräuchliche Befehle zu erstellen. So erstellt etwa `alias ll='ls -latr'` den neuen Alias `ll`. -- Speichere Alternativnamen ("aliases"), Shelleinstellungen und häufig benutzte Funktionen in `~/.bashrc` und [stelle sie anderen Login-Shells zur Verfügung](http://superuser.com/a/183980/7106). So hast du auf dein Setup auch in allen anderen Shellsessions Zugriff. +- Speichere diese Alternativnamen ("aliases"), Shell-Einstellungen und häufig benutzte Funktionen in `~/.bashrc` und [stelle sie anderen Login-Shells zur Verfügung](http://superuser.com/a/183980/7106). So hast du auf dein Setup auch in allen anderen Shell-Sessions Zugriff. - Platziere Einstellungen von Umgebungsvariablen sowie Befehle, welche nach einer Anmeldung ausgeführt werden sollen, in `~/.bash_profile`. Eine separate Konfiguration ist notwendig für Shells, welche du von einer grafischen Benutzeroberfläche startest sowie für `cron`-Jobs. @@ -175,7 +175,7 @@ Hinweise: ControlPersist yes ``` -- Einige andere Optionen im Zusammenhang mit SSH sind sicherheitsrelevant und sollten nur mit Bedacht aktiviert werden, etwa Zugriff per Subnet oder Host sowie in vertrauenswürdigen Netzwerken: `StrictHostKeyChecking=no`, `ForwardAgent=yes` +- Einige andere Optionen im Zusammenhang mit SSH sind sicherheitsrelevant und sollten nur mit Bedacht aktiviert werden, etwa Zugriff per Subnet oder Host sowie in vertrauenswürdigen Netzwerken: `StrictHostKeyChecking=no`, `ForwardAgent=yes`. - Erwäge [`mosh`](https://mosh.mit.edu/) als Alternative zu `ssh`, die UDP benutzt, um so abgebrochene Verbindungen zu vermeiden, was ja in gewisser Hinsicht auch komfortabel ist (benötigt Server-seitiges Setup). @@ -188,8 +188,7 @@ Hinweise: - Verwende `fpp` ([PathPicker](https://github.com/facebook/PathPicker)) zur Interaktion mit Dateien als Output eines anderen Befehls (wie etwa `git`). -- Verwende für einen einfachen Webserver für alle Dateien im aktuellen Verzeichnis (sowie Unterverzeichnisse), der für alle in deinem Netzwerk abrufbar ist: -`python -m SimpleHTTPServer 7777` (für Port 7777 und Python 2) sowie `python -m http.server 7777` (für Port 7777 und Python 3). +- Verwende für einen einfachen Webserver für alle Dateien im aktuellen Verzeichnis (sowie Unterverzeichnisse), der für alle in deinem Netzwerk abrufbar ist: `python -m SimpleHTTPServer 7777` (für Port 7777 und Python 2) sowie `python -m http.server 7777` (für Port 7777 und Python 3). - Benutze `sudo`, um einen Befehl als ein anderer Benutzer auszuführen. Standardmäßig ist dies die Ausführung als root; benutze `-u` zur Angabe eines anderen benutzers sowie `-i`, um dich als dieser anzumelden (du wirst nach _deinem_ Passwort gefragt). @@ -348,8 +347,7 @@ Ein paar Beispiele, wie man Befehle zusammen benutzen kann: awk '{ x += $3 } END { print x }' meinedatei ``` -- Falls man die Größen/Datumsangaben von einem Dateibaum wissen möchte, funktioniert das Folgende wie ein rekursives `ls -l`, aber ist - leichter zu lesen als `ls -lR`: +- Falls man die Größen/Datumsangaben von einem Dateibaum wissen möchte, funktioniert das Folgende wie ein rekursives `ls -l`, aber ist leichter zu lesen als `ls -lR`: ```sh find . -type f -ls ``` @@ -382,9 +380,9 @@ Ein paar Beispiele, wie man Befehle zusammen benutzen kann: - `expr`: Führe arithmetische oder bool'sche Operationen aus oder werte reguläre Ausdrücke aus -- `m4`: Simpler Macro Auswerter +- `m4`: Simpler Macro-Auswerter -- `yes`: Gebe eine Zeichenkette sehr oft aus +- `yes`: Gib eine Zeichenkette sehr oft aus - `cal`: Netter Kalender From 6eed1402a1d1bcbdcdaaa8aeaa18c588f7aa7cb2 Mon Sep 17 00:00:00 2001 From: S1SYPHOS Date: Wed, 7 Sep 2016 10:39:06 +0200 Subject: [PATCH 24/26] Add german translation team to authors-info.yml --- admin/authors-info.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/admin/authors-info.yml b/admin/authors-info.yml index f61cf95..11ccafd 100644 --- a/admin/authors-info.yml +++ b/admin/authors-info.yml @@ -51,4 +51,6 @@ roles: rverchere: translator (fr) kevingo: translation maintainer (zh-Hant) anna-d: translation maintainer (el) + S1SYPHOS: translation maintainer (de) + gernd: translator (de) dspinellis: section maintainer (Windows) From 6faaf8bb0e0cd2894bbf55bf26cf7bca41677a9b Mon Sep 17 00:00:00 2001 From: Joshua Levy Date: Wed, 7 Sep 2016 22:49:33 -0700 Subject: [PATCH 25/26] de translation links. --- README-cs.md | 2 +- README-el.md | 2 +- README-es.md | 2 +- README-fr.md | 2 +- README-it.md | 2 +- README-ja.md | 2 +- README-ko.md | 2 +- README-pt.md | 2 +- README-ru.md | 2 +- README-sl.md | 2 +- README-uk.md | 2 +- README-zh-Hant.md | 2 +- README-zh.md | 2 +- README.md | 2 +- 14 files changed, 14 insertions(+), 14 deletions(-) diff --git a/README-cs.md b/README-cs.md index 070b559..33cfddf 100644 --- a/README-cs.md +++ b/README-cs.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # Umění příkazové řádky diff --git a/README-el.md b/README-el.md index 7fab5d3..e7b3861 100644 --- a/README-el.md +++ b/README-el.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # Η Τέχνη της Γραμμής Εντολών diff --git a/README-es.md b/README-es.md index 39281cf..fbfd016 100644 --- a/README-es.md +++ b/README-es.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # El Arte del Terminal diff --git a/README-fr.md b/README-fr.md index 26c227f..4e03ca5 100644 --- a/README-fr.md +++ b/README-fr.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # L'art de la ligne de commande diff --git a/README-it.md b/README-it.md index 313a3cc..40b650f 100644 --- a/README-it.md +++ b/README-it.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # The Art of Command Line (Traduzione Italiana) diff --git a/README-ja.md b/README-ja.md index 3270eca..dda5fd3 100644 --- a/README-ja.md +++ b/README-ja.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* 原文のコミット [ee4b00bc396087d27231f60512aeb77b19ce734e](https://github.com/jlevy/the-art-of-command-line/blob/ee4b00bc396087d27231f60512aeb77b19ce734e/README.md) diff --git a/README-ko.md b/README-ko.md index 6566944..992233a 100644 --- a/README-ko.md +++ b/README-ko.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # The Art of Command Line diff --git a/README-pt.md b/README-pt.md index c5d4676..3df275e 100644 --- a/README-pt.md +++ b/README-pt.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # A arte da linha de comando diff --git a/README-ru.md b/README-ru.md index 2173c80..91a9251 100644 --- a/README-ru.md +++ b/README-ru.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # Искусство командной строки diff --git a/README-sl.md b/README-sl.md index 824c5e9..654578c 100644 --- a/README-sl.md +++ b/README-sl.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # Umetnost ukazne vrstice diff --git a/README-uk.md b/README-uk.md index c2adc05..bf17d4c 100644 --- a/README-uk.md +++ b/README-uk.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # Мистецтво командного рядка diff --git a/README-zh-Hant.md b/README-zh-Hant.md index 5d9e512..16fa13a 100644 --- a/README-zh-Hant.md +++ b/README-zh-Hant.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # 命令列的藝術 diff --git a/README-zh.md b/README-zh.md index bfbfce8..ebc4bdb 100644 --- a/README-zh.md +++ b/README-zh.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # 命令行的艺术 diff --git a/README.md b/README.md index 85d7db6..42f45d9 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ 🌍 -*[Čeština](README-cs.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* +*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [Português](README-pt.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)* # The Art of Command Line From 92fa33faa948af3bc20db824b130866d6325a400 Mon Sep 17 00:00:00 2001 From: Joshua Levy Date: Wed, 7 Sep 2016 22:53:40 -0700 Subject: [PATCH 26/26] Authors list update. --- AUTHORS.md | 66 +++++++++++++++++++++++++++++++++--------------------- 1 file changed, 41 insertions(+), 25 deletions(-) diff --git a/AUTHORS.md b/AUTHORS.md index da56937..c134346 100644 --- a/AUTHORS.md +++ b/AUTHORS.md @@ -12,86 +12,101 @@ They have kindly agreed to review and help update future contributions for the t * [Antonio Ossa (aaossa)](https://github.com/aaossa) — [5+](https://github.com/jlevy/the-art-of-command-line/commits?author=aaossa)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aaaossa) — _translator (es)_ * [Ahmet Alp Balkan (ahmetalpbalkan)](https://github.com/ahmetalpbalkan) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=ahmetalpbalkan)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aahmetalpbalkan) * [Semir Patel (analogue)](https://github.com/analogue) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=analogue)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aanalogue) +* [Andreas Hofmann (andreas-hofmann)](https://github.com/andreas-hofmann) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=andreas-hofmann)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aandreas-hofmann) * [Desmond Stonie (aneasystone)](https://github.com/aneasystone) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=aneasystone)/[8+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aaneasystone) * [Haoxuan Li (angel1a)](https://github.com/angel1a) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=angel1a)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aangel1a) -* [anna-d (anna-d)](https://github.com/anna-d) — [19+](https://github.com/jlevy/the-art-of-command-line/commits?author=anna-d)/[4+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aanna-d) — _translation maintainer (el)_ +* [anna-4](https://github.com/anna-4) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=anna-4)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aanna-4) +* [anna-d (anna-d)](https://github.com/anna-d) — [19+](https://github.com/jlevy/the-art-of-command-line/commits?author=anna-d)/[5+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aanna-d) — _translation maintainer (el)_ * [Chong Guo (Armour)](https://github.com/Armour) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=Armour)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AArmour) — _translator (zh)_ * [Brad Beyenhof (augmentedfourth)](https://github.com/augmentedfourth) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=augmentedfourth)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aaugmentedfourth) * [b-jazz (b-jazz)](https://github.com/b-jazz) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=b-jazz)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ab-jazz) * [bafoed](https://github.com/bafoed) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=bafoed)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Abafoed) * [Alex Vergara Gil (BishopWolf)](https://github.com/BishopWolf) — [4+](https://github.com/jlevy/the-art-of-command-line/commits?author=BishopWolf)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ABishopWolf) — _translator (es)_ -* [Arturo Fernandez (bsnux)](https://github.com/bsnux) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=bsnux)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Absnux) +* [Arturo Fernandez (bsnux)](https://github.com/bsnux) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=bsnux)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Absnux) * [Alex Cabrera (cabreraalex)](https://github.com/cabreraalex) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=cabreraalex)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Acabreraalex) * [Carlos Mantilla (ceoaliongroo)](https://github.com/ceoaliongroo) — [29+](https://github.com/jlevy/the-art-of-command-line/commits?author=ceoaliongroo)/[16+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aceoaliongroo) — _translation maintainer (es)_ -* [Chris Kuehl (chriskuehl)](https://github.com/chriskuehl) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=chriskuehl)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Achriskuehl) +* [Chris Kuehl (chriskuehl)](https://github.com/chriskuehl) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=chriskuehl)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Achriskuehl) * [Corey "See More" Richardson (cmr)](https://github.com/cmr) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=cmr)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Acmr) -* [Colas BROUX (ColasBroux)](https://github.com/ColasBroux) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=ColasBroux)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AColasBroux) +* [CodinCat (CodinCat)](https://github.com/CodinCat) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=CodinCat)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ACodinCat) +* [Colas BROUX (ColasBroux)](https://github.com/ColasBroux) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=ColasBroux)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AColasBroux) * [Colin Wang (colinwjd)](https://github.com/colinwjd) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=colinwjd)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Acolinwjd) * [Chris Rhodes (crr0004)](https://github.com/crr0004) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=crr0004)/[4+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Acrr0004) * [Chelsea Voss (csvoss)](https://github.com/csvoss) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=csvoss)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Acsvoss) * [Daniel t. (danasmera)](https://github.com/danasmera) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=danasmera)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adanasmera) * [Dmytro Danylevskyi (danylevskyi)](https://github.com/danylevskyi) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=danylevskyi)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adanylevskyi) * [Dave Loyall (daveloyall)](https://github.com/daveloyall) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=daveloyall)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adaveloyall) -* [Deborah Digges (Deborah-Digges)](https://github.com/Deborah-Digges) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=Deborah-Digges)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ADeborah-Digges) +* [Deborah Digges (Deborah-Digges)](https://github.com/Deborah-Digges) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=Deborah-Digges)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ADeborah-Digges) * [Jamie Luck (delucks)](https://github.com/delucks) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=delucks)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adelucks) -* [Dima Paloskin (dimapaloskin)](https://github.com/dimapaloskin) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=dimapaloskin)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adimapaloskin) +* [Dima Paloskin (dimapaloskin)](https://github.com/dimapaloskin) * [Michael Diamond (dimo414)](https://github.com/dimo414) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=dimo414)/[4+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adimo414) -* [Dmytro Kovalov (uk: Дмитро Ковальов) (dmytro)](https://github.com/dmytro) — [5+](https://github.com/jlevy/the-art-of-command-line/commits?author=dmytro)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Admytro) — _translation maintainer (uk)_ +* [Dmytro Kovalov (uk: Дмитро Ковальов) (dmytro)](https://github.com/dmytro) — [6+](https://github.com/jlevy/the-art-of-command-line/commits?author=dmytro)/[4+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Admytro) — _translation maintainer (uk)_ * [Hayato Matsuura (doublemarket)](https://github.com/doublemarket) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=doublemarket)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adoublemarket) — _translation maintainer (ja)_ * [Diomidis Spinellis (dspinellis)](https://github.com/dspinellis) — [12+](https://github.com/jlevy/the-art-of-command-line/commits?author=dspinellis)/[5+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adspinellis) — _section maintainer (Windows)_ -* [Vincent Wong (EaterOA)](https://github.com/EaterOA) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=EaterOA)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AEaterOA) -* [Éric Guirbal (ericguirbal)](https://github.com/ericguirbal) — [22+](https://github.com/jlevy/the-art-of-command-line/commits?author=ericguirbal)/[6+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aericguirbal) — _translation maintainer (fr)_ +* [Vincent Wong (EaterOA)](https://github.com/EaterOA) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=EaterOA)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AEaterOA) +* [Éric Guirbal (ericguirbal)](https://github.com/ericguirbal) — [25+](https://github.com/jlevy/the-art-of-command-line/commits?author=ericguirbal)/[8+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aericguirbal) — _translation maintainer (fr)_ +* [Fernando Almeida (fernandoalmeida)](https://github.com/fernandoalmeida) — [8+](https://github.com/jlevy/the-art-of-command-line/commits?author=fernandoalmeida)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Afernandoalmeida) * [Yessou Sami (fnzv)](https://github.com/fnzv) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=fnzv)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Afnzv) * [Francesco Malatesta (francescomalatesta)](https://github.com/francescomalatesta) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=francescomalatesta)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Afrancescomalatesta) — _translation maintainer (it)_ -* [githubashto](https://github.com/githubashto) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=githubashto)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agithubashto) — _translator (ru)_ +* [Gaga Pan (gaga5lala)](https://github.com/gaga5lala) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=gaga5lala)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agaga5lala) +* [Gernot Pointner (gernd)](https://github.com/gernd) — [6+](https://github.com/jlevy/the-art-of-command-line/commits?author=gernd)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agernd) — _translator (de)_ +* [githubashto](https://github.com/githubashto) — _translator (ru)_ * [Grigory Rechistov (grigory-rechistov)](https://github.com/grigory-rechistov) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=grigory-rechistov)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agrigory-rechistov) — _translator (ru)_ * [Konstantin Gribov (grossws)](https://github.com/grossws) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=grossws)/[6+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agrossws) -* [Beau Hastings (hastinbe)](https://github.com/hastinbe) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=hastinbe)/[4+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ahastinbe) -* [Sung Kim (hunkim)](https://github.com/hunkim) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=hunkim)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ahunkim) — _translator (ko)_ +* [Ashhar Hasan (hashhar)](https://github.com/hashhar) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=hashhar)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ahashhar) +* [Beau Hastings (hastinbe)](https://github.com/hastinbe) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=hastinbe)/[4+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ahastinbe) +* [Sung Kim (hunkim)](https://github.com/hunkim) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=hunkim)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ahunkim) — _translator (ko)_ * [Hunter-Github](https://github.com/Hunter-Github) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=Hunter-Github)/[5+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AHunter-Github) * [Hyojin Kwak (hyojin)](https://github.com/hyojin) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=hyojin)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ahyojin) * [Ihor Dvoretskyi (idvoretskyi)](https://github.com/idvoretskyi) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=idvoretskyi)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aidvoretskyi) +* [Kevin Morales (iKenshu)](https://github.com/iKenshu) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=iKenshu)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AiKenshu) * [Ivgeni "Iv" Segal (isegal)](https://github.com/isegal) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=isegal)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aisegal) * [Igor Veksler (iveksl2)](https://github.com/iveksl2) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=iveksl2)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aiveksl2) * [J Alan Brogan (jalanb)](https://github.com/jalanb) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=jalanb)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajalanb) -* [Jᴀᴍᴇs Kᴏʟᴄᴇ (jameskolce)](https://github.com/jameskolce) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=jameskolce)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajameskolce) -* [Joshua Levy (jlevy)](https://github.com/jlevy) — [137+](https://github.com/jlevy/the-art-of-command-line/commits?author=jlevy)/[26+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajlevy) — _orignal author and project maintainer_ -* [Jesse Sightler (jsight)](https://github.com/jsight) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=jsight)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajsight) +* [James Kolce (jameskolce)](https://github.com/jameskolce) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=jameskolce)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajameskolce) +* [Joshua Levy (jlevy)](https://github.com/jlevy) — [140+](https://github.com/jlevy/the-art-of-command-line/commits?author=jlevy)/[38+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajlevy) — _orignal author and project maintainer_ +* [Jesse Sightler (jsight)](https://github.com/jsight) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=jsight)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajsight) * [Konstantin Mikhaylov (jtraub)](https://github.com/jtraub) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=jtraub)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajtraub) -* [Wael M. Nasreddine (kalbasit)](https://github.com/kalbasit) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=kalbasit)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akalbasit) -* [Colin Chan (kalgynirae)](https://github.com/kalgynirae) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=kalgynirae)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akalgynirae) +* [Jakub Wilk (jwilk)](https://github.com/jwilk) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=jwilk)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajwilk) +* [Wael Nasreddine (kalbasit)](https://github.com/kalbasit) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=kalbasit)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akalbasit) +* [Colin Chan (kalgynirae)](https://github.com/kalgynirae) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=kalgynirae)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akalgynirae) * [Michail Kargakis (kargakis)](https://github.com/kargakis) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=kargakis)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akargakis) -* [kstn (kastian)](https://github.com/kastian) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=kastian)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akastian) — _translator (ru)_ +* [kstn (kastian)](https://github.com/kastian) — _translator (ru)_ * [Kesu J (kesu)](https://github.com/kesu) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=kesu)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akesu) * [kevingo (kevingo)](https://github.com/kevingo) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=kevingo)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akevingo) — _translation maintainer (zh-Hant)_ * [Konstantin Ilyashenko (kostya13)](https://github.com/kostya13) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=kostya13)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akostya13) * [Takuma Yamaguchi (kumon)](https://github.com/kumon) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=kumon)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akumon) +* [Dmytro Prokhorenkov (l13t)](https://github.com/l13t) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=l13t)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Al13t) * [Lakshmipathi (Lakshmipathi)](https://github.com/Lakshmipathi) — [10+](https://github.com/jlevy/the-art-of-command-line/commits?author=Lakshmipathi)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ALakshmipathi) * [Pavel Zhukov (landgraf)](https://github.com/landgraf) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=landgraf)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Alandgraf) * [Lampros Mountrakis (lmount)](https://github.com/lmount) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=lmount)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Almount) * [lsrom](https://github.com/lsrom) — [14+](https://github.com/jlevy/the-art-of-command-line/commits?author=lsrom)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Alsrom) — _translation maintainer (cs)_ * [Luke Yeager (lukeyeager)](https://github.com/lukeyeager) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=lukeyeager)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Alukeyeager) * [TAKAGI Masahiro (m-takagi)](https://github.com/m-takagi) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=m-takagi)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Am-takagi) -* [Matjaž Lipuš (matjaz)](https://github.com/matjaz) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=matjaz)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amatjaz) -* [Mayra Cabrera (mayra-cabrera)](https://github.com/mayra-cabrera) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=mayra-cabrera)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amayra-cabrera) +* [Not Mark (mark-i-m)](https://github.com/mark-i-m) — [5+](https://github.com/jlevy/the-art-of-command-line/commits?author=mark-i-m)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amark-i-m) +* [marocchino](https://github.com/marocchino) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=marocchino)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amarocchino) +* [Matjaž Lipuš (matjaz)](https://github.com/matjaz) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=matjaz)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amatjaz) +* [Mayra Cabrera (mayra-cabrera)](https://github.com/mayra-cabrera) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=mayra-cabrera)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amayra-cabrera) * [Michael Barlow (michaelbarlow7)](https://github.com/michaelbarlow7) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=michaelbarlow7)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amichaelbarlow7) +* [Jinhui-Lin (mintisan)](https://github.com/mintisan) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=mintisan)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amintisan) * [Crisoforo Gaspar Hernández (mitogh)](https://github.com/mitogh) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=mitogh)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amitogh) * [miuc (miuc)](https://github.com/miuc) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=miuc)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amiuc) -* [Michael Kwardakov (mkwardakov)](https://github.com/mkwardakov) — [5+](https://github.com/jlevy/the-art-of-command-line/commits?author=mkwardakov)/[4+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amkwardakov) +* [Michael Kwardakov (mkwardakov)](https://github.com/mkwardakov) — [5+](https://github.com/jlevy/the-art-of-command-line/commits?author=mkwardakov)/[5+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amkwardakov) * [Harry Moreno (morenoh149)](https://github.com/morenoh149) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=morenoh149)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amorenoh149) -* [Dongliang Mu (mudongliang)](https://github.com/mudongliang) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=mudongliang)/[7+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amudongliang) +* [Dongliang Mu (mudongliang)](https://github.com/mudongliang) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=mudongliang)/[8+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amudongliang) * [Nilton Vasques (niltonvasques)](https://github.com/niltonvasques) — [24+](https://github.com/jlevy/the-art-of-command-line/commits?author=niltonvasques)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aniltonvasques) — _translation maintainer (pt)_ * [Oleg Berman (olegberman)](https://github.com/olegberman) — [15+](https://github.com/jlevy/the-art-of-command-line/commits?author=olegberman)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aolegberman) — _translation maintainer (ru)_ * [osmero](https://github.com/osmero) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=osmero)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aosmero) — _translator (ru)_ -* [Serg Petrov (p12se)](https://github.com/p12se) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=p12se)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ap12se) -* [Peter Kokot (peterkokot)](https://github.com/peterkokot) — [37+](https://github.com/jlevy/the-art-of-command-line/commits?author=peterkokot)/[29+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Apeterkokot) — _translation maintainer (sl)_ +* [Serg Petrov (p12se)](https://github.com/p12se) +* [Peter Kokot (peterkokot)](https://github.com/peterkokot) — [46+](https://github.com/jlevy/the-art-of-command-line/commits?author=peterkokot)/[32+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Apeterkokot) — _translation maintainer (sl)_ * [Ryan (picasso250)](https://github.com/picasso250) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=picasso250)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Apicasso250) * [Chujie Zeng (Psycho7)](https://github.com/Psycho7) — [19+](https://github.com/jlevy/the-art-of-command-line/commits?author=Psycho7)/[8+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3APsycho7) — _translation maintainer (zh)_ * [Rahul Kavale (rahulkavale)](https://github.com/rahulkavale) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=rahulkavale)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Arahulkavale) * [Raju Devidas Vindane (rajuvindane)](https://github.com/rajuvindane) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=rajuvindane)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Arajuvindane) * [Rasmus Wriedt Larsen (RasmusWL)](https://github.com/RasmusWL) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=RasmusWL)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ARasmusWL) * [Riley Shaw (rileyjshaw)](https://github.com/rileyjshaw) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=rileyjshaw)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Arileyjshaw) -* [Remi Verchere (rverchere)](https://github.com/rverchere) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=rverchere)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Arverchere) — _translator (fr)_ +* [Ryan Delaney (rpdelaney)](https://github.com/rpdelaney) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=rpdelaney)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Arpdelaney) +* [Remi Verchere (rverchere)](https://github.com/rverchere) — _translator (fr)_ +* [S1SYPHOS (S1SYPHOS)](https://github.com/S1SYPHOS) — [7+](https://github.com/jlevy/the-art-of-command-line/commits?author=S1SYPHOS)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AS1SYPHOS) — _translation maintainer (de)_ * [Saksham Sharma (sakshamsharma)](https://github.com/sakshamsharma) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=sakshamsharma)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Asakshamsharma) * [Kit Chan (shukitchan)](https://github.com/shukitchan) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=shukitchan)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ashukitchan) * [Simarpreet Singh (simar7)](https://github.com/simar7) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=simar7)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Asimar7) @@ -105,6 +120,7 @@ They have kindly agreed to review and help update future contributions for the t * [taxusyew](https://github.com/taxusyew) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=taxusyew)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ataxusyew) * [Thomas Lee (ThomasLee969)](https://github.com/ThomasLee969) — [12+](https://github.com/jlevy/the-art-of-command-line/commits?author=ThomasLee969)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AThomasLee969) * [Timur (tim-teufel)](https://github.com/tim-teufel) — [4+](https://github.com/jlevy/the-art-of-command-line/commits?author=tim-teufel)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Atim-teufel) +* [Timothy Qiu (timothyqiu)](https://github.com/timothyqiu) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=timothyqiu)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Atimothyqiu) * [René Ribaud (uggla)](https://github.com/uggla) — [5+](https://github.com/jlevy/the-art-of-command-line/commits?author=uggla)/[10+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Auggla) * [Sungjin Kang (ujuc)](https://github.com/ujuc) — [6+](https://github.com/jlevy/the-art-of-command-line/commits?author=ujuc)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aujuc) — _translator (ko)_ * [Ungsik Yun (Ungsik-Yun)](https://github.com/Ungsik-Yun) — [15+](https://github.com/jlevy/the-art-of-command-line/commits?author=Ungsik-Yun)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AUngsik-Yun) — _translation maintainer (ko)_