Ree CASS) Chapter 1: Panne be Computer Program Example 112. ‘There are 100 employees in an organization. The organization wants to distribute annual bonus to ihe based on their performance recorded in their annual appraisal forms. Each employce’, appraisal form contains hither basic salary and grade for hiner performance during the year. Grades an Of three categories — ‘A° for oustanding, “B’ for good, and °C’ for average performance. Bonus foray ‘employee is 100 of basic salary for outstanding performance, 70% of basic salary for good performance | 40% of basic salary for average performance, and none for all other cases. Write an algorithm to calculae ‘and print the total boaus amount. Algorithm: ‘Step 1: Initialize Total_Bonus and Total_Employees_Checked to zero. ‘Step 2: Initialize Bonus and Basic_Salary to zero, ‘Step 3: Take the appraisal form of the next employee. Step 4: Read the employee's Basic_Salary and Grade. Step 5: If Grade = A, then Bonus = Basic_Salary. Go to Step 8. Step 6: If Grade = B, then Bonus = Basic Salary x 0.7. Go to Step 8. Step 7: If Grade =C, then Bonus = Basic_ Salary x 0.4. Step 8: Add Bonus to Total_Bonus. Step 9: Add 1 to Total_Employees Checked. ‘Step 10: If Total_Employees_ Checked < 100, then go to Step 2. Step 11: Print Total_Bonus. Step 12: Stop. Programmers design such algorithms to solve complex programming problems. The examples clearly show that algorithm development even for simple problems is not as simple as it might appear initially, and requires some thinking. Also note from the examples that to solve a given problem every instruction must be carried out strictly in a particular sequence. It is this fact that a beginner to problem solving using computers finds difficult to appreciate. Representation of Algorithms ‘Commonly used ways to represent an algorithm are: 1. As program 2. As flowchan 3. As pseudocode ‘An algorithm represented in the form of a programming language is a program. Hence, any program is an algorithm, but the reverse isnot true. :Flowcharts [49 Other than programs, programmers often use flowcharts and pseudocodes for representing algorithms while planning their programs. They often find them of immense help in developing effective and corect algorithms for their programs before coding them in programming languages. Subsequent sections describe these program- planning tools. To plan their programs, programmers generally select one of them depending on their choice. FLOWCHARTS ees What is a Flowchart? ‘A flowchart is a pictorial representation of an algorithm. Programmers often use it asa program-planning tool for visually organizing a sequence of steps necessary to solve a problem using a computer. It uses boxes of different shapes to denote different types of instructions. Programmers write actual instructions within these boxes using clear and concise statements. Directed solid lines connecting these boxes indicate flow of operations ~ sequence in which to execute the instructions. The process of drawing a flowchart for an algorithm is known as flowcharting. Why Use Flowcharts? Normally; we first represent an algorithm as a flowchart, and then express the flowchart in a programming language to, prepare a computer program. The main advantage of this two-step approach in program writing is that, while drawing a flowchart, a programmer can concentrate fully on the logic of the solution to the problem at hand, without paying attention to the syntax and other details of the programming language. Moreover, flowchart shows the flow of operations in pictorial form, a programmer can detect any error in the logic greater ease than in the case of a program. Once the flowchart is ready, the programmer can concentrate on coding the operations in each box of the flowchart as statements of the programming language. Normally, this two-step approach ensures an error-free program, cea Experienced programmers, sometimes, write programs without drawing a flowchart. However, beginners should first draw a flowchart to reduce the number of errors and omissions in a program, Moreover, itis a good practice to have a flowchart along with a computer program because the flowchart often serves as a document for the computer program. It is very useful during the testing of the program, and while incorporating further modifications in the program. ut te uy Flowchart Symbols Need for Flowchart Symbols A flowchart uses boxes of different shapes to denote different types of instructions. The use of symbols having standardized meanings makes it easier to communicate program logic through flowcharts. This is because use of standard symbols in a flowchart enables anyone using the flowchart to interpret the logic easily. For example, a diamond always means a decision. Hence, when a programmer looks at a flowchart he/she can identify the + decision points easily by looking for diamond-shaped boxes.Basic Flowchart Symbols Flowchans need only a few basic symbols to indicate necessary operations in algorithms, Figure 11.1 shows the basic flowchart symbols standangized by the American National Standands Institute (ANSI), Their functions are described below. Terminal InpuvOurput Processing ae | —! ? | Decision Flow lines Connectors i Figure 11.1. Base owehart symbols. 1. Terminal. Terminal symbol indicates the beginning (Start), the end (Stop), and pauses (Halt) in a Programs logic flow. It isthe first and the last symbol in a flowchart. In addition, if the program logic has, 2 pause, we also indicate it with a terminal symbol. Normally, we use a pause in program logic under some error condition, or for doing some manual setting during processing of program such as changing i forms in 2 computer's printer. zg Input/Output. Is 2 flowchar, inpuvlourput symbols indicate all program instructions-to input/output data from any type of inpuourput device (such as keyboard, mousé, scanner, monitor, printer, plotter, etc.) They also indicate instructions to input/output data from/to a storage device (such as disk, tape, etc.). Processing A processing symbol represents arithmetic and data movement instructions. Hence, in a flowchan, processing symbols indicate all arithmetic processes of adding, subtracting, multiplying, and dividing. They also indicate logical processes of moving data from one memory location to another (assignment statements). A processing symbol with more than one arithmetic and data movement instructions indicates consecutive execution ofthese instructions in the order of their placement. | Decision. A decision symbol indicates a decision point, which is a point at which a branch to one of wo or more alternative paths is possible. Figure 11.2 shows three different ways of using a decision symbol. The criterion for making a decision isin the corresponding decision box. A decision symbol also accounts for all possible exit paths depending on the result of decision. For each exit path, it has a label indicating the condition upon which the program logic takes that path for further execution, Flow lines. Flow lines with esrowheads indicate flow of operation, which is the sequence of execution of instructions. Normal flow of a flowchart is from top-to-bottom and left-to-right. Although, a flowchart requires arrowheads only when normal flow of operation changes, but as a good practice and to avoid ambiguity, we draw flow lines usually with an arrowhead at the point of entry to all flowchart symbols. Good practice also dictates that we should avoid crossing of flow lines as far as practicable. Connectors. When a flowchart becomes so complex that the number of flow lines and their direction are confusing, or when the flowchart spreads over more than one page, it is useful to utilize connector symbols 2s a substitute for flow lines. This symbol represents an entry from, or an exit to another part of the flowchart. A connector symbol is a circle with a Jeter or digit placed in it to indicate the link. A pait of identically labeled connector symbols indicates a continued flow when the use of a line is confusinged Flowcharts [201 } Hence, two connectors with identical labels serve the same function as a Jong flow line. How it is possible to determine if a connector symbol is an entry or ext point? Itis very simple ~ if an arrow enters but does not feave a connector, its an exit point, and program control transfers tothe identically labeled connector he having an outlet, Connectors help in simplifying the task of drawing large flowcharts that spread over * several pages. Yes (2) Atwo-way branch decision (0) Athres-way branch decision (6) A muttiple-way branch decision Figure 112. Games of decksion syntols Sample Flowcharts We introduce below the art of flowcharting (describing an algorithm in the form of a flowchart) with the help of some simple examples. Example 11.3. AA student appears for an examination consisting of total 10 subjects with each subject having maximum marks of 100, The student's roll number, name, and marks obtained by hinvher in various subjects are input data, Such’a collection of related data items, treated as a unit, is known as a record. Draw a flowchart for the algorithm to calculate the percentage marks obtained by the stent, and to print it with higher roll number and namie. x Solution: Figure 11.3 shows the flowchart of the algorithm for this problem. The frst symbol, labeled “Start”, is a terminal symbol indicating the beginning of flowchart logic. It does not mean that someone has to switch on. the computer or press a start button. The second symbol is an UO symbol labeled “Read input data”. This step {inputs the roll number, name, and marks obtained by the student from an input device into the main storage of the computer. The third symbol is a processing symbol. Is label indicates that at this step the computer adds the marks obtained by the student in various subjecis, and stores the sum in a memory location named Tora. The fourth symbol is again a processing symbol. Its label indicates that at this stage, the program, calculates Percentage marks by dividing Total by 10, and stores the result in a memory location named Percentage. The fifth symbol is an JO symbol labeled “Write output data”.Levels of Flowcharts ‘There are no set standards on the amount of detail required in a flowchart. A flowchart that outlines the main segments of a program (shows only broad details) is a macro flowchart, and a flowchart with more details is a micro flowchart (also called detailed flowchart) | For example, let us consider the processing box having the instruction “Add marks of all subjects giving Total” in the flowcharts of our examination problem. Figure 11.10 shows a detailed flowchart for the operation in this processing box. The detailed flowchart shows how program logic computes the value of Total. Similarly, we can also convert Y/O boxes for “Read” and “Write” operations into detailed flowcharts. Part of a macro flowehart . ‘Add marks of Total = Total + Marks (D)} all subjects giving Toral : : ‘A micro flowchart Figure 11.10. Detailed flowchart of add marks of al subjects giving Total. Flowcharting Rules While programmers have a good deal of freedom in creating flowcharts, the American National Standards Institute (ANSI) has recommended a number of general rules and guidelines to help standardize flowcharting, process. Various computer manufacturers and data processing departments usually have similar flowcharting, standards, The basic flowcharting rules and guidelines are as follows: i 1, First chart the main line of logic, and then incorporate detail, 2, Maintain a consistent level of details for a given flowchart. ‘ '3) Do not chart every detal ina flowchart otherwise, the flowchart will only be a graphic representation of all the steps of the corresponding program. A reader interested in details can refer to the program itself,[[2T7]_Chapter 11: Planning the Computer Program 4. Use common statements that are easy to understand for words within flowchart symbols. Use descriptiy, titles written in your own language, rather than machine-oriented language. Be consistent in using names and variables in a flowchart. Go from left to right and top to bottom in constructing a flowchart. Keep a flowchart as simple as possible, and avoid crossing of flow lines. es If you need a new page while drawing a flowchart, break the flowchart at an input or output poin, | Moreover, use properly labeled connectors to link portions of the flowchart on different pages. i Advantages and Limitations of Flowcharts Advantages Use of flowcharts for program planning provides following benefits: 1. Better communication. A flowchart is a pictorial representation of a program. Therefore, it is easier fora Programmer to explain the logic of a program to others through a flowchart, rather than the program itself. 2. Effective analysis. A macro flowchart, which charts the main line of logic of a software system, becomes | the system's model that can be broken down into detailed parts for study. and further analysis of the | system. 3, Effective synthesis. Normally, a group of programmers is associated with the design of a big software system. Each programmer is responsible for designing only a part of the entire system. Hence, if each Programmer draws a flowchart for his/her part of design, the flowcharts of all programmers put together | ‘can help visualize the overall system design. At this stage, we can easily detect any problem in’ linking various parts of the system and modify the design accordingly. Thus, we often use flowcharts as working ‘models in the design of new programs and software systems. 4. Proper program documentation. Program documentation involves collecting, organizing, storing, and maintaining a complete historical record of programs, and other documents associated with a system ‘Good documentation is needed because: . (2) Documented knowledge belongs to an organization, and does not disappear with the departure | (resignation/retirement) of a programmer, (b) If an organization decides to postpone a project, documented work helps in restarting the project later from the stopped stage, (©) When a programmer wants to modify an existing program, documented work provides hinv/her a ‘more understandable record of originally done work. Flowchants often provide valuable documentation suppor. a 5, Efficient coding. Once a flowchan is ready, programmers find it very easy to write the corresponding ‘rogram because the flowchart acts as a road map for them. It guides them to go from the g point of the program to the final point, without omitting any step. The ultimate result is an error-free program developed at a faster rate, 6. Systematic debugging. A flowchart is very helpful in detecting, locating, and removing mistakes (bugs) in a program in a systematic manner because programmers find it easier to follow the logic of the program in flowchart form. The process of removing errors (bugs) in a program is known as debugging. ITI "eee7, Gystematic testing. Testing is the process of confirming whether a program does all its intended jobs guccessfully under specified constraints. For testing a program, the testing team executes the program ‘with different sets of data as input totes the different paths in program logic. For example, to test the complete logic ofthe program for Example 11.6, the following sets of data are necessary: | (a) Data for a male student. | (b) Data fora female student, who scored less than 45%. | (©) Data fora female student, who scored exactly 45%. (@) Data fora female student, who scored more than 45% but less than 60. | (© Data fora female student, who scored exactly 60% tii (Data fora female student, who scored more than 60%. (© Obviously inthe end, the trailer data having sentinel value. {A flowchart i very helpful in designing test data fr systematic testing of programs. Limitations Inspite oftheir many advantages, flowcharts have the following limitation: 1, Flowcharts are very time consuming and laborious to draw with proper symbols and spacing, especially | for large complex programs. In this chapter, you have seen examples of small flowcharts developed for relatively small programs. You can very well imagine how difficult it would be to develop a detailed flowchart for a program containing over $0,000 statements. 2, Owing toshe symbol-string nature of flowcharting, any change or modification in program logic usually requires a completely new flowchart. Redrawing a flowchart being a tedious task, many programmers do not redraw or modify the corresponding flowcharts when they modify their programs. This leaves a program and its flowchart in an inconsistent state. Tati, the logic used in the program and that shown in its flowchart do not match. This defeats the purpose of use of flowcharts as documentation support for programs. To take care of this problem, many companies use software tools that generate flowcharts automatically from program code. These software tools read a programs instructions and draw an equivalent flowchart of its logic. This backward approach draws flowcharts from program codes mainly for documentation purpose. 3. There are no standards determining the amount of detail that should be included in a flowchart, Because of such limitations, many organizations have reduced the amount of flowcharting used. In its place, they use alternative tools for program analysis, two of which are described below. PSEUDOCODE What is Pseudocode? Pseudocode is another program-planning tool used for planning program logic. “Pseudo” means imitation or false and “Code” refers tothe instructions written in a programming language, Pseudocode, therefore, isan imitation of actual computer instructions. These pseudo-instructions are phrases writen in a natural language (e.g., English, French, German, etc.) that a computer cannot understand. However, pseudocode uses a structure that resembles‘outpit operations, arithmetic operations, operations for data movement within CPU and memory, and logical or comparison operations, Every natural language has a systematic method of using the words and symbols in that language defined by the ‘grammar rules of the language, Similarly, we need to use the words and symbols of a computer language as per the set rules, known as syntax rules, ofthe language. In cae ofa natural language, one can use poor or incorrect vocabulary and grammar and still communicate his/her thoughts. However, in case of a programming language, unless a programmer adheres exactly to the syntax rules ofthe language, even down to the punctuation marks, a computer will not understand hister instructions Over the years, programming languages have progressed from machine-orented languages (that use strings of binary 1s and 0s) to problem-oriented languages (that use common mathematical and/or English terms), However, ‘we can classify ll computer languages broadly into following three categories: 1, Machine language 2, Asseribly language 3. High-level language ‘The nature and characteristics of these three types of languages are described below. MACHINE LANGUAGE ‘Although we can design a computer to make it understand many different computer languages, every computer understands only one language without using a translation program. This language is called machine language of the computer. Normally, the machine language of a computer is written as strings of binary Is and Os. The cireuitry of a computer can recognize the machine language instructions immediately. It converts them into electrical signals needed to execute them. ‘A machine language instruction normally has a two-part format (see Figure 12.1), The fist partis operation code that tells the computer what function to perform, and the second partis operand that tells where to find or store the data on which the computer has to perform the function, Hence, each instruction tells the computer what operation to perform and the length and locations of the data fields involved in the operation. Every computer has a set of, operation codes called its instruction set, Each operation code (or opcode) in the instruction set is meant to perform a specific basic operation or function. Typical operations included inthe instruction set of a computer are: 1. "Arithmetic operations 2, Logical operations 3. Branch operations (either conditional or unconditional) fo transfer of control tothe address given in the operand field 4, Data movement operations for moving data between memory locations and registers 5. Data movement operations for moving data from input devices to memory, or from memory to output devices.[222 | Chapter 12: Computer Languages ___ Figure 12.1 shows a typical single-address machine language instruction. Although some computers use only single address instructions, many computers use multiple-address instructions that include addresses of two or more operands. For example, augend and addend may be the two operands of an addition operation. OPCOD! (operation code) Figure 12.1. Instruction format . ‘most ; Al computers use bir diss (sand 1s) for perforin internal operations, ewes TO CAA mag, language instructions consist of strings of binary numbers For example, 3 (PIC Pr © pins | number on a printer might be 210120011 | i | 100 | A program to add two numbers in memory, and print the result might ppeat as Foll0Ws: | age is not easy 0 use because it is ditfcy,, | a : number system, yi | and, and because it uses. at a ae aracor familia. However, some of the first programy Nbich we eT with the first few computers, actually wrote ye programs in binary form as this one Obviously, this langu: a Since human progtameers axe muse fardliar wil Gecanal numnber. systenip ht) peat SWAle™ comp instructions in decimal, and leave it 1 the input device to convert them into binary. In fact, without too mac | effort 2 computer can be wired so that instead of using long strings of 1s and Os we can use, the more family decimal numbers. With this change, the preceding program appears as follows: | This set of instructions, whether in binary or decimal, which a computer can understan | directly without the help of a translating program is called machine code or machine language program. Hence, we need not necessarily code a machine language program as strings of binary digits (Is and 0s). We can also write it using decimal digits if the computer's circuitry permits this. Advantages and Limitations of Machine Language ‘A computer can execute programs written in machine language at great speed because the computer can | understand machine instructions without the need for any translation. However, writing a program in machine | language has following disadvantages: 1. Machine dependent. As the internal design of every type of computer is different from every other type of computer, machine language also differs from computer to computer. Hence, after becoming proficient in the machine language of one type of computer, if a company decides to change to another type, is programmers will have to learn a new machine language, and would have to rewrite all existing prograns. 2. Difficult to program. Although a computer executes machine language programs directly and efficiently, it is difficult to program in machine language. It is necessary for a programmer to either memorize the dozens of operation code numbers for the commands in the machine’s instruction set or refer to a reference card constantly. A programmer must also keep track of storage locations of data andinstructions. Moreover, a machine language programmer must be knowledgeable about the hardware struture of the computer 4, Error prone. For writing programs in machine language, a programmer has to remember the opcodes | + and must Keep track of storage locations of data and instructions. This makes it very difficult for him/her fo concentrate fully on the logic ofthe problem, resulting in programming errors. Additionally, due to | lack of any immediate visual indication of an error as the programmer writes machine language code, it | makes removal of such errors all the more difficult ‘4, Difficult to modify. It is difficult to correct or modify machine language programs. Checking machine instructions to locate errors is very difficult and time consuming, Similarly, modifying a machine | language program later is so difficult that many programmers prefer to code the new logic afresh instead j of incorporating necessary modifications in the old program. hilt In short, we rarely use machine language today for writing programs because it is very difficult and time consuming 10 do so. i [ASSEMBLY LANGUAGE a ss Programming in machine language i difficult and eror prone because a programmer needs to: 15> Write numeric codes forthe instructions in a computers instruction st. i 2, Write the storage locations of data and instructions in numeric form. } 3. Keep track of storage locations of data and instructions while writing a program. ‘Assembly language programming, introduced in 1952, helped in overcoming these limitations of machine language programming in the following manner: 1. By using alphanumeric mnemonic codes instead of numeric codes for the instructions in the instruction ) set. For example, using ADD instead of 1110 (binary) or 14 (decimal) for the instruction to add, SUB instead of 1111 (binary) or 15 (decimal) forthe instruction to subtract, and so on. With this feature, \ programmers can remember easily and use the instructions in the instruction set. 2. -By allowing use of alphanumeric names instead of numeric addresses for representing addresses of fixed storage locations. For example, we may choose to represent memory locations 1000, 1001, and 1002 as FRST, SCND, and ANSR, respectively in an assembly language program. With this feature, a programmer can remember easily and use the storage locations of the data and instructions used in an assembly language program, This was same as using memory variables in programming languages. \\ 3. By providing additional instructions, called pseudo-instructions, inthe instruction set for instructing the system how we want it to assemble the program in computer's memory. For example, there may be pseudo-instructions for telling the system things like: | : samt PROGRAM xt c000 | START DARA. AT. =1000 Ser ASIDE eee ser ASIDE roe SEND ser ASIDE at for NSE224 Chapter 12: Computer Languages With this feature. a programmer need not keep track of storage locations of the data and instructions whi writing an assembly language program. That is, he/she need not even tell the computer where {0 place cach data item or instruction of a program. A language that allows use of letters and symbols instead of numbers for representing instructions and storage) locations is called asserchly language or symbolic language. A program written in an assembly language is calle) assembly language program or symbolic program. | Assembler | | | ‘A computer cen directly execute only machine language programs, which use numbers for representing instructions and storage locations. Hence, we must convert (translate) an assembly language program into is | equivalent machine language procram before executing it on the computer. A translator program called assembler} does this translation. Assembler is system software supplied by computer manufacturers. It translates an assem | language program into its equivalent machine language program. It is so called because in addition to translating | it also “assembles” the machine language program in main memory of the computer, and makes it ready fy execution. ?. 4 As Figure 122 shows, input to the assembler is an assembly language program (often referred to as source | Program), and is output is the equivalent machine language program (often referred to as object program). Since the assembler translates each assembly language instruction into an equivalent machine language instruction, there is a one-to-one correspondence beeen the assembly language instructions of a source program and the machine, language instructions of its equivalent object program. Note that during the process of translation of a soure | program into its equivalent object program by the assembler, the source program is not under execution. Tie} assembler only converts it into 2 form that the computer can execute. | Notice that in case of an assembly language program, the computer has to run the assembler (program) first to translate the original assembly language program (source program) into its equivalent machine language program (object program), and then execute the object program to get the result. This means that the computer has to spend ‘more time in getting the desired result from an assembly language program as compared to a machine language program. However, assembly language programming saves so much time and effort of a programmer that the extra time and effort spent by the computer is worth it. This conversion time is one-time and very small in case of stored-program computers. Once the system obtains the object code, it can execute it as many times as required. I Output Assembly language program A FTasenbier | 2°, Machine language program One-to-one correspondence (Source program) ————_""_ (Object program) Figure 12.2. llustrating the translation process of an assembler. ‘An example can best illustrate assembly language programming and translation of an assembly language progr into its equivalent machine language program. Hence, let us assume that a computer uses the mnemonics given it Figure 123 for the operation codes mentioned against each. For simplicity, we have considered here only fixe operation codes for viting our example program. Like this, there can be more than hundred 0 available in the instruction set of a computer.Mnemonic | Opcode | ‘Meaning HLT 0 CLA 10 ADD if SUB 1S STA 30 Hal, used atthe end of program to stop Clear and add into A register Add tothe contents of A register Subtract from the contents of A register Store A register Figure 12.3. A subset ofthe set of instructions supported by a computer. Let us write a simple assembly language program for adding two numbers and storing the result. Figure 12.4 shows the program. To get an idea of how the assembler converts this program into an equivalent machine language program, let us follow its instructions one-by-one. Notice tat the first five instructions ofthe program are pseudo-instructions for telling the assembler what to do. They are not par of the main program to add the two numbers. AT 0000 aT 1000 AN ADDRESS aN AN ADDRESS Figure 12.4, A sample assembly language program for adcing two numbers and storing the result. The first instruction of the assembly language program tell the assembler thatthe instructions for the main program (to add two numbers) should start at memory location 0000. Based on this directive, the assembler loads the first instruction of the main program (which happens to be CLA FRST in this example) at memory location 0000. It loads each subsequent instruction in the following memory location (that is, ADD SCND at location (0001, STA'ANSR at location 0002, and HLT at location 0003). ‘The second instruction ofthe assembly language program tells the Symbolic | Memory assembler that the data of the program should start at memory name | location location’ 1000, The next three instructions tll the assembler to set pes | 00 aside addresses for data items FRST, SCND, and ANSR. Based on these. four directives, the assembler sets up a mapping table scnd_|_ 1001 somewhere in the computer memory that looks somewhat lke the Anse [eine one in Figure 12.5. That is, the assembler picks up the first free address in the data area of the program, which is location 1000 Figure 12.5. Mapping table set up by the and calls it FRST, It picks up the next free address in the data area, See ete dala tore ‘which is location 1001, and calls it SCND. Finally, it picks up the af the assembly language next free address in the data area, which is location 1002, and calls program of Figure 12.4. it ANSR, ‘The next instruction of the assembly language program is CLA FRST, which the assembler translates into 10 1000, by translating CLA into 10 as in Figure 123, and FRST into 1000 as in Figure 12.5. Similarly, theassembler translates the instrection ADD SCND into 14 1001, and the instruction STA ANSR into 30 109) Finally, it translates the instruction HLT into 00, thus, providing the complete machine language program for the given assembly language program. Figure 12.6 shows the resulting machine language program. Comments Clear and add the number stored at FRST to A register Add the number stored at SCND to the contents of A register Store the contents of A register into ANSR Figure 128. Equivalent mactine language program for the assembly language program of Figure 12.4. Advantages of Assembly Language over Machine Language Assembly languages have following advantages over machine languages: 1, Easier to understand and use. Due to the use of mnemonics instead of numeric op-codes and symbolic names for data locations instead of numeric addresses, assembly language programs are much easier to understand and use than machine language programs, 2. Easier to locate and correct errors. Due to the use of mnemonic op-codes and symbolic names for data locations and also because programmers need not keep track of storage locations of the data and instructions, fewer errors are made while writing programs in assembly language, and those that are made are easier to find and correct. Additionally, assemblers detect and indicate errors automatically for use of an invalid mnemonic op-code or an undefined name. For example, let us assume that an assembly language program instruction reads ADD AREA and we forget to define AREA in the program. The assembler will look through its table and not finding AREA in it will indicate the error. 3. Easier to modify. Since they are easier to understand, it is easier to locate, correct, and modify instructions of an assembly language program than a machine language program. Moreover, insertion or removal of certain instructions in a program does not require change in the address part of the instructions following that part of the program. This is required in case of machine language. 4. No worry about addresses. An important advantage of assembly language is that programmers need not keep track of storage locations of data and instructions while writing an assembly language program. For example, let us assume that we have written a long machine language program involving many instructions and several references to itself within the program such as looping, branching, and so on. At the very end, we discover suddenly that we have left out-an instruction in the middle. If we insert that instruction, we will have to go through the entire program to check and modify (if necessary) all_ Assembly Language [227 | references to other instruction. This is certainly a tedious job. However, if we waite the same program in assembly language, we merely add the extra instruction, and the assembler will take care of suitably modifying the references automatically. Easily relocatable. Availability of pseudo-instructions for instructing the system how we want it to assemble a program inside the computer's memory makes assembly language programs easily re- Jocatable. This is because we can easily change a program's location by changing the pseudo-instructions suitably. This is not possible easily with machine language programming. An example can best illustrate this feature. Let us assume that an assembly language program starts at address 1000, and we find suddenly that this program uses another program, which also starts at location 1000. Obviously, we will have fo rewrite one of the two programs to move it to some other location. In machine language, this can be a complicated job. However, in case of assembly language, we merely have to change the pseudo- instructions suitably for assembling the program for one ofthe two programs. For example, we change the following pseudo- instructions for one ofthe programs: START PROGRAM AT 1000 START DATA AT 2000 to the following pseudo-instructions: START PROGRAM AT 3000 START DATA AT 4000 ‘and run the assembly language program once again through the assembler. The equivalent machine language program will this time start at merry location 3000 instead of 1000, and there will be no conflict with the other program. In other words, we can move assembly language programs easily from one section of memory to another, Efficiency of machine language. An assembly language program also enjoys the efficiency of its corresponding machine language program because there is one-to-one correspondence between the instructions of an assembly language program and its corresponding machine language program. In other ‘words, an assembly language program will be just as long asthe resulting machine language program. Hence, leaving out the translation time required by the assembler, the actual execution time for an assembly language program and its equivalent machine language program (written independently) would bbe the same. Limitations of Assembly Language ‘With the’use of assembly language, we cannot solve the following limitations of machine language: 1 Machine dependent. Since the assembler translates each instruction of an assembly language program into exactly one machine language instruction, assembly language programs are machine dependent. That js, assembly languages differ from computer to computer, and we can execute an assembly language program only on the computer, in whose assembly language is the program’s code. Hence, a decision to change to another computer will require learning a new language and conversion of all existing programs into assembly language of the new computer. Knowledge of hardware required. Since assembly languages are machine dependent, an assembly language programmer must have a good knowledge of the characteristics and logical structure of his/her ‘computer to write good assembly language programs. Machine level coding. In case of an assembly language, we still have to write instructions at machine- code level. That is, one assembly language instruction corresponds to one machine language instruction.2287) Chapter 12: Computer Languages Hence, like machine language programs, writing assembly language programs is also time-consuming and sifficult, Typical Uses of Assembly Language Programmers rarely write programs of any significant size in assembly language today. They write assembly language code only when a program's execution efficiency is very important. Assembly language programming helps in producing compact, fast, and efficient code because it gives the programmer total control of the computer's CPU. memory, and registers. Hence, we use assembly language programming mainly to fi important parts of programs written in a higher-level language, High-level language programs that are candidates for this type of fine-tuning are those whose execution consumes a substantial part of the total computing resources, and hence offer real payoffs for any improvement in execution time. In such circumstances, a clever Programmer can rewrite some small but critical section of the high-level language program in assembly language to improve its overall performance significantly. Assembly Languages with Macro Instructions In general, assembly languages are termed one-for-one in nature, that is, each assembly)language instruction results in one machine language instruction. However, quite often, a program uses certain set of machine language oor assembly language instructions repeatedly. For example, suppose we need three instructions, one after thé other, to print a value on a computer. Also, suppose that a program uses these three instructions repeatedly, always in the same order. Instead of forcing a programmer to write the set of three instructions every time he/she wants to print a value. we might as well design the assembler (program) to substitute these three instructions for a single instruction. For instance, every time a programmer uses the PRINT instruction in a program, the assembler would | ‘wanslate it into three machine language instructions instead of one, hence, supplying the complete set of instructions required for printing. Any instruction, such 2s PRINT, which an assembler translates into several machiné language instructions, is called macro instruction. There might be many such macro instructions permitted by an assembler. Hence, to speed up coding process, researchers developed assemblers, which could produce multiple machine language instructions foreach macro instruction ofan assembly language program. The use of macro instructions adds more work to a computer because the translation process becomes more than just changing each word into a number. The assembler must be able to supply the missing instructions as well, but it means a tremendous saving of work for a programmer. The programmer is relieved of the task of writing an instruction for every machine operation performed. Hence, the use of macro instructions reduces the length of programs, cuts down on errors, and simplifies programming. The macro instruction capability was developed very early in the evolution of computer languages. In fact, it is this concept of multiple machine instructions from one macro instruction around which today’s machine- independent, high-level languages are designed. HIGH-LEVEL LANGUAGE Both machine and assembly languages have following limitations: 1. They are machine dependent. We cannot execute a machine/assembly language program on any computer other than the one for which a programmer has written itHigh-Level Language [229] 2. They require programmers to have a good knowledge of the internal structure of the computer used. 4, Itis difficult, error prone, and time consuming to write programs in machinefassembly language because they deal with machine-level coding and require us to write one instruction for each machine-level operation. Due to these imitations, we often refer to machine and assembly languages as low-level programming languages. High-level programming languages bvercome these limitations of low-level programming languages. They have following features: 1, They are machine independent. That is, we can easily port and execute a program written in a high-level Janguage on any computer having translator sofware forthe high-level language, 2, They do not require programmers to know anything about the intemal strcture of the computer, which will execute their high-level language programs. In fact, since high-level languages are machine independent, a programmer writing a program in a high-level language may not even know which ‘computer will execute the program. This allows programmers to concentrate on the logic of the problem rather than be concerned with the details of the intemal structure of the computer. 3, They do not deal with machine-level coding, Rather, they deal with high-level coding, enabling the programmers 10 write instructions using English words and familiar mathematical ‘symbols and expressions. Each statement of a high-level language is normally a macro instruction that is translated into several machine language instructions. This is one-to-many translation and not one-to-one as in the case of assembly language. For example, let us consider the same problem of adding two numbers (FRST and SSCND), and storing the sum in ANSR, We saw that three low-level (machine/assembly) instructions are required to perform this job. However, if we use a high-level language, say FORTRAN for instance, to instruct the computer to do this job, only one instruction need be written: ANSR = FRST + SCND This instruction is obviously very easy to understand and write because it resembles the familiar algebraic notation for adding two numbers: a=b +c. ‘Advent of high-level languages has enabled even non-expert users to use computers to solve problems. This has allowed many users, without any background in computer science and engineering, to become computer . This, in tum, has resulted in the creation of a large number of computer applications in diverse areas leading to the use of computers today in every occupation. Compiler ‘A computer can execute only machine language programs directly. Hence, we must convert (translate) a high- level language program into its equivalent machine language program before we can execute it on a computer. We do ths translation withthe help of a translator program called compiler. ‘A compiler is a translator program (more sophisticated than an assembler) that translates a high-level language program into its equivalent machine language program. A compiler is so called because it compiles a set of machine language instructions for every program instruction of a high-level language. AAs Figure 12.7 shows, input to the compiler is a high-level language program (often referred to as source program), and its output isthe equivalent machine language program (often refered to as object program). Since high-level language instructions are macro instructions, the compiler translates each high-level language instruction into a set of machine language instructions rather than a single machine language instruction. Hence, |there is a one-to-many correspondence between the high-level language instructions of a source program and the machine language instructions of its equivalent cbject program, Note that during the process of translation of a source program into its equivalent object program by the compiler, the source program is not urider execution, ‘The compiler only convers it into a form that the computer can execute, Inu ey High-level language program 8 7 Gorapiter LONE", \tachine language program ‘One-to-many correspondence (Source program) "+ (Object program) Figure 127. tustrating the translation process of a compiler. A compiler transistes only source programs written in the language, which the compiler can translate. For example, a FORTRAN compiler can translate only source programs written in FORTRAN. Therefore, each computer requires 2 separate compiler for each high-level language that it supports. That is, to execute both FORTRAN and COBOL programs on a computer, the computer must have both FORTRAN and COBOL compilers. Figure 12. illustrates this ‘Compiler for “| language LI |” Program PI in high-level language L1 Machine code for PI | Compiler for language 12 || Program P2 in high-level language L2 Machine code for P2 ‘A computer supporting languages L1 and L2 Figure 12.8. lusvating the requirement of a separate compiler for each high-level language supported by a computer. Also, note that an object program for one computer may not be the same as the object program for another computer. Hence, it is necessary that each computer must have its own “personal” compiler for a language, say LI. Figure 12.9 illustrates how we can achieve machine-independence by using different compilers to translate the same high-level language program to machine language programs of different computers. Compilers are large programs residing permanently on secondary storage, To translate a source program, a computer first loads the compiler and the source program from secondary storage into its main memory. The computer then executes the compiler (which is also a program) with the source program as its input data. It generates the equivalent object program as its output, which the computer normally saves in a file on secondary storage. To execute the program, the computer loads the object program into main memory from secondary storage and executes it. Note that, there is no need to repeat the compilation process every time we wish to execute the program. This is because the object program stored on secondary storage is already in machine language. We simply have to load the object program into main memory from the secondary storage and execute it directly. Also, note that compilation is necessary whenever we modify the program. That is, to incorporate changes in the program, we must load the original source program into main memory from secondary storage,High-Level Language [23 software, and to convert them into a final executable program, which is sometimes called loud module. Hence, a Tinker is software that takes multiple object program files (modules) of some software and fits them together to assemble them into the software's final executable form. Interpreter Interpreter is another type of translator used to translate a high-level language program into its equivalent machine language program, It takes one statement of the high-level language program, translates it into. machine language instructions, and then executes the resulting machine language instructions immediately. That is in case of an interpreter, the translation, and execution processes alternate for each statement encountered in the high- level language program. This differs from a compiler that merely translates the entie source program into an object program, and is not involved in its execution. The input to an interpreter is a source program, but unlike a compiler, its output is the result of program execution instead ofan object program (see Figure 12.11). it Ouy Highvel language program 2%) Ierpreer canes and executes | OUP, ut of program excution statement-by-statement) (Source program) Figure 12.11, lustrating the role ofan interpreter. After compilation ofa source program, a user saves the resulting object program permanently for future use, and uses it every time he/she has to execute the program. Hence, repeated compilation translation ofthe source code) is not necessary for repeated execution ofa program. However, in case ofan interpreter, since a user cannot save the object program for future use, repeated interpretation (translation plus execution) of a program is necessary for its repeated execution, Since an interpreter translates and executes a high-level language program statement-by- statement, it reinterprets (translates and executes) a program statement every time it encounters that statement during program execution. For example, during execution ofa program, it reinterpret the instructions ina loop as ‘many times as the process executes the loop. ‘As compared to compilers, interpreters are easier to write because they are less complex programs than compilers. They also require less memory space for execution than compilers require. The main advantage of interpreters over compiles is that an interpreter flags a syntax error in a program statement toa programmer as soon as it interprets the program statement. Ths allows the programmer to make corrections during interactive program development. Therefore, interpreters make it easier and faster to correct programs. The main disadvantage of interpreters over compilers is that they are slower than compilers when running a finished program. This is because an interpreter translates each statement from the source program every time it executes it. A compiler translate each statement only once and saves it in te object program. We can execute the saved object program many times whenever needed, and no translation of any statement is required during the execution of the program. As the interpreter does not produce an object code for a program, it must perform the translation process each time it executes the program, To combine the advantages of both interpreters and compilers, sometimes, the program development environment of a computer system provides both a compiler and an interpreter for a high-level language. In these cases, a programmer first uses the interpreter to develop and debug his/her program. Then, aftr reaching a bug-free state, he/she compiles the program to obtain its object code and uses the object code for routine processing subsequently,B34 |_Chapter 12: Computer Languages We also refer to assemblers, compilers, and interpreters as language processors since they process language | instructions. ‘ | Intermediate Language Compiler and Interpreter A new type of compiler and interpreter now becoming popular combines the speed, ease, and control of both ‘compiler and interpreter in the same package and provides other features such as machine independence. In this approach, the compiler first compiles the source program to an intermediate object program. This intermediate object program is not a machine language code but a program written in an intermediate language that is virtually machine independent and understood by the combination interpreter. Then the interpreter takes the intermediate object program’and converts it into machine language program and executes it on the desired computer (often referred as host computer as it ‘hosts’ the virtual execution environment). The main benefits of this approach are: 1, The intermediate object program is in compiled form and thus is not original source code. This makes jt | safer and easier for a programmer to share his/her programs with others when the programmer does not ‘want to share the source code. The intermediate object program is in the form of a standard Intermediate Definition Language (IDL). Hence, writing a compiler and an interpreter is easier. 3. We can write the interpreter for any computer architecture and operating system as long as it can interpre the intermediate object program on the host computer system. This provides virtual machine environmen: to the executing program. 4. Arnewer system of interpreter is available that can convert (or compile) the complete or selected sections of intermediate object program, in memory, to final host machine language program and then stan execution at a faster speed as compared to line-by-line execution. This technique ‘is called Just-In-Time (IT) compilation. Advantages and Limitations of High-level Languages Advantages of High-level Languages High-level languages enjoy following advantages over assembly and machine languages: 1. Machine independence. We can execute a program written in a high-level language on many different types of computers with very litle or practically no effort of porting it on different computers. This means that a company changing its-computers, even to one from a different manufacturer, need not rewrite all the programs that itis currently using. This also means that commercial software will have a larger market because it need not be restricted to one type of computer. Hence, developers receive better reward for the time and effort spent on software developed with high-level language programming. 2. Easier to learn and use. High-level languages are easier to learn because they are very similar to the natural languages used by us in our day-to-day life. They are also easier to use because a programmer need not know the internal details of a computer for programming in a high-level language. 3. Fewer errors. While programming in a high-level language, a programmer need not worry about how and where to store the instructions and data of the program, and need not write machine-levei instructions