4 (Attribution : A significant chunk of the content under this section is based on data from Wikipedia and the Linux Documentation Project)

     4 We are here to welcome you to Linux. GNU/Linux is an operating system that is similar to the UNIX operating system, but is open source software. Being an open source program means that (if you wanted to) you could view the source code of the operating system and change it to suit your needs. 

     5 

     5 

     6 Linux (usually pronounced ˈlɪnəks') is a generic term referring to Unix-like computer operating systems based on the Linux kernel, where a kernel is the intermediate layer between the hardware and the applications. The kernel is, on an abstract level, the core of (most) operating systems, that manages the various system resources. The development of the Linux OS is considered the basis for Free and Open Source Software (FOSS) collaboration since typically the underlying source code can be used, modified freely, and redistributed by anyone under the terms of the GNU (a recursive acronym for "GNU's Not Unix!") Global Public License (GPL) and other free software licences. This freedom to access and reuse various components of a system, is one of the primary reasons for the popularity of Linux.

     6 The name "Linux" properly refers to an operating system "kernel", a single but key component of a complete operating system. In everyday use, the term "Linux" is frequently used to refer to a complete operating system which consists of the kernel and some of the thousands of other programs required to make an operating system useful. Much of the important system software that is typically installed on a Linux system comes from The GNU Project, a project to build an operating system made entirely of free software.

     7 

     7 The first Linux kernel was created by Linus Torvalds. It was started as an x86-only, single processor operating system, but grew to become one of the most ported pieces of software. Other parts of a complete GNU/Linux system come from other projects such as the GNU project, and are integrated into a complete GNU/Linux OS by your supplier. Usually your supplier will assign their own version number to the integrated whole.This collection of the kernal and programs maintained by vendor is called distro or distribution.

     8 Linux is installed on a variety of computer hardware, that include mobile phones, embedded devices and supercomputers, but is infamous for its use in servers.

     8 The GNU Project is overseen by the Free Software Foundation. The Free Software Foundation was founded by Richard Stallman. Stallman believes that the people should use the term "GNU/Linux" to refer to such an operating system, because so many of the required programs were in fact, written as part of the GNU Project.

     9 

     9 

    10 The name "Linux"  comes from the Linux kernel, originally written in 1991 by Linus Torvalds. The rest of the system usually comprises components such as the Apache HTTP Server, the X Window System, the GNOME and KDE desktop environments, and utilities and libraries from the GNU Project (announced in 1983 by Richard Stallman). Commonly-used applications with desktop Linux systems include the Mozilla Firefox web-browser and the OpenOffice.org office application suite. The GNU contribution is the basis for the Free Software Foundation's preferred name GNU/Linux. The kernel's mascot is a penguin named "Tux". Mozilla Firefox and OpenOffice.org are open-source projects which can be run on most Operating Systems, including proprietary ones.

    11 

    12 Historical Background

    13 ----------------------

    14 

    15 Events leading to the creation

    16 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    17 - The Unix operating system was developed in the 1960s and released for public use in 1970. Its accessibility and portability caused it to be widely adopted, copied and modified by academic institutions and businesses. Its design became influential to authors of other systems. Other free operating systems include the Berkeley Software Distribution (BSD), developed at the University of California at Berkeley, and MINIX which was released by Andrew S. Tanenbaum. The development and adoption of BSD and MINIX were limited due to various reasons, and this lack of a widely-adopted and free kernel triggered Linus Torvalds into starting his project.

    18 

    19 - In 1983, Richard Stallman started the GNU project with the goal of creating a free UNIX-like operating system. As part of this work, he wrote the GNU General Public License (GPL). By the early 1990s there was almost enough available software to create a full operating system. However, the GNU kernel, called Hurd, failed to attract enough attention from developers leaving GNU incomplete.

    20 

    21 The Creation of Linux

    22 ~~~~~~~~~~~~~~~~~~~~~~

    23 In 1991, Linus Torvalds began a project at the University of Helsinki that later became the Linux kernel. It was initially a terminal (command-line) emulator, which Torvalds used to access the large UNIX servers of the university. He wrote the program targeting just the hardware he was using and independent of an operating system because he wanted to use the functions of his computer with an 80386 processor. Development was done on Minix using the GNU C compiler. This application is still the main choice for compiling Linux today (although the code can be built with other compilers, such as the Intel C Compiler).

    24 

    25 Torvalds continues to direct the development of the kernel. Stallman heads the Free Software Foundation, which in turn supports the GNU components. Finally, individuals and corporations develop third-party non-GNU components, which constitute a vast body of work and including kernel modules, and user applications and libraries. Linux vendors and communities combine and distribute the kernel, GNU components, and non-GNU components, with additional package management software in the form of Linux distributions.

    33 User Interface

    17 

    34 ~~~~~~~~~~~~~~

    18 

    35 Users can control a Linux-based system through a command line interface (or CLI), a graphical user interface (or GUI), or through controls attached to the associated hardware (this is common for embedded systems). For desktop systems, the default mode is usually the GUI. On desktop machines, "KDE", "GNOME" and "Xfce" are the most popular user interfaces,though a variety of additional user interfaces exist. Most popular user interfaces run on top of the "X Window System" (or X), which enables a graphical application running on one machine to be displayed and controlled from another in a network.

    19 

    36 

    37 A Linux system also provides a CLI of some sort through a shell, which is the traditional way of interacting with a Unix system. A Linux distribution specialized for servers may use the CLI as its only interface. A “headless system” (system run without even a monitor) can be controlled by the command line via a remote-control protocol such as SSH or telnet. The CLI is particularly suited for automation of repetitive or delayed tasks, and provides very simple inter-process communication. A graphical terminal emulator program is often used to access the CLI from a Linux desktop.

    38 

    39 Development

    40 ~~~~~~~~~~~

    41 The primary difference between Linux and many other popular contemporary operating systems is that the Linux kernel and other components are free and open source software. Linux is not the only such operating system, although it is by far the most widely used. Some free and open source software licenses are based on the principle of "copyleft", a kind of reciprocity: any work derived from a copyleft piece of software must also be copyleft itself. The most common free software license, the GNU GPL, is a form of copyleft, and is used for the Linux kernel and many of the components from the GNU project.

    42 

    43 Linux based distributions are intended by developers for interoperability with other operating systems and established computing standards. Linux systems adhere to POSIX, SUS, ISO and ANSI standards where possible, although to date only one Linux distribution has been POSIX.1 certified, Linux-FT.Free software projects, although developed in a collaborative fashion, are often produced independently of each other. The fact that the software licenses explicitly permit redistribution, however, provides a basis for larger scale projects that collect the software produced by stand-alone projects and make it available all at once in the form of a Linux distribution.

    44 

    45 A Linux distribution, commonly called a "distro", is a project that manages a remote collection of system software and application software packages available for download and installation through a network connection. This allows the user to adapt the operating system to his/her specific needs. Distributions are maintained by individuals, loose-knit teams, volunteer organizations, and commercial entities. A distribution can be installed using a CD that contains distribution-specific software for initial system installation and configuration. A package manager such as Synaptic or YAST allows later package upgrades and installations. A distribution is responsible for the default configuration of the installed Linux kernel, general system security, and more generally integration of the different software packages into a coherent whole.

    46 

    47 Community

    48 ~~~~~~~~~

    49 A distribution is largely driven by its developer and user communities. Some vendors develop and fund their distributions on a volunteer basis. Examples include Debian and the Debian-based, Ubuntu. Others maintain a community version of their commercial distributions, as Red Hat does with Fedora.

    50 

    51 In many cities and regions, local associations known as Linux Users Groups (LUGs) seek to promote their preferred distribution and by extension free software. They hold meetings and provide free demonstrations, training, technical support, and operating system installation to new users. Many Internet communities also provide support to Linux users and developers. Most distributions and free software / open source projects have IRC (Internet Relay Chat) chatrooms or newsgroups. Online forums are another means for support. Linux distributions host mailing lists; commonly there will be a specific topic such as usage or development for a given list. All these can be found simply by running an appropriate search on Google.

    52 

    53 Although Linux distributions are generally available without charge, several large corporations sell, support, and contribute to the development of the components of the system and of free software. These include Dell, IBM, HP, Oracle, Sun Microsystems, Novell, Nokia. A number of corporations, notably Red Hat, have built their entire business around Linux distributions.

    54 

    55 Can I make a profit out of running a business involving Linux?

    56 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    57 

    58 The answer is, "Yes!". The free software licenses, on which the various software packages of a distribution built on the Linux kernel are based, explicitly accommodate and encourage commercialization; the relationship between a Linux distribution as a whole and individual vendors may be seen as symbiotic. One common business model of commercial suppliers is charging for support, especially for business users. A number of companies also offer a specialized business version of their distribution, which adds proprietary support packages and tools to administer higher numbers of installations or to simplify administrative tasks. Another business model is to give away the software in order to sell hardware. Examples of corporations that are extensively (and sometimes exclusively) open-source and Linux-powered , with successful revenue generation models involving these, are Google, SUN, Mozilla, etc.

    59 

    60 Programming on Linux

    61 ~~~~~~~~~~~~~~~~~~~~

    62 Most Linux distributions support dozens of programming languages. The most common collection of utilities for building both Linux applications and operating system programs is found within the GNU toolchain, which includes the GNU Compiler Collection (GCC) and the GNU build system. Amongst others, GCC provides compilers for Ada, C, C++, Java, and Fortran. The Linux kernel itself is written to be compiled with GCC. Proprietary compilers for Linux include the Intel C++ Compiler, Sun Studio, and IBM XL C/C++ Compiler.

    63 

    64 Most distributions also include support for PHP, Perl, Ruby, Python and other dynamic languages. Examples of languages that are less common, but still supported, are C# via the Mono project, sponsored by Novell, and Scheme. A number of Java Virtual Machines and development kits run on Linux, including the original Sun Microsystems JVM (HotSpot), and IBM's J2SE RE, as well as many open-source projects like Kaffe.

    65 

    66 The two main frameworks for developing graphical applications are those of GNOME and KDE. These projects are based on the GTK+ and Qt widget toolkits, respectively, which can also be used independently of the larger framework. Both support a wide variety of languages. There are a number of Integrated Development Environments (IDEs) available including Anjuta, Code::Blocks, Eclipse, KDevelop, Lazarus, MonoDevelop, NetBeans, and Omnis Studio while the long-established editors Vim and Emacs remain popular.

    74 The license commonly used is the GNU Public License (GPL). The license says that anybody who may want to do so, has the right to change Linux and eventually to redistribute a changed version, on the one condition that the code is still available after redistribution. In practice, you are free to grab a kernel image and sell the new code, as long as your customers can still have a copy of that code.

    27 

    90 From a Palmtop with 2 MB of memory to a petabyte storage cluster with hundreds of nodes: add or remove the appropriate packages and Linux fits all. One does not need a supercomputer anymore,because you can use Linux to do big things using the building blocks provided with the system. If one wants to do little things, such as making an operating system for an embedded processor or just recycling your old 486, Linux will do that as well.

    43 From a Palmtop with 2 MB of memory to a petabyte storage cluster with hundreds of nodes: add or remove the appropriate packages and Linux fits all. 

    91 

    44 

    92 - The Linux OS and Linux applications have very short debug−times:

    45 

    93 

    94 Because Linux has been developed and tested by thousands of people, both errors and people to fix them are found very quickly. It often happens that there are only a couple of hours between discovery and fixing of a bug.

   101 In order to work on a Linux system directly, one needs to provide a user name and password. You always need to authenticate to the system. Most PC−based Linux systems have two basic modes for a system to run in: either quick and clean in text console mode,which includes with mouse, multitasking and multi−user features, or in graphical console mode, which looks better but eats more system resources.

    52 In order to work on a Linux system directly, one needs to provide a user name and password. You always need to authenticate to the system. Most PC−based Linux systems have two basic modes for a system to run in: either quick and clean in text console mode,which includes with mouse, multitasking and multi−user features, or in graphical console mode.

   102 

    53 

   103 Graphical Mode

    54 

   104 ~~~~~~~~~~~~~~

   105 This is the default nowadays on most desktop computers. You know you will be connecting to the system using graphical mode when you are first asked for your user name, and then to type your password.

   106 

   107 To log in, make sure the mouse pointer is in the login window, provide your user name and password to the system and click *OK* or press *Enter*.

   108 It is generally considered a bad idea to connect (graphically) using the root user name, the system adminstrator's account, since the use of graphics includes running a lot of extra programs, in root's case with a lot of extra permissions. To keep all risks as low as possible, use a normal user account to connect graphically. But there are enough risks to keep this in mind as a general advice, for all use of the root account: only log in as root when extra privileges are required.

   109 

   110 After entering your user name/password combination, it can take a little while before the graphical environment is started, depending on the CPU speed of your computer, on the software you use and on your personal settings.

   111 

   112 To continue, you will need to open a *terminal window* or *xterm* for short (X being the name for the underlying software supporting the graphical environment). This program can be found in the *Applications−>Utilities->System Tools* or *Internet menu*, depending on what window manager you are using. There might be icons that you can use as a shortcut to get an *xterm* window as well, and clicking the right mouse button on the desktop background will usually present you with a menu containing a terminal window application.

   113 

   114 While browsing the menus, you will notice that a lot of things can be done without entering commands via the keyboard. For most users, the good old point−n−click method of dealing with the computer will do. But for those who want to enter the "heart" of the system, a tool stronger than a mouse will be required to handle the various tasks. This tool is the shell, and when in graphical mode, we activate our shell by opening a terminal window.

   115 

   116 A terminal window should always show a command prompt when you open one. This terminal shows a standard prompt, which displays the user's login name, and the current working directory, represented by the twiddle (~)

   117 

   118 Another common form for a prompt is this one:

   119 [user@host dir]

   120 

   121 In the above example, *user* will be your login name, *hosts* the name of the machine you are working on, and *dir* an indication of your current location in the file system. Prompts can display all kinds of information, but they are not part of the commands you are giving to your system. To disconnect from the system in graphical mode, you need to close all terminal windows and other applications. After that, hit the *logout* icon or find *Log Out* in the menu. Closing everything is not really necessary, and the system can do this for you, but session management might put all currently open applications back on your screen when you connect again, which takes longer and is not always the desired effect. However, this behavior is configurable.

   144 When invoked without any arguments, *ls* lists the files in the current working directory. A directory that is not the current working directory can be specified and ls will list the files there. The user also may specify any list of files and directories. In this case, all files and all contents of specified directories will be listed. The name *ls* is derived from *list segments* which was used in earlier systems.

    65 *ls* lists the files in the current working directory. A directory that is not the current working directory can be specified and ls will list the files there.::

   145 

    66 

   146 Files whose names start with "." are not listed, unless the *-a* flag is specified or the files are specified explicitly.

   147 

   148 Without options, *ls* displays files in a bare format. This bare format however makes it difficult to establish the type, permissions, and size of the files. The most common options to reveal this information or change the list of files are:

   149 

   150     * *-l* long format, displaying Unix file types, permissions, number of hard links, owner, group, size, date, and filename

   151     * *-F* appends a character revealing the nature of a file, for example, * for an executable, or / for a directory. Regular files have no suffix.

   152     * *-a* lists all files in the given directory, including those whose names start with "." (which are hidden files in Unix). By default, these files are excluded from the list.

   153     * *-R* recursively lists subdirectories. The command ls -R / would therefore list all files.

   154     * *-d* shows information about a symbolic link or directory, rather than about the link's target or listing the contents of a directory.

   155     * *-t* sort the list of files by modification time.

   156     * *-h* print sizes in human readable format. (e.g., 1K, 234M, 2G, etc.)

   157 

   158 In some environments, providing the option *--color* (for GNU ls) or *-G* (FreeBSD ls) causes ls to highlight different types of files with different colors, instead of with characters as *-F* would. To determine what color to use for a file, GNU *ls* checks the Unix file type, the file permissions, and the file extension, while FreeBSD *ls* checks only the Unix file type and file permissions.::

   192 This stands for "change directory". When one wants to go up to the parent directory, bypassing the tree of directories one has entered, “ cd ..” can be used.

    74 This stands for "change directory". When one wants to change the directory .

    75 

    76        $cd Music 

   236 In order to find out the various options that can be appended to the *who* command, check the *man* page by typing out the following in the terminal::

   120 

   237 

   238 	$man who

   239 

   240 This will take you to the "Manual" page containing details about the *who* command

   251 Options

   131 

   252 ~~~~~~~

   132 

   253 

   133 

   254 On Unix-like operating systems, *mkdir* takes options. Three of the most common options are:

   134 pwd

   255 

   135 ----

   256     * *-p*: will also create all directories leading up to the given directory that do not exist already. If the given directory already exists, ignore the error.

   136 pwd is a Linux / Unix command which prints the current working directory. If you wish to know the full path of the  directory in which you are in from the Linux console, then the pwd command will come to your rescue. pwd stands for Print Working Directory.

   257     * *-v*: display each directory that mkdir creates. Most often used with -p.

   137 

   258     * *-m*: specify the octal permissions of directories created by mkdir.

   138 pwd have one option called -P, which lists the current working directory with all the links resolved.

   259 

   139 

   260 *-p* is most often used when using mkdir to build up complex directory hierarchies, in case a necessary directory is missing or already there. -m is commonly used to lock down temporary directories used by shell scripts.

   140 Usage of pwd command

   261 

   141 

   262 Examples

   142 I have a directory called "Examples/" on my machine which is actually a soft link to the directory /usr/share/example-content/. 

   263 ~~~~~~~~

   143 

   264 

   144 I move into the "Examples" directory and run the pwd command to get the following output.

   265 An example of *-p* in action is::

   145 

   266 

   146 $ cd Examples

   267 	$mkdir -p /tmp/a/b/c

   147 $ pwd

   268 

   148 /home/laf/Examples

   269 If */tmp/a* exists but */tmp/a/b* does not, mkdir will create */tmp/a/b* before creating */tmp/a/b/c*.

   149 

   270 

   150 

   271 And an even more powerful command, creating a full tree at once (this however is a Shell extension, nothing mkdir does itself)::

   151 FLAGS

   272 

   152 ~~~~~

   273 	$mkdir -p tmpdir/{trunk/sources/{includes,docs},branches,tags}

   153 The standard commands in Linux have a lot of options also called flags to change or provide some additional functionality to the command For example ::

   274 

   154       

   275 This will create:

   155        $ls -l 

   276 

   156        

   277 tmpdir 	- branches

   157        * *ls with flag -l* displays the result in long format, displaying Unix file types, permissions, number of hard links, owner, group, size, date, and filename

   278 	- tag

   158 

   279 	- trunk	- sources - includes

   159 

   280 			  - docs

   336 Pages are traditionally referred to using the notation "name(section)"; for example, ftp(1). The same page name may appear in more than one section of the manual, this can occur when the names of system calls, user commands, or macro packages coincide. Two examples are *man(1)* and *man(7)*, or *exit(2)* and *exit(3)*. The syntax for accessing the non-default manual section varies between different man implementations. On Linux and *BSD, for example, the syntax for reading *printf(3)* is::

   215 To see the manual on man itself do::

   337 

   338 	$man 3 printf

   339 

   340 Another example::

   437 	$ cp [ -f ] [ -H ] [ -i ] [ -p ][ -- ] SourceFile TargetFile

   286 	$ cp  SourceFile TargetFile

   441 	$ cp [ -f ] [ -H ] [ -i ] [ -p ] [ -r | -R ] [ -- ] SourceFile ... 		TargetDirectory

   290 	$ cp  SourceFile  TargetDirectory

   442 

   291  

   445 	$ cp [ -f ] [ -H ] [ -i ] [ -p ] [ -- ] { -r | -R } 

   294 	$ cp  -r SourceDirectory  TargetDirectory

   446 	SourceDirectory ... TargetDirectory

   578 To delete a directory (with rm -r), one must delete all of its contents recursively. This requires that one must have read and write and execute permission to that directory (if it's not empty) and all non-empty subdirectories recursively (if there are any). The read permissions are needed to list the contents of the directory in order to delete them. This sometimes leads to an odd situation where a non-empty directory cannot be deleted because one doesn't have write permission to it and so cannot delete its contents; but if the same directory were empty, one would be able to delete it.

   425 To delete a directory (with rm -r), one must delete all of its contents recursively. This requires that one must have read and write and execute permission to that directory (if it's not empty) and all non-empty subdirectories recursively (if there are any).

   579 

   426 

   580 If a file resides in a directory with the sticky bit set, then deleting the file requires one to be the owner of the file.

   427 

   581 

   428 

   582 

   429 

   583 Command Line Arguments

   584 =======================

   585 

   586 In computer command line interfaces, a command line argument is an argument sent to a program being called. In general, a program can take any number of command line arguments, which may be necessary for the program to run, or may even be ignored, depending on the function of that program.

   587 

   588 For example, in Unix and Unix-like environments, an example of a command-line argument is::

   589 

   590 	rm file.s

   591 

   592 "file.s" is a command line argument which tells the program rm to remove the file "file.s".

   593 

   594 Programming languages such as C, C++ and Java allow a program to interpret the command line arguments by handling them as string parameters in the main function.

   595 

   596 A command line option or simply *option* (also known as a command line parameter, flag, or a switch) is an indication by a user that a computer program should change its default output.

   597 

   598 Long options are introduced via "--", and are typically whole words. For example, *ls --long --classify --all*. Arguments to long options are provided with "=", as *ls --block-size=1024*. Some Unix programs use long options with single dashes, for example MPlayer as in *mplayer -nosound*.

   599 

   600 Linux also uses "--" to terminate option lists. For example, an attempt to delete a file called *-file1* by using *rm -file1* may produce an error, since rm may interpret *-file1* as a command line switch. Using *rm -- -file1* removes ambiguity.

   620 Some versions omit the n and just let you say -5.

   449 

   658 Using an older syntax (still used in Sun Solaris as the -n option is not supported), the last 20 lines and the last 50 bytes of filename can be shown with the following command::

   479 

   659 

   660 	$ tail -20 filename

   661 	$ tail -50c filename

   662 

   663 However this syntax is now obsolete and does not conform with the POSIX 1003.1-2001 standard. Even if still supported in current versions, when used with other options (like -f, see below), these switches could not work at all.

   731 This creates the file named *www* containing::

   547 This creates the file named *www* containing ::

   763 Filenames containing metacharacters can pose many problems and should never be intentionally created. If you do find that you've created a file with metacharacters, and you would like to remove it, you have three options. You may use wildcards to match metacharacter, use the \  to directly enter the filename, or put the command in double quotes (except in the case of double quotes within the file name, these must be captured with one of the first two methods). For example, deleting a file named `"``*`|more`"` can be accomplished with::

   578 Filenames containing metacharacters can pose many problems and should never be intentionally created.

   764 

   765 	$ rm ??more

   766 

   767 or::

   768 

   769 	$ rm $\backslash$*$\backslash$|more

   770 

   771 or::

   772 

   773 	$ rm ''*|more'' 

   788 Jargon File Definition

   593 Usage ::

   789 ~~~~~~~~~~~~~~~~~~~~~~

   594         $ cat foo boo

   790 

   595 	This is file foo

   791 The Jargon File version 4.4.7 lists this as the definition of *cat*::

   596 	

   792 

   597 	This is file boo.

   793    1. To spew an entire file to the screen or some other output sink without

   598 

   794  	pause (syn. blast).

   599 

   795 

   796    2. By extension, to dump large amounts of data at an unprepared target or

   797  	with no intention of browsing it carefully. Usage: considered silly.

   798  	Rare outside Unix sites. See also dd, BLT.

   799 

   800 	Among Unix fans, *cat(1)* is considered an excellent example of

   801  	user-interface design, because it delivers the file contents without 

   802 	such verbosity as spacing or headers between the files, and because 

   803 	it does not require the files to consist of lines of text, but works 

   804 	with any sort of data.

   805 

   806 	Among Unix critics, *cat(1)* is considered the canonical example of 

   807 	bad user-interface design, because of its woefully unobvious name. 

   808 	It is far more often used to blast a single file to standard output 

   809 	than to concatenate two or more files. The name cat for the former 

   810 	operation is just as unintuitive as, say, LISP's cdr.

   811 

   812 	Of such oppositions are holy wars made...

   813 

   814 Useless Use of 'cat'

   815 ~~~~~~~~~~~~~~~~~~~~

   816 

   817 UUOC (from comp.unix.shell on Usenet) stands for “Useless Use of cat”. As it is observed on *comp.unix.shell*, “The purpose of cat is to concatenate (or 'catenate') files. If it's only one file, concatenating it with nothing at all is a waste of time, and costs you a process.”

   818 

   819 Nevertheless one sees people doing::

   820 

   821 	$ cat file | some_command and its args ...

   822 

   823 instead of the equivalent and cheaper::

   824 

   825 	<file some_command and its args ...

   826 

   827 or (equivalently and more classically)::

   828 

   829 	some_command and its args ... <file

   830 

   831 Since 1995, occasional awards for UUOC have been given out. The activity of fixing instances of UUOC is sometimes called 'demoggification'.

   832 

   833 Amongst many, it is still considered safer to use *cat* for such cases given that the < and > keys are next to each other in many popular keyboard mappings. While the risk might be low, the impact of using > instead of < can be high and prohibitive.

   834 

   835 zcat

   836 ~~~~~

   837 

   838 *zcat* is a Unix program similar to *cat*, that decompresses individual files and concatenates them to standard output. Traditionally *zcat* operated on files compressed by compress but today it is usually able to operate on *gzip* or even *bzip2* archives. On such systems, it is equivalent to *gunzip -c*

   858 *Options* are typically entered before the file name, but can also be entered in the environment variable *$MORE*. Options entered in the actual command line will override those entered in the *$MORE* environment variable. Available options may vary between Unix systems.

   619 

   872 The command-syntax is::

   633 The command-syntax is ::

   932 The majority of these directories exist in all UNIX operating systems and are generally used in much the same way; however, the descriptions here are those used specifically for the FHS, and are not considered authoritative for platforms other than Linux.

   697 The majority of these directories exist in all UNIX operating systems and are generally used in much the same way; however, the descriptions here are those used specifically for the FHS, and are not considered authoritative for platforms other thanmajor Linux distros.

  1016 The *chmod* command (abbreviated from 'change mode') is a shell command and C language function in Unix and Unix-like environments. When executed, it can change file system modes of files and directories. The modes include permissions and special modes.A chmod command first appeared in AT&T Unix version 1, and is still used today on Unix-like machines.

   811 The *chmod* command (abbreviated from 'change mode') is a shell command and C language function in Unix and Unix-like environments. When executed, it can change file system modes of files and directories. The modes include permissions and special modes.

  1168 Special modes

   975 

  1169 +++++++++++++

   976 chown

  1170 

   977 ~~~~~

  1171 The *chmod* command is also capable of changing the additional permissions or special modes of a file or directory. The symbolic modes use **s** to represent the *setuid* and *setgid* modes, and **t** to represent the sticky mode. The modes are only applied to the appropriate classes, regardless of whether or not other classes are specified.

   978 The chown command is used to change the owner and group of files, directories and links.

  1172 

   979 

  1173 Most operating systems support the specification of special modes using octal modes, but some do not. On these systems, only the symbolic modes can be used.

   980 By default, the owner of a filesystem object is the user that created it. The group is a set of users that share the same access permissions (i.e., read, write and execute) for that object.

   981 

   982 The basic syntax for using chown to change owners is

   983 

   984     chown -v alice wonderland.txt

   985 

   986 

   987 

   988 

  1180 Programs do redirection with the *dup2(2)* system call, or its less-flexible but higher-level stdio analogues, *freopen(3)* and *popen(3)*.

   995 

  1203 A pipeline of three programs run on a text terminal::

  1018 A pipeline of two programs run on a text terminal::

  1243 In shells derived from *csh* (the C shell), the syntax instead appends the & character to the redirect characters, thus achieving a similar result.

  1058 

  1384 Traditional Unix regular expression syntax followed common conventions but often differed from tool to tool. The IEEE POSIX *Basic Regular Expressions* (BRE) standard (released alongside an alternative flavor called Extended Regular Expressions or ERE) was designed mostly for backward compatibility with the traditional (Simple Regular Expression) syntax but provided a common standard which has since been adopted as the default syntax of many Unix regular expression tools, though there is often some variation or additional features. Many such tools also provide support for ERE syntax with command line arguments.

  1158 

  1385 

  1159 Regular Expressions are a feature of UNIX. They describe a pattern to match, a sequence of characters, not words, within a line of text. Here is a quick summary of the special characters used in the grep tool and their meaning: 

  1386 In the BRE syntax, most characters are treated as literals — they match only themselves (i.e., a matches "a"). The exceptions, listed below, are called metacharacters or metasequences.

  1160 

  1387 

  1161 * ^ (Caret)        =    match expression at the start of a line, as in ^A.

  1388 +-------------+------------------------------------------------------------+

  1162 * $ (Question)     =    match expression at the end of a line, as in A$.

  1389 |Metacharacter|                            Description                     |

  1163 * \ (Back Slash)   =    turn off the special meaning of the next character, as in \^.

  1390 +=============+============================================================+

  1164 * [ ] (Brackets)   =    match any one of the enclosed characters, as in [aeiou].

  1391 | .           | Matches any single character (many applications exclude    | 

  1165                       Use Hyphen "-" for a range, as in [0-9].

  1392 |             | newlines, and exactly which characters are considered      | 

  1166 * [^ ]             =    match any one character except those enclosed in [ ], as in [^0-9].

  1393 |             | newlines is flavor, character encoding, and platform       |

  1167 * . (Period)       =    match a single character of any value, except end of line.

  1394 |             | specific, but it is safe to assume that the line feed      |

  1168 * * (Asterisk)     =    match zero or more of the preceding character or expression.

  1395 |             | character is included). Within POSIX bracket expressions,  |

  1169 * \{x,y\}          =    match x to y occurrences of the preceding.

  1396 |             | the dot character matches a literal dot. For example, a.c  |

  1170 * \{x\}            =    match exactly x occurrences of the preceding.

  1397 |             | matches abc, etc., but [a.c] matches only a, ., or         |

  1171 * \{x,\}           =    match x or more occurrences of the preceding.

  1398 |             | c.                                                         |

  1172 

  1399 +-------------+------------------------------------------------------------+

  1173 

  1400 | [ ]         | A bracket expression. Matches a single character that is   | 

  1174 

  1401 |             | contained within the brackets. For example, [abc] matches  |

  1175 Here are some examples using grep:

  1402 |             | a, b, or c. [a-z] specifies a range which matches any      |

  1176 

  1403 |             | lowercase letter from a to z. These forms can be mixed:    |

  1177 *    grep smug files         {search files for lines with 'smug'}

  1404 |             | [abcx-z] matches a, b, c, x, y, or z, as does              |

  1178 *    grep '^smug' files      {'smug' at the start of a line}

  1405 |             | [a-cx-z]. The - character is treated as a literal character|

  1179 *    grep 'smug$' files      {'smug' at the end of a line}

  1406 |             | if it is the last or the first character within the        |

  1180 *    grep '^smug$' files     {lines containing only 'smug'}

  1407 |             | brackets, or if it is escaped with a backslash: [abc-],    |

  1181 *    grep '\^s' files        {lines starting with '^s', "\" escapes the ^}

  1408 |             | [-abc], or [a\-bc].                                        |

  1182 *    grep '[Ss]mug' files    {search for 'Smug' or 'smug'}

  1409 +-------------+------------------------------------------------------------+

  1183 *    grep 'B[oO][bB]' files  {search for BOB, Bob, BOb or BoB }

  1410 | [^ ]        | Matches a single character that is not contained within the|

  1184 *    grep '^$' files         {search for blank lines}

  1411 |             | brackets. For example, [^abc] matches any character other  |

  1185 *   grep '[0-9][0-9]' file  {search for pairs of numeric digits}

  1412 |             | than a, b, or c. [^a-z] matches any single character       |

  1186 

  1413 |             | that is not a lowercase letter from a to z. As above,      |

  1187 

  1414 |             | literal characters and ranges can be mixed.                |

  1188 

  1415 +-------------+------------------------------------------------------------+

  1416 | ^           | Matches the starting position within the string. In        |

  1417 |             | line-based tools, it matches the starting position of any  |

  1418 |             | line.                                                      |

  1419 +-------------+------------------------------------------------------------+

  1420 | $           | Matches the ending position of the string or the position  |

  1421 |             | just before a string-ending newline. In line-based tools,  |

  1422 |             | it matches the ending position of any line.                |

  1423 +-------------+------------------------------------------------------------+

  1424 | `*`         | Matches the preceding element zero or more times. For      |

  1425 |             | example, ab*c matches "ac", "abc", "abbbc", etc. [xyz]*    |

  1426 |             | matches "", "x", "y", "z", "zx", "zyx", "xyzzy", and so on.|

  1427 |             | \(ab\)* matches "", "ab", "abab", "ababab", and so on.     |

  1428 +-------------+------------------------------------------------------------+

  1429 | ?           | Matches the preceding element zero or one time. For        |

  1430 |             | example, ba? matches "b" or "ba".                          |

  1431 +-------------+------------------------------------------------------------+

  1432 | `+`         | Matches the preceding element one or more times. For       |

  1433 |             | example, ba+ matches "ba", "baa", "baaa", and so on.       |

  1434 +-------------+------------------------------------------------------------+

  1435 | `|`         | The choice (aka alternation or set union) operator matches |

  1436 |             | either the expression before or the expression after the   |

  1437 |             | operator. For example, abc|def matches "abc" or "def".     |

  1438 +-------------+------------------------------------------------------------+

  1468 The word *One-liner* has two references in the index of the book *The AWK Programming Language* (the book is often referred to by the abbreviation TAPL). It explains the programming language AWK, which is part of the Unix operating system. The authors explain the birth of the One-liner paradigm with their daily work on early Unix machines:

  1218 

  1469 ::

  1470 

  1471     “The 1977 version had only a few built-in variables and predefined functions. It was designed for writing short programs [...] Our model was that an invocation would be one or two lines long, typed in and used immediately. Defaults were chosen to match this style [...] We, being the authors, knew how the language was supposed to be used, and so we only wrote one-liners.”

  1472 

  1473 Notice that this original definition of a One-liner implies immediate execution of the program without any compilation. So, in a strict sense, only source code for interpreted languages qualifies as a One-liner. But this strict understanding of a One-liner was broadened in 1985 when the IOCCC introduced the category of Best One Liner for C, which is a compiled language.

  1474 

  1475 The TAPL book contains 20 examples of One-liners (A Handful of Useful awk One-Liners) at the end of the book's first chapter.

  1476 

  1477 Here are the first few of them:

  1478 

  1479    1. Print the total number of input lines:

  1480 

  1481       END { print NR }

  1482 

  1483    2. Print the tenth input line:

  1484 

  1485       NR == 10

  1486 

  1487    3. Print the last field of every input line:

  1488 

  1489       { print $NF }

  1490 

  1491 One-liners are also used to show off the differential expressive power of programming languages. Frequently, one-liners are used to demonstrate programming ability. Contests are often held to see who can create the most exceptional one-liner.

  1492 

  1493 The following example is a C program (a winning entry in the "Best one-liner" category of the IOCCC, here split to two lines for presentation).::

  1494 	

  1495 	main(int c,char**v){return!m(v[1],v[2]);}m(char*s,char*t){return

  1496 	*t-42?*s?63==*t|*s==*t&&m(s+1,t+1):!*t:m(s,t+1)||*s&&m(s+1,t);}

  1497 

  1498 This one-liner program is a *glob pattern matcher*. It understands the glob characters '*' meaning 'zero or more characters' and '?' meaning exactly one character, just like most Unix shells.

  1499 

  1500 Run it with two args, the string and the glob pattern. The exit status is 0 (shell true) when the pattern matches, 1 otherwise. The glob pattern must match the whole string, so you may want to use * at the beginning and end of the pattern if you are looking for something in the middle. Examples::

  1501 

  1502 	$ prog foo 'f??'; echo $?

  1503 

  1504 	$ prog 'best short program' '??st*o**p?*'; echo $?

  1510 	$ ls -R | grep ":$" | sed -e 's/:$//' -e 's/[^-][^\/]*\//--/g' -e 's/^/   /' -e 's/-/|/' 

  1224       $grep user * | cut -d":"  -f1|uniq

  1511 

  1225 

  1512 

  1226 This returns list of all files which has the word user in it .

  1513 

  1227 

  1228 

  1229