The Role of the Command Line Interface in Modern Computing Operating Systems - Literature review Example

The Role of the CLI in Modern Computing Operating Systems Name Institution Course Instructor Date Contents Introduction 3 File and directory handling 3 System monitoring (process, memory usage and disk usage) 6 Building and distribution of programs applications using CLI 8 Debug mode 8 Release mode 9 CLI and scripting 10 Conclusion 16 References 17 The Role of the CLI in Modern Computing Operating Systems Introduction Despite many terms used by scholars such as ‘text interface’ and ‘command screen,’ among other terms to describe the command line interface (CLI), it is a user interface that involves typing of commands in a given computer operating system. It differs rather distinctively from the modern use of mouse in performing commands. For instance, the command line prompt of root Microsoft-Disk Operating System (root MS-DOS) is C:\> while that of LINUX (UNIX) is either % or >. That is why the use of CLI relies mainly on the keyboard in executing commands (Crooks et al. 2004, p.1189). As such, this paper seeks to present the role of the CLI in modern computing systems. It will achieve its objective by discussing various aspects of CLI that include file and directory handling, system monitoring, the use of CLI in building and distributing programs and assessing connection of CLI and scripting. File and directory handling Computer technologists define ‘shell’ as the use of an appropriate user interface in executing programs in a specific computer operating system. According to Mazieres (2001, p.261), there are several shell systems of operating computers, of which many users rely on graphical user interface (GUI) and command line interface (CLI). The CLI shell refers to the operating systems’ command protocol that requires the user to type alphanumeric denotations on a keyboard to input data or give instructions to the computer’s operating system. For example, in the CLI shell directory handling, a teletypewriter commands the computer’s executable interpreter program via typed keystroke codes, if the interpreter recognizes the keystroke codes it executes a specific application program, logs in the user or lists computer files, among other functions. Alternatively, if the interpreter parses the keystroke codes and the interpreter does not recognize the sequence, it portrays an error message on the screen (see screenshot 1). Screenshot 1: the CLI shell’s command prompt in Windows Alternatively, the use of CLI shell in file handling varies with the use of different operating systems. For example, LINUX uses a wide variety of CLI shell programs characterized with different capabilities, commands and syntaxes while the MS-DOS initially used a single type of CLI. Thereafter, the arrival of several third-party interfaces related to MS-DOS provided supplementary features to the MS-DOS standard command interface. Such features include execution of programs remotely and menuing. Also, application programs in the context of file and directory handling can use the CLI. For example, the telnet program in LINUX systems comprises of several commands that controls the local computer system connection. They usually consist of the same keystroke codes and input data transmitted to the remote system of the computer. There is a way of distinguishing the keystrokes and the input data by constructing an escape sequence. Based on the particular local keystroke, the local system always interprets the escape sequence and never passes it on. The escape sequence allows the program to switch between allowing keystroke-based data input processing and keyboard command interpretation. Screenshot 2: ‘Bash’ a commonly adopted LINUX CLI shell Additionally, many CLI shells are capable of saving re-usable command sequences. Moreover, the CLI’s features are important in the manipulation of the stored data files (script/batch files). For example, when restarting the computer system, the features allow repeated automation and initialization of routine computer programs and operations (Perez & Granger 2007, p.24). That is why the script mode use of CLI shells requires variables, structures and conditionals, among other language programming components. To a certain extent, CLI shell contains command-line completion feature that allow the interpreter to amplify commands following the input of a small number of characters. Similarly, other features allow the CLI shell to recall, repeat or edit previously issued commands. However, the memorization of the keystroke codes presents the only difficulty in the use of CLI shell file and directory handling (see screenshot 2). System monitoring (process, memory usage and disk usage) With reference to modern computing, system monitoring is an essential process. It is significant in a manner that any low performing programs that normally hamper system performance are detected and resolved early. One advantage of system monitoring is that the user is able to know whenever a system upgrade is required. Normal users of computers for non-advanced actions prefer using GUI. More advanced users prefer CLI. It is complicated in terms of its execution, but more effective when monitoring system functions. CLI usually provides a straightforward and effective means of controlling an operating system on the computer (Zander & Kothe 2011, p.255). System monitoring using CLI has wide application ranging from engineering fields to other scientific areas. System monitoring with CLI is effective as the system is able to make use of multiple command vocabularies at the same time. CLI also provides an extensive variety of choices compared to its modern counterpart, GUI. A lot of processes do require constant monitoring when the computer system is fully functioning. CLI uses text commands to manage many of the processes running on the system. Several process that can be managed include simple tasks such managing power entry in to the system and detecting any defaults. For power assessment, the command is cd / SYS / HDDO _PRSNT. After typing the command text, information is displayed on how the power is flowing through the system. One significance with that function is that overall power consumption by the system can be recorded for any future references. CLI has improved with time by being able to execute system monitoring functions on modern developed systems. CLI is able to utilize virtually developed software to analyze progress. One such developed tool is esxtop. Esxtop is able to analyze the usage of memory and CPU at the same time. Screenshot 6 below shows how one can monitor system functionality using Esxtop. The fact that CLI can still perform all these functions indicates that it is still relevant in modern computing. System monitoring is one of the key elements and CLI shows why it is still relevant (Alwall et al. 2011, p.22). Screenshot 3: monitoring of system functionality With only a bunch of keystroke codes, CLI is able to execute a number of tasks that show memory and CPU usage. A number of tools have been developed with the capability of system monitoring (Letondal 2001, p.75). Therefore, CLI is becoming out-phased with GUI, but it is still relevant in providing such services. Building and distribution of programs applications using CLI CLI shell allows users to build and distribute program using Ant build script in two major modes which include debug and release mode. After building, the user needs to sign the program before installation on a device or distribution. In the signing process, the program built in debug mode requires a debug key while that built in release mode requires a private key. Both modes require the Ant build script in compiling the program, because the Ant build tool creates .apk file that allows installation of the program. The debug mode allows automatic signing of .apk file via the SDK tools thereby allowing instant device installation of the program. For program distribution, the release mode built programs contain unsigned .apk file which allows individualistic signing using Jarsinger and Keytool, however, debug key signing prevents program distribution (Wilde et al. 2011, p.635). Debug mode Due to the automatic key signing and program optimization using zipalign by the build tools, the debug mode allows easy building, testing and installation of programs. In debug mode program building, an individual uses the CLI shell to navigate up to the program’s directory root. The user uses the Ant to assemble the program in debug mode (ant debug). The ant debug creates the debug .apk file within the bin/ program directory, termed -debug.apk. The program is signed and aligned automatically using the debug key and zipalign respectively. Therefore, whenever alteration occurs in resource or source file, one executes Ant to assemble the program’s latest version. Release mode Release mode allows users to build, release and distribute programs. There are two approaches of building programs in release mode. They include build unsigned and build signed and aligned. In build unsigned, the user needs to sign and align the assembled program manually. The initial step involves the release mode building of the unsigned .apk. Whereby, the user uses the CLI shell to navigate up to the programs’ directory root (ant release). The ant release generates an Android program .apk file within the bin/ program directory, termed unsigned.apk. At this point, the program contains an unsigned .apk file; therefore, it requires private key signing followed by zipalign’s aligning process. Finally, the program is readied for distribution via CLI after conducting compatibility tests on different devices. On the other hand, in build signed and aligned, the user automatically configures the build script thereby allowing independed signing and aligning of a particular program. However, the user needs to provide a keystore path and the name of the program key, termed as ant.properties file. With such undertakings, the build script prompts the users’ keystore and the program’s password when assembling and production of the ready-to-distribute program via release mode. However, Ant’s input handling process portrays the programs password on the screen. To hide the password, it is advisable to use Jarsinger or a similar tool in the manual signing of the program. In the specification of the user’s keystore and password, the user opens the program ant.properties file, followed by adding entries for key.password and key.store. For example, key.password=userkeystore or key.store=path/to/user.keystore. Thereafter, the user proceeds in building a release mode based signed .apk. It requires the users to open the CLI shell and navigate up to the program’s root directory, followed by program compilation using the release mode Ant (ant release). Finally, after prompting the program, the user is able to visualize the program’s password on the screen. The ant release creates an Android program .apk file within the bin/ program directory, termed -release.apk. It means that the anti.properties’ private key and zipalign signed and aligned the .apk file respectively thereby rendering the program ready for installing on a device and distributing via the internet. In program distribution, the user uploads the program via the signed .apk to, for instance, the Android URL allowing other people to download and install the program (Wang et al. 2011, p. 715). CLI and scripting The CLI users acknowledge that CLI is capable of processing instructions from files. In such aspects, the files are termed as CLI scripts. According to Bahn & Jacobsen (2002, p.58), the running of CLI scripts requires the user to input the CLI command line’s third parameter as the filename. This means that the processing and interpretation of the commands relates to the keyboard-typed command keystroke codes. Therefore, in the first line column, the mark # represents the embedded scriptfiles’ comments. Since normal CLI starting prompts the user’s password or username, it is important to prevent such instances by defining the system properties as the user’s password or username on the command-line (see screenshot 4). Screenshot 4: preventing display of username or password For instance, in the detailed use of MS-DOS scripting, the user needs to use /console (third parameter with winscp.exe) or winscp.com to initialize the scripting mode. In automated cases, the reading of commands relies on the standard winscp.com input, /script switch specified script file or command line passed /command switch (see screenshot 5). In this case, the default scripting relies on the interactive mode which is similar to the GUI mode (Langtangen 2006, p.33). However, in batch mode switching where automatic negative answering of the prompt occurs, the user relies on option batch abort command. Additionally, in the batch mode scholars advise the users to use option confirm off that allows overwrites in turning off confirmations. In case, the user fails to do so, overwrites are made impossible, because there is propensity of negative answering of the overwrite confirmation prompt. In multiple scripting sessions, the user is able to switch between the sessions using session command prompt. Screenshot 5: scripting in MS-DOS When checking the scripting results, the user needs to look out for the exit code one in WinSCP executables, because they signify abort answered prompts or errors when command interruption occurs. Alternatively, in the absence of errors, the executables display exit code zero. Additionally, it is important to note that in MS-DOS scripting all user commands in WinSCP contain syntax (see screenshot 6). Screenshot 6: WinSCP’s command syntax In the context of spaced command parameters, the user needs to surround the spaced command parameters with double quotes. This literally implies the doubling of quotes as in common writing (see screenshot 7). In this regard, the user needs to note the use of /command on command-line specifications, double quotes must surround each and every command followed by escaping via doubling the in-command double quotes. Also, environmental variables are applicable in syntax commands; however, it is wrong to use any MS-DOS command-line’s string processing syntax (see screenshot 8) (Langtangen 2006, p.55). On another note, MS-DOS scripting uses 20141024161712 code format in resolving %timestamp%. As such, the user uses %timestamp#format% syntax to tailor makes the code format. For instance, the format can involve ss seconds, nn minutes, hh hours, dd days, mm months and yyyy years. In such a case, 2014-11-20 is resolved by %timestamp#yyyy-mm-dd%. Apparently, in script argument referencing, users use syntax %N% and N as the argument’s ordinal number in conjunction with the use /parameter in command-line passing. Lastly on syntax, the insertion of comments in the script file requires the user to input a # when starting the line (see capture 9). Screenshot 7: an example of doubling quotes Screenshot 8: environment variables Screenshot 9: insertion of comments Finally, CLI scripting plays an important role in internet connections (see screenshot 9). Scholars however reveal that the success of the user in CLI scripting relies on the knowledge of command protocols that are useful in CLI scripting (see table 1). Table 1: common commands of CLI scripting Command protocol definition call Arbitrary starts the remote CLI command cd Transforms remote operating directory chmod Transforms remote file permissions close Terminates sessions echo Conducts script output message printing exit Terminates all sessions or programs instantly get Allows remote download of files to the remote directory help Displays of the screen ‘help’ keeuptodate Continuously shows the remote directory transformations on remote areas. lcd Necessitates remote working directory transformations lls Highlights the remote directory contents ln Necessitates the symbolic creation of local link lpwd Allows the printing of remote working directory ls Highlights the remote directory contents mkdir Generates local directory my Renames, moves or transfers local files open Allows linkage to the server option Sets and portrays script option values put Uploads remote directory files to local directory pwd Allows printing of the local operating directory rm Deletes local files rmdir Deletes local directory session highlights related or active script sessions stat Important in retrieval of local file features synchronize Allow local directory synchronization with remote counterparts Screenshot 10: CLI scripting in internet connections Conclusion In conclusion, the paper presented the role of the CLI in modern computing systems. It achieved its objective by discussing various aspects of CLI that include file and directory handling, system monitoring, the use of CLI in building and distributing programs and assessing connection of CLI and scripting. For instance, in file and directory handling, CLI is important in modern computing when a teletypewriter commands the computer’s executable interpreter program via typed keystroke codes. It is because, if the interpreter recognizes the keystroke codes it executes a specific application program, logs in the user or lists computer files, among other functions. However, if the interpreter parses the keystroke codes and the interpreter fails to recognize the sequence, it portrays an error message on the screen. Such functionality is not achievable by the use of GUI in file and directory handling. Finally, as much as modern GUI systems outface the initial CLI, it is still evident that complex tasks of computing are more effective when executed via the CLI shell. In particular, the users of Android system rely on CLI for building of programs in both debug and release modes, followed by packaging the programs for distribution. The debug mode allows easy packaging and installation of the program; however, it does not allow the distribution of the program. On the other hand, the release mode is sophisticated and complex in nature, but it allows packaging and distribution of the programs. References Alwall, J, Herquet, M, Maltoni, F, Mattelaer, O & Stelzer, T 2011, ‘MadGraph 5: going beyond,’ Journal of High Energy Physics, vol. 2011, no. 6, pp. 1-40. Bahn, SR & Jacobsen, KW 2002, ‘An object-oriented scripting interface to a legacy electronic structure code,’ Computing in Science & Engineering, vol. 4, no. 3, pp. 56-66. Crooks, GE, Hon, G, Chandonia, JM & Brenner, SE 2004, ‘WebLogo: a sequence logo generator,’ Genome research, vol. 14, no. 6, pp. 1188-1190. Langtangen, HP 2006 Python scripting for computational science (Vol. 3), Springer, New York, NY. Letondal, C 2001, ‘A Web interface generator for molecular biology programs in Unix,’ Bioinformatics, vol. 17, no. 1, pp. 73-82. Mazieres, D 2001, ‘A Toolkit for User-Level File Systems,’ In USENIX Annual Technical Conference, General Track, pp. 261-274. Perez, F & Granger, BE 2007, ‘IPython: a system for interactive scientific computing,’ Computing in Science & Engineering, vol. 9, no. 3, pp. 21-29. Wang, L, Kunze, M, Tao, J. & von Laszewski, G 2011, ‘Towards building a cloud for scientific applications,’ Advances in Engineering Software, vol. 42, no. 9, pp. 714-722. Wilde, M, Hategan, M, Wozniak, JM, Clifford, B, Katz, DS & Foster, I 2011, ‘Swift: A language for distributed parallel scripting,’ Parallel Computing, vol. 37, no. 9, pp. 633-652. Zander, TO & Kothe, C 2011, ‘Towards passive brain–computer interfaces: applying brain–computer interface technology to human–machine systems in general,’ Journal of Neural Engineering, vol. 8, no. 2, pp. 255. Read More