Linux Systems

#14: Post edited by

alx‭ · 2023-11-14T11:24:10Z (about 1 year ago)

Copy Link

Raw

Markdown

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type` --at least three spaces between `/` and `-`; this forum collapses multiple spaces--).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
~~Both programs display the name of some pages, followed by a short description of them. They differ in what they find.~~
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description for the term you specified. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
If you find info(1) difficult to use, you can pipe it to less(1) to read it all in one take, as if it were a manual page:
`info printf | less`
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type` --at least three spaces between `/` and `-`; this forum collapses multiple spaces--).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them (it is the NAME (or Name) section of the manual page that these commands print). They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description for the term you specified. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
If you find info(1) difficult to use, you can pipe it to less(1) to read it all in one take, as if it were a manual page:
`info printf | less`
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.

#13: Post edited by

alx‭ · 2023-11-14T10:12:58Z (about 1 year ago)

Copy Link

Raw

Markdown

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description for the term you specified. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
If you find info(1) difficult to use, you can pipe it to less(1) to read it all in one take, as if it were a manual page:
`info printf | less`
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type` --at least three spaces between `/` and `-`; this forum collapses multiple spaces--).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description for the term you specified. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
If you find info(1) difficult to use, you can pipe it to less(1) to read it all in one take, as if it were a manual page:
`info printf | less`
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.

#12: Post edited by

alx‭ · 2023-11-14T00:23:48Z (about 1 year ago)

Copy Link

Raw

Markdown

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
If you find info(1) difficult to use, you can pipe it to less(1) to read it all in one take, as if it were a manual page:
`info printf | less`
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description for the term you specified. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
If you find info(1) difficult to use, you can pipe it to less(1) to read it all in one take, as if it were a manual page:
`info printf | less`
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.

#11: Post edited by

alx‭ · 2023-11-14T00:22:22Z (about 1 year ago)

Copy Link

Raw

Markdown

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
~~If you find info(1) difficult to use, you can pipe it to less(1) to read it all in one take, as if it were a huge manual page:~~
`info printf | less`
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
If you find info(1) difficult to use, you can pipe it to less(1) to read it all in one take, as if it were a manual page:
`info printf | less`
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.

#10: Post edited by

alx‭ · 2023-11-14T00:21:33Z (about 1 year ago)

Copy Link

Raw

Markdown

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
If you find info(1) difficult to use, you can pipe it to less(1) to read it all in one take, as if it were a huge manual page:
`info printf | less`
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.

#9: Post edited by

alx‭ · 2023-11-14T00:19:17Z (about 1 year ago)

Copy Link

Raw

Markdown

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
~~### Interactive programs~~
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.
~~<https://tldr.sh/>~~

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.

#8: Post edited by

alx‭ · 2023-11-14T00:18:56Z (about 1 year ago)

Copy Link

Raw

Markdown

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
### Interactive programs
In interactive programs, there's usually a key that shows the help of the program, reminding you the keys for the interactive commands of the program. less(1) uses `h`; mutt(1) uses `?`. `h` and `?` are common keys for that.
<https://tldr.sh/>

#7: Post edited by

alx‭ · 2023-11-14T00:15:30Z (about 1 year ago)

Copy Link

Raw

Markdown

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then, for example, use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>

#6: Post edited by

alx‭ · 2023-11-14T00:15:06Z (about 1 year ago)

Copy Link

Raw

Markdown

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a page. On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a descriptive page. On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>

#5: Post edited by

alx‭ · 2023-11-14T00:13:36Z (about 1 year ago)

Copy Link

Raw

Markdown

~~## Learn the pager~~
### less(1)
less(1) is the usual pager nowadays. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a page. On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>

## The pager
### less(1)
less(1) is the usual pager nowadays; you would do well learning to use it. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## Filtering
### grep(1)
It may be useful to produce an index of a manual page:
```
$ man ldd | grep -e '^ \{0,3\}[^ ]' -e '^ \{4,7\}-'
ldd(1) General Commands Manual ldd(1)
NAME
SYNOPSIS
DESCRIPTION
Security
OPTIONS
--version
--verbose
-v Print all information, including, for example, symbol versioning
--unused
-u Print unused direct dependencies. (Since glibc 2.3.4.)
--data-relocs
-d Perform relocations and report any missing objects (ELF only).
--function-relocs
-r Perform relocations for both data objects and functions, and re‐
--help
BUGS
SEE ALSO
Linux man‐pages (unreleased) (date) ldd(1)
```
You can use more complex filters to, for example, read only a specific section(s) of a manual page.
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a page. On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>

#4: Post edited by

alx‭ · 2023-11-14T00:08:46Z (about 1 year ago)

Copy Link

Raw

Markdown

## Learn the pager
### less(1)
less(1) is the usual pager nowadays. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a page. On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).

## Learn the pager
### less(1)
less(1) is the usual pager nowadays. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a page. On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).
<https://tldr.sh/>

#3: Post edited by

alx‭ · 2023-11-14T00:08:10Z (about 1 year ago)

Copy Link

Raw

Markdown

## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a page. On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).

## Learn the pager
### less(1)
less(1) is the usual pager nowadays. It's also used for paging the manual pages, in most systems. The most common operation is searching, which is done by pressing `/`. Press `h` within the pager, or run `less --help` to read its help for interactive use of the pager.
While reading a manual page, I often find myself searching for specific options of a command. Imagine I want to search for the option `-type` of find(1). I type `/^ *-type` (or being lazy, I often type `/ -type`).
-----
## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a page. On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).

#2: Post edited by

alx‭ · 2023-11-13T17:32:03Z (about 1 year ago)

Copy Link

Raw

Markdown

## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and only sometimes they have also manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a page. On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).

## whatis(1) vs apropos(1)
Both programs display the name of some pages, followed by a short description of them. They differ in what they find.
### whatis(1)
You ask **what is** a term (a command, a C function, ...), and it tells you a short description.
This program searches for manual pages whose name matches the term you specified.
### apropos(1)
This program searches both the name of pages and their short description, and finds anything that matches both. It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".
-----
## Other documentation formats
### info(1)
info(1) is an alternative system, much more complex than man(1). The GNU project doesn't like manual pages, and developed their own documentation format, and formatter. GNU programs always have info(1) documentation, and often (but not always) they also have manual pages. Non-GNU projects tend to only have manual pages.
I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.
### help(1)
Shells usually provide a help(1) command that documents the built-ins of the shell. This is the case with `read`, `cd`, ... There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).
Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).
### tldr(1)
These pages present short and common examples with a short explanation. Sometimes it's easier to start reading examples rather than trying to read a page. On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).

#1: Initial revision by

alx‭ · 2023-11-13T17:31:25Z (about 1 year ago)

Copy Link

Raw

Markdown

## whatis(1) vs apropos(1)

Both programs display the name of some pages, followed by a short description of them.  They differ in what they find.

### whatis(1)

You ask **what is** a term (a command, a C function, ...), and it tells you a short description.

This program searches for manual pages whose name matches the term you specified.

### apropos(1)

This program searches both the name of pages and their short description, and finds anything that matches both.  It's more like "I'm not sure what I'm searching for, please show me anything that resembles this".

-----

## Other documentation formats

### info(1)

info(1) is an alternative system, much more complex than man(1).  The GNU project doesn't like manual pages, and developed their own documentation format, and formatter.  GNU programs always have info(1) documentation, and only sometimes they have also manual pages.  Non-GNU projects tend to only have manual pages.

I read their manual pages, unless I don't find what I'm looking for, in which case I look at their info(1) manual.

### help(1)

Shells usually provide a help(1) command that documents the built-ins of the shell.  This is the case with `read`, `cd`, ...  There's no binary program being run, but rather a built-in function within the shell; this can optimize some common operations, or in some cases it's impossible to implement some functionality in the form of a binary program (e.g., `cd`).

Most of these built-ins are defined by POSIX, so you can still read the POSIX manual page for the utility (install `manpages-posix` on Debian).

### tldr(1)

These pages present short and common examples with a short explanation.  Sometimes it's easier to start reading examples rather than trying to read a page.  On Debian, `apt-get install tldr`; then use `tldr tar` to read examples of use of tar(1).

Communities

Post History