The only consideration about system software that is important to users is to be certain that any applications software purchased by users be compatible with their computers' system software. For example, a computer utilizing Windows cannot run applications software developed for an Apple Computer's System 8 operating system, and vice versa. Beyond this fact system software is really not very interesting - except to the techno-nerds while they are enjoying their Big Macs!
The concept of Multiprogramming is introduced on page 153. Multiprogramming is the capability of an operating system to simultaneously have two or more applications programs resident in RAM, has some consequences that need to be understood by users as they have direct affect upon computer performance. Multiprogramming permits two or more applications programs to reside in RAM, and the operating system controls the switching between the programs. The operating system transfers control to one of the application programs, and the CPU runs that program exclusively until an input or output operation is requested by the application program, or until a specific amount of time (typically 1/3 second) passes. The operating system regains control of the CPU, then transfers control to another application program and the same operations occur. The operating system can switch control among any number of applications programs. The CPU is so fast that it is able to accomplish enough work in 1/3 second that it appears that the applications programs are running continuously. As an example of multiprogramming, consider a user who is using Access to extract data from a database, port it into Excel for specific calculations, then incorporate the calculations into a Word document. Windows, the operating system, controls the switching among the programs. The switching process can be accomplished very quickly if the program to which control is being switched is within RAM. However, if the program to which control is being switched is not entirely in RAM (see "Virtual Memory," page 151), then some or all of the program has to be loaded from secondary storage (disk) into RAM before the control can be switched. And before the program can be copied from disk to RAM, some or all of another program currently in RAM must be copied to disk to make room for the program being copied in. The copying from RAM to disk and from disk to RAM is an extremely slow operation (compared to switching programs already in RAM), and the degredation in service can be perceived by the user. For example, a switch from Excel to Word when both are in RAM can be accomplished in less than one second. That same switch may take as long as five to ten seconds if one or both are not residing in RAM.
The switching process, whether initiated by Windows or by the user when he/she clicks on the task bar, can be accomplished much more quickly when both programs are in RAM. For this reason, the best and least expensive way to improve overall computer peformance is to increase the amount of RAM available for applications programs. For example, a computer with 32 meg of RAM can accommodate Windows and Excel easily, but Word would have to reside primarily on disk. Increasing the RAM to 64 meg would permit both Excel and Word to be loaded entirely into RAM, thereby reducing the switching time and improving performance. This concept applies only in situations where users are frequently switching from one application program to another. Users who (primarily) use only one application program at a time will not see an immediate benefit from more RAM. However, generally speaking, the best way to improve performance is to increase RAM. The figure below illustrates the multiprogramming situation.
All computers require that programs residing in RAM and being executed by the CPU be in the specific machine language of the CPU. Machine language programs, called object code programs, actually consist of a series of patterns of "1" and "0" that are different from the EBCDIC or ASCII codes only because the Control Unit interprets them as program instructions rather than letters or numbers (how that is accomplished is best left to the Computer Science types). The result is that machine language is virtually impossible for people to understand and/or modify.
Early computer scientists soon discovered that it was impossible to develop any but the simplest programs directly in machine language. They then developed the concept of assembly language, a programming language that was easier for people to use. Instead of a series of "1" and "0" patterns, an assembly language statement may look like this:
INPKB 4000
This instruction may, for example, tell the CPU to accept input from the keyboard and store the input results in RAM beginning in storage location 4000. The assembler program language statement constist of two parts: the mnemonic, or letter code that defines the physical activity to be accomplished (read from keyboard), and the address in RAM that is the target of the activity (RAM address 4000). Writing programs in assembly language is much easier than writing in machine language. Programs written in the assembly language (or any programming language - more on this later) by people are called source code programs.
The "problem" with assembly language is that it must be converted into machine language before the computer can actually execute it. The conversion process is accomplished by a program, written in machine language, that accepts the assembly source code program as input and generates the machine language object code program as output. The object program can then be loaded into RAM and executed by the computer. The use of assembly language programs makes development and (especially) modification of programs much easier for people, but effectively doubles the work of the computer when a new program is run. This is "no big deal" today since computers are both fast and cheap. But in the early days of computing, the computer was a very expensive and precious resource, and any additional step required to run a program was considered as a significant expense. Fortunately, human effectiveness won out over computer efficiency, and people soon quit having to program in machine language.
Note that once a program is developed and no longer requires any modifications, it can be assembled into an object code program and stored on disk. The object code program can then be loaded each time the program is run. The source code does not have to be assembled each time the program is run. However, when changes are required, the assembly language source code program is modified, then the modified assembly language source code program is again translated into a new object code program. The new object code program can then be loaded each time the program is run. Remember this note because its significance will be illustrated below.
The "problem" with assembly language source code programs is that they are also cumbersome with which to work. They get rather long because each physical computer instruction in machine language is generated from a corresponding assembly language program instruction. Early computer users were primarily scientists who wrote programs to solve mathematical problems. Programs were often program representations of mathematical formulas. In fact, one of the first electronic computers, the ENIAC that was developed by Mauchley and Eckert, was used to calculate "firing tables," the trajectories of shells fired from battleship guns under different conditions. In 1955, computer scientists at IBM developed the first high level programming language, FORTRAN. The language facilitated the development of programs that represent mathematical formulas. IBM also developed the program to translate the FORTRAN source code into object code, called the compiler. The U.S. Navy soon led the development of COBOL, Common Business Oriented Language, to meet its less scientific and more business oriented needs. They also assisted in the development of the COBOL compiler to translate COBOL source code programs into object code programs. At this time IBM also developed PL/1, a marvelous programming language that incorporated all of the features of FORTRAN and COBOL (as well as lots of concepts copied by later programming languages). In fact, I began my career as a programmer writing PL/1 programs. Interestingly, IBM copied the programming language name "PL/1" as well as "PL/2" through "PL/99". I always thought that IBM was being a bit over optimistic about their programming language names.
The fourth and fifth generation programming languages are (actually) specific refinements to third generation procedural programming languages. Any good programmer can accomplish anything in a third generation language that can be accomplished in a fourth or fifth generation language, usually more quickly and less expensively. Figure 4.24, page 57, illustrates the various generations of programming languages.
There are two significant points to consider when using any higher level programming language (regardless of generation). First, all source programs must be eventually translated into object code machine language programs. To do this a compiler is required. If you (or a programmer working for you) want to write a program in "C" for example, you must first purchase the "C" compiler so the translation from source code to object code can be accomplished.
Second, as noted above, once programs reach a stage where they no longer require changes, the object code program can be loaded each time the program is to be run. When you buy an "application package" (an accounting system, for example), you are buying object code machine language programs. The programs cannot be modified in any way. If the programs satisfy your information requirements, then there is no problem. However, if modifications are required, you have four choices.
- Contact the manufacturer of the package and ask for modifications (they have the source code). This is expensive (often $100 to $250 per hour) and most manufacturers don't want to do this anyway.
- Buy another package that (more closely) satisfies your specific information requirements.
- Buy a package that includes the source code, usually at a premium of 500% to 1000% in price. This option makes the source code available when modifications are desirable. You will also have to buy the compiler for the language that the application programs are written in.
- Write the programs yourself, or hire a programmer (either in-house or a consultant) to write the programs. This option also makes the source code available when modifications are desirable.
The "bottom line" is that purchasing a package is great (and inexpensive) if you can find a package to satisfy your specific information requirements. Evaluate packages carefully because you can't modify them and you can't return them for a refund. Packages that don't meet users' requirements quickly become "shelfware."
The New Programming Languages, consisting primarily of Object Oriented Programming Languages (OOPL), incorporate concepts that make system development easier and more consistent. The concepts are described briefly beginning on page 158, but quite frankly the benefits of OOPL are too technical to be of much use to most users. Interested students can contact me for more information about OOPL. The same offer goes for Visual Programming languages.
Internet Oriented Languages, such as HTML and Java, are fast gaining popularity as the Internet expands. We will examine these languages in greater depth when we begin our study of the Internet itself. A brief introduction to these languages is provided on page 160.