Computer Languages

     Despite having very little knowledge of the world of computer programming, I
have come to believe that C++ is currently the programming language of choice.

If that is the case, it would be easiest to only learn C++ and to ignore the
other programming languages. However, computer programmers should not ignore the
other programming languages for at least three important reasons. One, some
computers might not accept C++ as a programming language. Two, there may be
features of other programming languages that are superior to C++. Three, there
are many useful programs written in languages besides C++ that can only be
modified with knowledge of those other languages. For these reasons, it is
important that all good programmers are able to adapt to other programming
languages. The intention of this lab is to create computer programmers who are
able to adapt to many different programming languages. Section I: Examining

High-Level Programming Languages Introduction to Section I In this section, six
previously-prepared programs, written in the programming languages Fortran,

Pascal, and C, are looked at and compared. For each program a hypothesis is
formed about the function the program serves, and the way in which the program
performs that function. Also included in the hypothesis is a description of what
makes the programming language easy or difficult to read. Testing the hypothesis
is simply a matter of compiling and running the program using a variety of
inputs. For each experiment in this section, I wrote out a hypothesis for the
program before I tested it. Then, after testing the program, I prepared a
conclusion about how the program works. Experiment 1: oddeven.f Hypothesis I
believe that the Fortran program will first ask for how many numbers are in your
list of numbers. Then it will read in all the numbers in your list, one at a
time and tell you if the number that you just entered is even or odd. The
program will keep track of how many of your numbers are even and how many are
add. After you have entered in all the numbers in your list, it will print out
how many of your numbers are odd and how many are even. The Fortran language is
fairly easy to understand, so forming my hypothesis of what the program would do
was not a very difficult task. Most of the commands used in Fortran are words
that represent their function like "PRINT *," "READ *,"
"IF," "THEN," and "END." On the other hand, Some
of the commands used, like "DO 11 I =1" and "MOD," are vague
and not easily understood. The print commands are especially helpful for
checking my hypothesis. Because the print commands were written to give the user
a good idea of what the program is doing, they also helped me figure out what
the program is going to do. Conclusion The program behaved pretty much as I
thought it would in my hypothesis. First the program instructed me to
"Enter length of list." Then I was to enter in the numbers in my list
one by one, and after each number the computer either responded with
"[number] is even" or "[number] is odd. After I had entered in
all the numbers in my list, the program printed out how many of my numbers were
even and how many were odd. The program did not even mess up when I entered in
decimal numbers, instead it just truncated the number and proceeded as if the
truncated number was the number to be evaluated. Unfortunately, the program did
label zero an even number, which it isn't, but that is a fairly minor mistake.

Also, I happened to have noticed that if I was entering numbers, and screwed up,
the program wouldn't let me delete the last number I entered. This is kind of a
drawback, but I don't know how one would go about fixing that problem.

Experiment 2: weather.p Hypothesis To begin with, the program will print the
following "Good day. My name is Ronald Gollum. I'm stuck in this box until
quitting time. Please chat with me about the weather. Is it raining now?"

The computer will store the user's answer to this question under a variable
titled "Ans." If your answer to the question is Y or y, then the
computer will store the value true under the Boolean variable titled
"Raining." If your answer to that question is not Y or y, then the
program will store the value False in "Raining" and then print the
message "Too bad. We need rain." No matter what was entered
previously, the program will print the message "Do you think it will rain
tomorrow?" The program will replace the old value of "Ans" with
the answer to this new question. If the answer is Y or y the program will print
"I'll worry about that tomorrow." If the value stored under
"Raining" is true, the computer will then print the message "It's
finally quitting time! Good bye. You brightened up this rainy day."

Otherwise, the program will write, "It's finally quitting time! Good bye. I
want to work on my tan." For Pascal, like for Fortran, most of the commands
are words that represent something - commands like "begin," "writeln"
(I am guessing that ln stands for line), "readln," "if,"
"then," and "end." In Pascal, though, the commands that
store and interpret variables are not worded as I would expect them to be. For
example, one command was "if not Raining then [...]". I would expect a
computer to have an easier time with a more defined command like "if
raining = false then [...]." That Pascal command was probably someone's
attempt to make the program more like plain English. I also noticed that the
words in Pascal are not capitalized like in Fortran. In general, Pascal appears
to be much more like normal paragraph then Fortran. Tests Input Ouput at end

Input Immediate Output Y You brightened up this... Y I'll worry about that
tomorrow. yes You brightened up this... YES I'll worry about that tomorrow N I
want to work on my tan. N none No I want to work on my tan. NO none Yahoo You
brightened up this... YOyO I'll worry about that tomorrow Hallo I want to work
on my tan. Ween none 1999 I want to work on my tan. /?? none Conclusion The
program ran pretty much like I said that it would in my hypothesis. The only
real difference is that the program reacts to any word beginning with a Y or a
y, like it is a Y or a y. That is because only the first letter of any word that
is entered in is stored. When I entered the word yummy, the computer treated it
like I had entered an affirmative y. In the same respect, when I entered the
completely unrelated word Odd as a response, the computer treated my answer like
a negative response, and later responded like I had said no. I tried answering
with a bunch of different responses including numbers, symbols, and even Pascal
commands, but in every case the computer treated my answer like a negative
response, unless my response began with a Y or a y. Experiment 3: triangle.c

Hypothesis The program will ask for three side lengths for a triangle. If all
three side lengths are equal, the program will print "Equilateral\n".

If two side lengths are equal, the program will print "Isosceles\n".

Otherwise, the program will print "Scalene\n". The program will repeat
until 0 is entered as a side length, and then it will stop. Trying to guess what
this program is going to do was really difficult. This program is much longer
than the first two, and many of the commands seem to be unnecessary (commands
like "#include", "int clasify," "break," and
"scanf"). The commands are very difficult to read, and involve complex
syntax (What the heck is the command "scanf ("%If%If",
"&s2", &s3)" supposed to do?). The only reason that I
have any idea what the program is going to do is because of the print
statements, which print what the user needs to know. However, even within the
quotation marks of the print statements there is C syntax, like in this command
"printf ("Isosceles/n")". The if commands, at the end of the
program, led me to believe that the computer just compares the lengths to see
whether or not they are equal to each other. Tests Inputs Output 13, 13, 13

Equilateral 12, 16, 12 Isosceles 100, 90, 1 Scalene 45.8, 57.3, 45.8 Isosceles
-99, -99, -99 Equilateral Inputs Output -18, -96, 5, -18 Isosceles -56, -56, 38

Isosceles -89, 89, 98 Scalene -9, -9.5, 9.5 Scalene -11.25, -11.25, -11.25

Equilateral Inputs Output 76000, 7600.1,7600.1 Isosceles 8600.1, 8600.2, 8600.3

Scalene 17, 0 , 89 (ends) 0, 89, 123 (ends) -119, 245, 0 (ends) Conclusion

Surprisingly, my hypothesis was fairly close to being right. The computer
instructed me to enter three lengths. After I entered three lengths the computer
told me what kind of triangle those lengths corresponded to (scalene, isosceles,
or equilateral). The program did not print isosceles/n etc... like I
hypothesized it would, instead it printed isosceles. When I entered zero as a
side length the program ended just like it was supposed to.. The program would
accept negative lengths, despite the fact that a negative length is not
possible. The only stipulation the program had to separate the 3 different kinds
of triangles is that the correct number of side lengths was equal. Experiment 4:

Language Comparison Before Running the Programs C is a very difficult
programming language to understand. C commands are full of syntax that does not
seem to represent the plain English equivalent of the commands. C also requires
all sorts of symbols, parentheses, and brackets, which makes the program look
cluttered and cryptic. The bright side to the symbols, parentheses, and brackets
is that the programmer does not have to follow any specific format. Compared to
the C program, the Fortran program is very easy to read. Fortran reads almost
like a normal language algorithm. The commands used are REAL, PRINT *, READ *,
and END. The programmer still needs to know some syntax, but not nearly as much
as C. Each line contains one complete command, and nothing else. There are no
brackets, and parentheses cluttering up the program. Pascal is very similar to

Fortran, except that it is a little bit more complex and cluttered. Each line in

Pascal has a semicolon at the end, whereas Fortran did not need those
semicolons. Pascal also has colons and parentheses within the commands that

Fortran does not have. Pascal is still much easier to read than C. After Running
the Programs When I ran them, the three programs were almost identical. The only
difference between the three programs was the way the final print was formatted.

Pascal represented the numbers in scientific notation with 8 decimal places,
while Fortran and C represented the numbers in standard notation with about 6
decimal places. Fortran also had large spaces before and after each number,
whereas C did not. adda.f Adds 3 Numbers instead of 2. PROGRAM ADD 3 REAL NUM1,

NUM2, NUM3, SUM PRINT *, 'Enter three numbers: ' READ *, NUM1, NUM2, NUM3 SUM =

NUM1 + NUM2 + NUM3 PRINT * PRINT *, 'The sum of ', NUM1, ', ', NUM2, ' and ',

NUM3, 'is ', SUM PRINT * END All I needed to do to modify the program was add a
third number to the declaration, to the initial "PRINT" command, to
the "READ" command, to the "SUM =" statement, and to the
final "PRINT" command. addb.f subtracts two numbers PROGRAM SUBTRACT

REAL NUM1, NUM2, SUB PRINT *, 'Enter two numbers: ' READ *, NUM1, NUM2 SUB =

NUM1 - NUM2 PRINT * PRINT *, NUM1, ' minus ', NUM2, ' is ', SUB PRINT * END All

I needed to do to modify this program was to change the SUM variable to SUB,
change the addition sign in the "SUB =" statement to a subtract sign,
and change the final printout to print the appropriate statement. addc.f Divides
two numbers PROGRAM MULTIPLY OR DIVIDE REAL NUM1, NUM2, PROD PRINT *, 'Enter two
numbers: ' READ *, NUM1, NUM2 PROD = NUM1 / NUM2 PRINT * PRINT *, NUM1, ' / ',

NUM2, ' is ', PROD PRINT * END All I needed to do to modify this program was to
change the SUM variable to PROD, change the addition sign in the "SUM
=" statement to a division symbol, and change the final printout to print
the appropriate statement. Conclusion to Section I Writing the hypothesis's for
each the three programs turned out to be more difficult than I would have
thought. Each program had it's own syntax, and figuring out the syntax was not
an easy task. In experiment four, I decided that Fortran was the easiest
language to understand, Pascal was the next easiest, and C was extremely
difficult to understand. Without looking at the print statements for C, I would
not have been able to figure out what the triangle program did at all.

Minimizing the syntax and making the commands represent their functions is
extremely important for producing a readable, programmable language. Section II:

Programming In C++ Introduction to Section II For the last week in class, we
have been working exclusively with C++ without using computers, so I have been
looking forward to seeing the programs I've written in action. After programming
in assembly language, the prospect of writing programs that will write out lines
of characters that actually mean something is thrilling to me. I have heard that
programming in C++ is a pain in the butt, but I can not imagine that it is
nearly has laborious as programming in assembly language. In the section, I will
find out if I can cut it as a C++ programmer. Experiment 5: taxes.cc Hypothesis

First the program reads in your taxable income. If your taxable income is less
than $20,000 a year, the program multiplies your taxable income by the low-rate
tax (15%), and that value is your tax. If your taxable income is less than
$50,000 and greater than or equal to $20,000, the program multiplies your
taxable income by the mid-rate tax (28%), and that value is your tax. If your
taxable income is greater than or equal to $50,000, the program multiplies your
taxable income by the high-rate tax (.31), and that value is your tax. Finally,
the program prints your tax. Because we have been studying C++ for the last
week, understanding this program was not very difficult at all. If it were not
for that experience, this would probably be one of the more difficult programs
to read. The program uses quiet a bit of syntax, and the parentheses, brackets,
and symbols make it look cluttered and unorganized. On the good side, the
program has all the constants and variables at the beginning were they can be
easily changed. Conclusion The program worked as I thought it would in my
hypothesis for all positive numbers. For 0, the program returned zero, and for
negative numbers, the program returned the corresponding negative answers.

Experiment 6: determine_grade.cc The Algorithm Get a value for minimum
satisfactory score. Get a value for student's score. If student's score is
greater than or equal to minimum satisfactory score then Print the message
"Student's score is satisfactory." Else (student's score is less than
minimum satisfactory score) Print the message "Student's score is
unsatisfactory." Stop. The Source Code // Program: Determine Grade //

Author: Nathan Lindquist // Date Written: November 3, 1999 // Purpose of

Program: To read in a minimum satisfactory score and a // student's score, and
determine if the student's score is satisfactory // or unsatisfactory, based on
the minimum satisfactory score. // #include *iostream.h* int main () { double
min_satisfact_score; double student_score; cout ** endl ** "Enter the
lowest satisfactory score." ** endl; cin ** min_satisfact_score; cout **
endl ** "Enter the student's score." ** endl; cin ** student_score; if
(student_score *= min_satisfact_score) { cout ** endl ** "Student's score
of " ** student_score; cout ** " is satisfactory." ** endl **
endl; } else { cout ** endl ** "Student's score of " ** student_score;
cout ** " is unsatisfactory." ** endl ** endl; } } Experiment 7:

Modifying A C++ Program The Algorithm Get a value for points scored. If the
value of points scored is greater than or equal to 90, Print the message
"This vegetable is Grade A Fancy." Else if the value of points scored
is greater than or equal to 84, Print the message "This vegetable is Extra

Standard." Else if the value of points scored is greater than or equal to

10, Print the message "This vegetable is Standard." Else, Print the
message "This vegetable is Substandard." Stop. The Source Code // Name
of Program: Determine Veggie Class // Author: Nathan Lindquist // Date written:

November 3, 1999 // Purpose of Program: To read in the point value of a U S

Department // of Agriculture graded canned vegetable and decide which class
(Grade A // Fancy, Extra Standard, Standard, or Substandard) that canned
vegetable // fits into. // #include *iostream.h* int main () { int point_score;
cout ** endl ** "Enter the USDA point score of a canned vegetable " **
endl; cout ** "(the score should be an integer.)" ** endl; cin **
point_score; if (point_score *= 90) { cout ** endl ** "This vegetable is

Grade A Fancy" ** endl; } else if (point_score *=85) { cout ** endl **
"This vegetable is Extra Standard" ** endl; } else if (point_score
*=70) { cout ** endl ** "This vegetable is Standard" ** endl; } else {
cout ** endl ** "This vegetable is Substandard" ** endl; } } Tests

Input Output 105 This veg. is Grade A Fancy 93 This veg. is Grade A Fancy 90

This veg. is grade A Fancy 87 This veg. is Extra Standard 85 This veg. is Extra

Standard Input Output 76 This veg. is Standard 70 This veg. is Standard 65 This
veg. is Substandard 0 This veg. is Substandard -13 This veg. is Substandard

Experiment 8: Comparing C++ And Assembly Language The Algorithm The values of

Integer and Total are 0. While Integer is not equal to -1 Get a new value for

Integer. Set the value of Total equal to the previous value of Total + Integer.

Print the value of Total. The Source Code // Name of Program: Add Until //

Author: Nathan Lindquist // Date Written: November 3, 1999 // Purpose of
program: To read in integers and add them // until an end number (-1) is
entered. When the end // number (-1) is entered the program ends. // #include *iostream.h*
int main() { const int EndNumber= -1; // When this integer is entered, the total
// is printed, and the program ends. int Integer; int Total; Integer = 0; Total
= 0; while (Integer != EndNumber) // This will do the following steps until //
the end numver is entered. { Total = Total + Integer; cout ** endl **
"Enter an integer to be added. Enter the integer " ** endl; cout **

EndNumber ** " to print the total and end this program."** endl; //

These two cout commands tell the user to "Enter an // integer to be added.

Enter the integer [EndNumber] // to print the total and end this program."
cin ** Integer; } cout ** endl ** "The total of all the integers you "
** endl; cout ** "entered, except for the "; cout ** EndNumber **
", is " ** Total ** "." ** endl ** endl; // These final
three cout commands print "The total of // all the integers you entered,
except for the // [EndNumber] is [Total]. } Tests Inputs Manual Calculations

Output 3, 30, 10, 7, 18, -1 3 + 30 +10 + 7 + 18 = 68 68 -15, -20, -40, -7, -1
-15 + -20 + -40 + -7 = -82 -82 7, 0, 31, -128, -15, 75 -1 7 + 0 + 31 + -26 + -15
= -3 -30 127, -36, 15, -118, 0, 43, 49, 18, -1 126 + -36 + 15 + -118 + 0 + 43 +

49 + 18 =97 98 Conclusion While the above C++ program is actually longer than my
assembly language program from last lab, the C++ program above is ten times
better. The C++ program actually tells the user what value to enter and what the
output means. Whereas as in assembly language, a user would not know what to
input or what the output means. In the above program the constant that ends the
program can be easily switched from -1 to some other number; in assembly
language, switching a constant like that could take an hour. In the above
program, changing the program from adding numbers, to multiplying them would be
a matter of changing one sign; in assembly language, such a change quadruples
plus the size of your program. Conclusion to Section II Compiling the C++
programs actually worked out fairly well for me. If my program had an error in
it when I tried to compile it, the computer would tell me what line the error
was on, and it would point to what it thought the error was. Fortunately, I did
not end up with any serious problems, most of my mistakes were just typos. I
heard that many others where having a very difficult time compiling their C++
programs. Compared to assembly language, programming in C++ is no problem.

Conclusion Programming in Fortran, Pascal, and C++ is much more productive then
programming in assembly language. A whole array of much more advanced tools is
at our disposal. Now, we can write whole lines of characters, label variables
and constants, use Boolean expressions with variables and numbers other than
zero, write comments into the program, and the list of new tools goes on, and
on. Each one of these tools by itself would take hours, if not days to write an
efficient assembly language program for. In high level programming language, we
don't have to worry about registers, memory, storage, retrieval, and other
assembly language functions. To write a program that instructs the user what to
enter, inputs the side lengths of a triangle, and outputs the kind of triangle
it is, would take weeks of boring, meticulous assembly language programming.

With Pascal, Fortran, and C++, the same program takes an hour or less.