Thread and IPC

Thread and IPC

Beberapa minggu lalu, kita sudah ber-eksperimen dengan menggunakan proses dan daemon pada sistem operasi Linux, sekarang kita mencoba menyelesaikan suatu permasalahan yang menggunakan Interprocess Communication (IPC), dimana permasalahan kali ini mengenai tentang permainan Benteng Takeshi yang aturannya sebagai berikut:  
1. Masing-masing pemain (Raja Takeshi dan si Penantang) memiliki 16 buah lubang yang nantinya bisa diisi ranjau. 
2. Kedua pemain tersebut masing-masing memiliki 16 buah ranjau yang bisa dipakai dan poin awalnya yakni 0. 
3. Selama pertandingan, kedua pemain akan saling bergantian mengisi lubang-lubang tersebut dengan ranjau sedangkan salah satunya memberikan tebakan lubang mana yang aman dari ranjau. 
4. Setiap gilirannya, pemain bisa memasang 0 sampai 4 ranjau di lubang yang berbeda dan lawannya menebang 4 lubang. 
5. Pemain yang mendapatkan poin hanya pemain yang memasang ranjau saja, dimana pemain yang memasang ranjau mendapat poin dari jumlah ranjau yang memakan korban.      

Sebelum menyelesaikan permasalahannya, alangkah baiknya anda mengetahui pengetahuan dan penggunaan dari Interprocess Communication (IPC).  Interprocess Communication (IPC) merupakan salah satu cara pertukaran data antar satu proses dgn proses yg lainnya, baik proses yg berada di dalam komputer yang sama, ataupun komputer jarak jauh yang terhubung melalui jaringan.
Berikut jenis-jenis dari Interprocess Communication (IPC) : 
1. Pipes
Pipe merupakan komunikasi sequensial antar proses yang saling terelasi, namun pipe memiliki kelemahan yaitu hanya bisa digunakan untuk komunikasi antar proses yang saling berhubungan, dan komunikasinya yang dilakukan adalah secara sequensial. 
2. Shared Memory 
Sistem Berbagi Memori merupakan salah satu cara komunikasi antar proses dengan cara mengalokasikan suatu alamat memori untuk dipakai berkomunikasi antarproses. Alamat dan besar alokasi memori yang digunakan biasanya ditentukan oleh pembuat program. Pada metode ini, sistem akan mengatur proses mana yang akan memakai memori pada waktu tertentu sehingga pekerjaan dapat dilakukan secara efektif. 
3. Message Queue 
Sistem berkirim pesan adalah proses komunikasi antar bagian sistem untuk membagi variabel yang dibutuhkan. Proses ini menyediakan dua operasi yaitu mengirim pesan dan menerima pesan. 
4. Socket   
Bentuk dari komunikasi yaitu UDP dan TCP menggunakan abstraksi socket yang menyediakan endpoint untuk komunikasi antar proses. Socket bisa dijalankan diberbagai platform(BSD UNIIX, UNIX, Linux, Windows, & Machintos OS).

Setelah mengetahui jenis-jenis dari IPC, maka skrg saatnya mengetahui beberapa penggunaan IPC, berikut beberapa contoh penggunaan dari IPC: 
1. Deklarasi Variabel  

2. Membuat file pipe 

3. Membuka file pipe 

4. Menuliskan isi file pipe

5. Menutup file pipe

6. Menghapus file pipe 

Nah, setelah mengetahui beberapa cara penggunaan dari IPC, langsung aja kita menyelesaikan permasalahan tentang permainan Benteng Takeshi. Untuk permasalahan ini, anda harus membuat 2 kodingan, berikut kodingannya :

Nah, setelah itu apa hasil jika anda compile kedua kodingan diatas?
Sebelumnya cara compile yakni sebagai berikut:

gcc -o [output] input.c -lpthread 

Dan sekarang coba compile dan jalankan file diatas, bagaimana hasilnya?
Berikut hasilnya :

Keterangan : 
pemain1.c (terminal sebelah kiri) pertama kali akan memberikan jebakan ranjau di lubangnya sendiri, sementara pemain2.c (terminal sebelah kanan) yang akan menebak pertama kalinya, 
pemain1 memberikan ranjau di lubang 1, 2, 3, dan 4.
sementara pemain2 menebak di lubang 1, 2, 4 dan 6.
karena pemain2 menebak di lubang yang ada ranjau sebanyak 3 lubang (lubang 1, 2 dan 4) maka si pemain1 mendapatkan 3 poin.

Keterangan : 
setelah pemain1 sudah memasukkan ranjau di lubang nya, maka lubangnya akan menjadi kosong (0), setelah itu giliran pemain2 untuk memberikan jebakan ranjau di lubangnya, sementara pemain1 yang akan menebak untuk pertama kalinya. 
pemain2 memberikan ranjau di lubang 11, 12, 13, dan 14.
sementara pemain1 menebak di lubang 4, 7, 9 dan 11.
karena pemain1 menebak di lubang yang ada ranjau sebanyak 1 lubang (lubang 11) maka si pemain2 mendapatkan 1 poin saja.
dan berikut seterusnya...
Jadi selamat mencoba !

Daemon

Daemon
Proses daemon yaitu sebuah proses yang berjalan di balik layar (background) dan tidak berinteraksi langsung dengan user melalui standard input/output.

Ada 6 proses pembuatan Daemon
1. Fork Parent Process dan penghentian Parent Process
    Langkah pertama adalah melakukan forking untuk membuat process baru
    kemudian mematikan Parent Process.
    pid_t pid, sid;
    pid = fork();
    if (pid < 0){
        exit(EXIT_FAILURE);
    }
    if (pid > 0){
        exit(EXIT_SUCCESS);
    }

2. Mengubah mode file menggunakan UMASK(0);
    Untuk menulis beberapa file (termasuk logs) yang dibuat oleh daemon, mode
    file harus diubah untuk memastikan bahwa file tersebut dapat ditulis dan 
   dibaca secara benar. Pengubahan mode file menggunakan implementasi 
   umask().

3. Membuat Unique Session ID (SID)
    Child Process harus memiliki unik SID dari kernel untuk dapat beroperasi. 
    Sebaliknya, Child process menjadi Orphan Proses pada system. Tipe pid_t yang 
    dideklarasikan pada bagian sebelumnya, juga digunakan untuk membuat SID 
    baru untuk child process.

    sid = setsid();
    if (sid < 0){
        exit(EXIT_FAILURE);
    }

4. Mengubah Directory Kerja
    Directory kerja yang aktif harus diubah ke suatu tempat yang telah pasti akan
    selalu ada.

    if ((chdir("/home/yudhis/sisop/new/")) < 0){
        exit(EXIT_FAILURE);
    }

5. Menutup File Descriptor Standar
    Salah satu dari langkah terakhir dalam mengeset daemon adalah menutup file
    descriptor standar (STDIN, STDOUT, STDERR).

    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);

6. Membuat Loop utama (inti kerja dari daemon)
    Daemon bekerja dalam jangka waktu tertentu, sehingga diperlukan sebuah 
    looping.
  
   while(1){
          sleep(30);
   }
   exit(EXIT_SUCCCESS);


Berikut adalah full source code daemon :

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <syslog.h>
#include <string.h>

int main(void){
    pid_t pid, sid;
    pid = fork();
    if (pid < 0){
        exit(EXIT_FAILURE);
    }
    if (pid > 0){
        exit(EXIT_SUCCESS);
    }
    umask(0);
    sid = setsid();
    if (sid < 0){
        exit(EXIT_FAILURE);
    }
    if ((chdir("/home/ghaly/")) < 0){
        exit(EXIT_FAILURE);
    }
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
    while(1){
          sleep(30);
   }

    exit(EXIT_SUCCESS);
}

Silahkan dicoba teman-teman!!

WGET, EXEC, dan TAR

WGET

Retrieve web pages or files via HTTP, HTTPS or FTP

EXEC
Execute a command

Syntax
      exec [-cl] [-a name] [command [arguments]]

Options
      -l   Place a dash at the beginning of the zeroth arg passed to command.
           (This is what the login program does.)

      -c   Causes command to be executed with an empty environment.

      -a   The shell passes name as the zeroth argument to command.

TAR
Store, list or extract files in an archive

Syntax
      tar [[-]function] [options] filenames...

      tar [[-]function] [options] -C directory-name...

   Command-line arguments that specify files to add to, extract from,
   or list from an archive can be given as shell pattern matching strings.

Functions:
       Exactly one of the following functions (shown in bold) must be specified:
     -A
     --catenate
     --concatenate  Append the contents of named file, which must itself be a
      gnutar archive, to the end of the archive (erasing the old
      end-of-archive block).  This has the effect of adding the
      files contained in the named file to the first archive,
      rather than adding the second archive as an element of the
      first.  Note: This option requires a rewritable tarfile,
      and therefore does not work on quarter-inch cartridge
      tapes.  (see notes below)
     -c
     --create     Create a new archive (or truncate an old one) and write
                   the named files to it.
     -d
     --diff
     --compare     Find differences between files in the archive and
                   corresponding files in the file system.

     --delete     Delete named files from the archive.
                  (Does not work on quarter-inch tapes).
     -r
     --append     Append files to the end of an archive.
                  (Does not work on quarter-inch tapes).
     -t
     --list     List the contents of an archive; if filename arguments are
                   given, only those files are listed, otherwise the entire
                   table of contents is listed.

     --test-label     test the archive volume label and exit

     -u
     --update     Append the named files if the on-disk version has a 
                   modification date more recent than their copy in the 
                   archive(if any).  Does not work on quarter-inch tapes.
     -x
     --extract
     --get         Extract files from an archive.  The owner, modification
                   time, and file permissions are restored, if possible.  If
                   no file arguments are given, extract all the files in the
                   archive.  If a filename argument matches the name of a
                   directory on the tape, that directory and its contents are
                   extracted (as well as all directories under that direc-
                   tory).  If the archive contains multiple entries corre-
                   sponding to the same file (see the --append command
                   above), the last one extracted will overwrite all earlier
                   versions.

     -C, --directory=DIR     change to directory DIR

     -f, --file=ARCHIVE     use archive file or device ARCHIVE

     -j, --bzip2     filter the archive through bzip2

     -J, --xz     filter the archive through xz

     -p, --preserve-permissions     extract information about file permissions (default for superuser)

     -v, --verbose     verbosely list files processed.

     -z, --gzip     filter the archive through gzip 

You can specify an argument for `--file (or -f ) whenever you use tar; this option determines the name of the archive file that `tar' will work on.

If you don't specify this argument, then `tar' will use a default, usually some physical tape drive attached to your machine. If there is no tape drive attached, or the default is not meaningful, then `tar' will print an error message like one of the following:

     tar: can't open /dev/rmt8 : No such device or address
     tar: can't open /dev/rsmt0 : I/O error

To avoid confusion, we recommend that you always specify an archive file name by using `--file=ARCHIVE-NAME' (or `-f ARCHIVE-NAME') when writing your `tar' commands.

     --verbose' (`-v') shows details about the results of running `tar'.

This can be especially useful when the results might not be obvious. For example, if you want to see the progress of `tar' as it writes files into the archive, you can use the `--verbose' option. In the beginning, you might find it useful to use `--verbose' at all times; when you are more accustomed to `tar', you will likely want to use it at certain times but not at others.

Sometimes, a single instance of `--verbose' on the command line will show a full, `ls' style listing of an archive or files, giving sizes, owners, and similar information. Other times, `--verbose' will only show files or members that the particular operation is operating on at the time. In the latter case, you can use `--verbose' twice in a command to get a listing such as that in the former case.

Options

--absolute-names
-P
     Normally when creating an archive, `tar' strips an initial `/' from
     member names.  This option disables that behavior.

--after-date
     (See --newer.)

--atime-preserve
     Tells `tar' to preserve the access time field in a file's inode
     when dumping it.

--backup=BACKUP-TYPE
     Rather than deleting files from the file system, `tar' will back
     them up using simple or numbered backups, depending upon
     BACKUP-TYPE.

--block-number
-R
     With this option present, `tar' prints error messages for read
     errors with the block number in the archive file.

--blocking-factor=BLOCKING
-b BLOCKING
     Sets the blocking factor `tar' uses to BLOCKING x 512 bytes per
     record.

--bzip2
-I
     This option tells `tar' to read or write archives through `bzip2'.

--checkpoint
     This option directs `tar' to print periodic checkpoint messages as
     it reads through the archive.  Its intended for when you want a
     visual indication that `tar' is still running, but don't want to
     see --verbose' output.

--compress
--uncompress
-Z
     `tar' will use the `compress' program when reading or writing the
     archive.  This allows you to directly act on archives while saving
     space.

--confirmation
     (See --interactive.)

--dereference
-h
     When creating a `tar' archive, `tar' will archive the file that a
     symbolic link points to, rather than archiving the symlink.

--directory=DIR
-C DIR
     When this option is specified, `tar' will change its current
     directory to DIR before performing any operations.  When this
     option is used during archive creation, it is order sensitive.

--exclude=PATTERN
     When performing operations, `tar' will skip files that match
     PATTERN.

--exclude-from=FILE
-X FILE
     Similar to --exclude, except `tar' will use the list of patterns
     in the file FILE.

--file=ARCHIVE
-f ARCHIVE
     `tar' will use the file ARCHIVE as the `tar' archive it performs
     operations on, rather than `tar''s compilation dependent default.

--files-from=FILE
-T FILE
     `tar' will use the contents of FILE as a list of archive members
     or files to operate on, in addition to those specified on the
     command-line.

--force-local
     Forces `tar' to interpret the filename given to --file as a local
     file, even if it looks like a remote tape drive name.

--group=GROUP
     Files added to the `tar' archive will have a group id of GROUP,
     rather than the group from the source file.  GROUP is first decoded
     as a group symbolic name, but if this interpretation fails, it has
     to be a decimal numeric group ID.

     Also see the comments for the --owner=USER option.

--gzip
--gunzip
--ungzip
-z
     This option tells `tar' to read or write archives through `gzip',
     allowing `tar' to directly operate on several kinds of compressed
     archives transparently.

--help
     `tar' will print out a short message summarizing the operations and
     options to `tar' and exit.

--ignore-failed-read
     Instructs `tar' to exit successfully if it encounters an
     unreadable file. 

--ignore-umask
     (See --preserve-permissions'; *note Writing::..)

--ignore-zeros
-i
     With this option, `tar' will ignore zeroed blocks in the archive,
     which normally signals EOF.  *Note Reading::.

--incremental
-G
     Used to inform `tar' that it is working with an  old GNU-format
     incremental backup archive.  It is intended primarily for backwards
     compatibility only.

--info-script=SCRIPT-FILE
--new-volume-script=SCRIPT-FILE
-F SCRIPT-FILE
     When `tar' is performing multi-tape backups, SCRIPT-FILE is run at
     the end of each tape.

--interactive
--confirmation
-w
     Specifies that `tar' should ask the user for confirmation before
     performing potentially destructive options, such as overwriting
     files.

--keep-old-files
-k
     When extracting files from an archive, `tar' will not overwrite
     existing files if this option is present.  *Note Writing::.

--label=NAME
-V NAME
     When creating an archive, instructs `tar' to write NAME as a name
     record in the archive.  When extracting or listing archives, `tar'
     will only operate on archives that have a label matching the
     pattern specified in NAME.

--listed-incremental=SNAPSHOT-FILE
-g SNAPSHOT-FILE
     During a --create' operation, specifies that the archive that
     `tar' creates is a new GNU-format incremental backup, using
     SNAPSHOT-FILE to determine which files to backup.  With other
     operations, informs `tar' that the archive is in incremental
     format.

--mode=PERMISSIONS
     When adding files to an archive, `tar' will use PERMISSIONS for
     the archive members, rather than the permissions from the files.
     The program `chmod' and this `tar' option share the same syntax
     for what PERMISSIONS might be.  *Note Permissions: (fileutils)File
     permissions.  This reference also has useful information for those
     not being overly familiar with the Unix permission system.

     Of course, PERMISSIONS might be plainly specified as an octal
     number.  However, by using generic symbolic modifications to mode
     bits, this allows more flexibility.  For example, the value `a+rw'
     adds read and write permissions for everybody, while retaining
     executable bits on directories or on any other file already marked
     as executable.

--multi-volume
-M
     Informs `tar' that it should create or otherwise operate on a
     multi-volume `tar' archive.

--new-volume-script
     (see -info-script)

--newer=DATE
--after-date=DATE
-N
     When creating an archive, `tar' will only add files that have
     changed since DATE.

--newer-mtime
     In conjunction with --newer', `tar' will only add files whose
     contents have changed (as opposed to just --newer', which will
     also back up files for which any status information has changed).

--no-recursion
     With this option, `tar' will not recurse into directories unless a
     directory is explicitly named as an argument to `tar'.

--null
     When `tar' is using the --files-from' option, this option
     instructs `tar' to expect filenames terminated with `NUL', so
     `tar' can correctly work with file names that contain newlines.

--numeric-owner
     This option will notify `tar' that it should use numeric user and
     group IDs when creating a `tar' file, rather than names.

--old-archive
     (See --portability.)

--one-file-system
-l
     Used when creating an archive.  Prevents `tar' from recursing into
     directories that are on different file systems from the current
     directory.

--owner=USER
     Specifies that `tar' should use USER as the owner of members when
     creating archives, instead of the user associated with the source
     file.  USER is first decoded as a user symbolic name, but if this
     interpretation fails, it has to be a decimal numeric user ID.

     There is no value indicating a missing number, and `0' usually
     means `root'.  Some people like to force `0' as the value to offer
     in their distributions for the owner of files, because the `root'
     user is anonymous anyway, so that might as well be the owner of
     anonymous archives.

--portability
--old-archive
-o
     Tells `tar' to create an archive that is compatible with Unix V7
     `tar'.

--posix
     Instructs `tar' to create a POSIX compliant `tar' archive.

--preserve
     Synonymous with specifying both --preserve-permissions' and
     --same-order.

--preserve-order
     (See --same-order; *note Reading::..)

--preserve-permissions
--same-permissions
-p
     When `tar' is extracting an archive, it normally subtracts the
     users' umask from the permissions specified in the archive and
     uses that number as the permissions to create the destination
     file.  Specifying this option instructs `tar' that it should use
     the permissions directly from the archive.  *Note Writing::.

--read-full-records
-B
     Specifies that `tar' should reblock its input, for reading from
     pipes on systems with buggy implementations.  *Note Reading::.

--record-size=SIZE
     Instructs `tar' to use SIZE bytes per record when accessing the
     archive.

--recursive-unlink
     Similar to the --unlink-first option, removing existing
     directory hierarchies before extracting directories of the same
     name from the archive.  *Note Writing::.

--remove-files
     Directs `tar' to remove the source file from the file system after
     appending it to an archive.

--rsh-command=CMD
     Notifies `tar' that is should use CMD to communicate with remote
     devices.

--same-order
--preserve-order
-s
     This option is an optimization for `tar' when running on machines
     with small amounts of memory.  It informs `tar' that the list of
     file arguments has already been sorted to match the order of files
     in the archive.  *Note Reading::.

--same-owner
     When extracting an archive, `tar' will attempt to preserve the
     owner specified in the `tar' archive with this option present.

--same-permissions
     (See --preserve-permissions; *note Writing::..)

--show-omitted-dirs
     Instructs `tar' to mention directories its skipping over when
     operating on a `tar' archive.

--sparse
-S
     Invokes a GNU extension when adding files to an archive that
     handles sparse files efficiently.

--starting-file=NAME
-K NAME
     This option affects extraction only; `tar' will skip extracting
     files in the archive until it finds one that matches NAME.  *Note
     Scarce::.

--suffix=SUFFIX
     Alters the suffix `tar' uses when backing up files from the default
     `~'.

--tape-length=NUM
-L NUM
     Specifies the length of tapes that `tar' is writing as being
     NUM x 1024 bytes long.

--to-stdout
-O
     During extraction, `tar' will extract files to stdout rather than
     to the file system.  *Note Writing::.

--totals
     Displays the total number of bytes written after creating an
     archive.

--touch
-m
     Sets the modification time of extracted files to the extraction
     time, rather than the modification time stored in the archive.
     *Note Writing::.

--uncompress
     (See --compress.)

--ungzip
     (See --gzip.)

--unlink-first
-U
     Direct `tar' to remove the corresponding file from the file system
     before extracting it from the archive.  *Note Writing::.

--use-compress-program=PROG
     Instruct `tar' to access the archive through PROG, which is
     presumed to be a compression program of some sort.

--verbose
-v
     Be more verbose about the operation.
     This option can be specified multiple times (for some operations)
     to increase the amount of information displayed.

--verify
-W
     Verify that the archive was correctly written.

--version
     `tar' will print an informational message about what version it is
     and a copyright message, some credits, and then exit.

--volno-file=FILE
     Used in conjunction with --multi-volume'.  `tar' will keep track
     of which volume of a multi-volume archive its working in FILE.

Shell Scripting (Part 2)

SHELL SCRIPTING (Part 2)

Shell script adalah beberapa perintah yang ditulis dengan plain text file. fungsi utama dari shell scripting adalah mengotomasi perintah-penrintah yang sudah biasa kita gunakan sehingga kita tidak perlu menuliskan setiap kali dengan cara yang berulang dan lengkap, tapi cukup dengan fungsi yang telah kita buat.

Inisialisasi Variabel

#!/bin/bash
data=$1
echo $data

Looping

#!/bin/bash
x=$1
for i in `seq 0 $x`;
do
echo $i
done

While

#!/bin/bash
x=$1
i=0
while [ $i -le $x ];
do
echo $i
let "i=$i+1"
done

If Condition

x=$1
if [ $(( x%2 )) -eq 0 ];
then
echo genap
else
echo ganjil
fi

Shell Scripting (Part 1)

SHELL SCRIPTING (Part 1)

Shell merupakan suatu program yang menghubungkan user dengan sistem operasi, dalam hal ini Kernel Unix. Shell menterjemahkan perintah-perintah dan parameter-parameter yang digunakan oleh user dalam environment Linux.

Jenis shell yang terdapat pada Unix :

Bourne Shell (sh) diciptakan oleh Steven Bourne, merupakan Shell UNIX yang pertama dan tercepat pada semua system UNIX Bourne Shell memiliki bahasa pemrograman shell yang baik tetapi kurang nyaman dalam hal interaktivitas.

C Shell (csh) diciptakan oleh Bill Joy, Bahasa pemrograman shell ini lebih sulit untuk digunakan oleh pemula karena memiliki sintaks mirip bahasa C dan oleh karena itulah shell ini dinamakan C Shell. kelebihannya Shell ini memiliki kemampuan interaktivitas yang lebih baik dibandingkan Bourne Shell, serta memiliki fasilitas command completation untuk dapat melengkapi perintah yang belum lengkap dapat dilakukan dengan menekan tombol Tab.

Korn Shell (ksh) diciptakan oleh Dave Korn. Shell ini diciptakan dengan menggabungkan kelebihan Bourne Shell dan C Shell sehingga Shell ini memiliki interaktivitas yang baik dan juga gaya pemrograman shell yang mudah.

Bourne Again Shell (bash) dikembangkan oleh Steven Bourne (pencipta sh) dimana shell ini adalah pengembangan Bourne Shell (sh) yang sudah dilengkapi dengan berbagai kelebihan yang tidak terdapat pada versi sebelumnya. Pada shell ini juga dilengkapi dengan kelebihan-kelebihan yang terdapat pada C Shell dan juga Korn Shell. Bash juga memiliki bahasa pemrograman yang baik serta interaktivitas yang mudah dipahami. Bash adalah jenis Shell yang paling banyak digunakan pada saat ini.

Almquist Shell (ash) dikembangkan oleh Kenneth Almquist. Shell ini kecil, cepat dan kompatibel dengan standard Posix. Ash banyak digunakan dalam embedded linux, embedded adalah sistem tertanam misalnya BIOS komputer.

BusyBox shell ini memiliki ukuran yang kecil dan banyak ditemukan dalam sistem linux embedded, installer, distribusi floppy atau kondisi yang membutuhkan kesederhanaan dan ukuran yang sangat kecil. shell ini juga menyediakan fungsionalitas banyak utiliti sistem dalam satu binary yang di link ke binari BusyBox.

Debian Almquist Shell (dash) merupakan turunan Almquist Shell (ash), yang diturunkan ke linux dari ash versi Net-BSD, oleh Herbert Xu pada tahun 1997, shell ini merupakan pengganti versi modern dari Shell ash pada distro Debian.

Exensible Shell (es) merupakan turunan dari Shell rc pada Plan 9 (distributed operation system yang dikembangkan oleh Bell Labs). Di Linux, es tergolong Shell yang sangat langka dan jarang digunakan.

Friendly Interactive Shell (fish) merupakan Shell yang cukup popular di Linux dan tergolong aktif dikembangkan. Fokus utama fish adalah kemudahan penggunaan. Fish tergolong sangat lengkap, kaya fitur dan cukup menarik.

Stand Alone Shell (sash) adalah Shell Unix yang menyediakan berbagai fungsionalitas utility sistem, dilink secara statik. Dengan fitur tersebut, sash umum ditemukan pada sistem minim resource, installer, atau pada rescue system.

Z Shell (zsh) adalah salah satu Shell populer di Linux, banyak pengguna Linux memanfaatkan kemampuan scripting-nya untuk membangun script yang kompleks.

Hart to Use Shell (hush) ide dari Shell ini adalah tugas yang sangat sederhana dibuat sangat rumit dan diselesaikan dengan perintah yang panjang.

Karel's Interactive Simple Shell (kiss) atau disebut juga Karel's Incredibly Stupid Shell (kiss) Shell dengan fungsionalitas berbagai utiliti penting sistem yaitu: rkiss dukungan readline, gkiss dukungan getline, bkiss tanpa fitur editing.