Command-Line Interface (CLI) Styles

.QUESTION

Command-Line Interface (CLI) Styles

Prior to graphical user interfaces (GUIs), system administrators and operating system users had to use a command-line interface (CLI) to execute system commands. In most of our modern operating systems, the systems administrator still has the ability to use the CLIs to configure system resources, enhance security, and increase system performance. Within these CLIs, there are methods available to output data in different formats, sort data, and search for specific data stored in memory. These CLI methods include the use of pipe and filtering commands to execute system commands to do the following: configure system resources, enhance security, and increase system performance. All in all, you will be better off by understanding the benefits and limitations of CLI styles in case they would be needed one day.

NOW:

1) read “Command-Line Reference A-Z” and Red Hat Enterprise Virtualization 3.1: Command Line Shell Guide
Command-line reference A-Z
https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-xp/bb490890(v=technet.10)?redirectedfrom=MSDN

Red Hat Enterprise Virtualization 3.1: Command Line Shell Guide
https://access.redhat.com/documentation/en-us/red_hat_virtualization/4.3/html/product_guide/installation

2) Research the Internet for the history and other details about the pipe and filter style of commands
3) Then, write a report explaining the strengths and limitations in using pipe and filter commands. Provide a brief history of pipe and filtering style commands. Also, provide a comparison between the benefits of using pipe and filter commands with the commands available through a GUI.

Subject	Report Writing	Pages	5	Style	APA

Answer

Command-Line Interface (CLI) Styles

A pipe is a type of redirection that is utilized in Linux and other several Unix operating systems (OS) to give output of different programs to be processed. Filter are small and modified program in Unix OS that texts data into some meaningful manner, which can be utilized along with other filters and pipes to create series of processes that produces detailed results. Pipes are deemed to contribute more to Unix as it gives output to different commands (Shotts, 2012). Filters allows the administrator to assess the input to recover the output information. It is vital to recognize the techniques linked to both pipe and filter instructions as a Linux controller or an IT expert, for the instructions to be easily implemented. This paper provides several examples of strengths and limitations of utilizing pipe and filter commands. It also addresses a brief history of pipe and filtering types commands, compares the benefits of pipe and filter commands usage in a Graphic Administrator Interface (GUI).

One of the most significant characteristics of an operating system (OS) is its capacity to efficiently accomplish a series of instructions. M. Doug McIlroy started testing the linking Macros so one instruction could run a series of several instruction automatically run every distinct command (Shotts, 2012). McIlory’s accomplishment encouraged Ken Thompson, the first UNIX OS developer, to make pipe commands in 1973 (Shotts, 2012). Ken Thompson had advanced UNIX to be a standard type of system, which worked well with pipes. The UNIX OS was constituted of several identical and useable sections that could simply be laced with the pipe commands to run a series of actions. commands, transformed the UNIX OS.

Strengths
1. Spontaneous flow of processing
2. Support improvements by adding filters for instance, an omitting loud shift filter, or by adjusting self-regulating filters
3. Filter functions in isolation
Weakness
1. Very difficult to be interactive
2. Difficulty on deleting the user-selected lines (it requires persistent information storage)
3. Data communicated in lowest denominator system
4. Ineffective usage of space
5. Overall processing algorithm restricted to successive flow
Component Type

There are three basic types that function in a processing chain:

Pump (Producer):

This produces information to an output port, which is linked to the input pipe.

Filter:

Receives information from an in port that is linked to the output port, it transforms the data, and puts it to an output port that is also linked with a different pipe. It can have several ports.

Sink

Receives data from the input port, which is linked to the output pipe that consumes the data.

Connector Middleware

Some of the ways of implementing the pipe include:

Procedure Invokation

Filters that are functioning synchronously within a single processor might be linked by process invokations. The filter’s output port links to a putData system in the subsequent filter. The filter’s input port is a limit set that is passed to its putData method. This kind of pipe affects a unit produced that goes through the whole filter chain to the consumer before the control goes back to the producer to place the subsequent data item.

Byte Streams

Several OS and some object-directed languages give streams of bytes pipes. The software package outlets that are utilized to apply the connections amid two (probably remote) software applications are essentially two bytes

The benefits include:
- All the selections and processes are invoked in constant form, as with GUI’s same operations frequently appear on dissimilar menus with various lines and different software applications that have dissimilar approaches
- All the options and processes must be documented, which implies that it is no longer hard to complete a rare procedure than a usual one