Introduction

Chapter 1: Introduction - II

Chapter Goals

To learn about programming languages
To understand your first C++ program
To recognize syntax and logic errors

Translating Human-Readable Programs to Machine Code

The processor executes machine instructions:
- Extremely primitive:
- Encoded as numbers:
```
161 40000 45 100 127 11280
```
- Tedious and error prone to look up numeric codes and enter them manually.
- Each processor has its own set of machine instructions.

Assembler (low-level language)
- First step - assign short names to commands:
```
mov 40000, %eax
sub 100, %eax
jg 11280
```
- Second step - using symbolic names instead of absolute addresses (memory locations):
```
mov int_rate, %eax
sub 100, %eax
jg int_error
```
- Makes reading easier for humans.
- Translated into machine instructions by another program called assembler.
- Still processor dependent.

Higher-level languages:
- Independent of the underlying hardware.
- Easiest for humans to read and write.
- They follow certain convevsions which are much stricter than they are for human languages.
```
if (int_rate > 100) message_box("Interest rate error");
```
- Translated by compilers into machine instructions.

Programming Languages

A special computer program, a so-called compiler, translates the higher-level description into machine instructions for a particular processor.
Compilers follow strict conventions regarding programming language use. When a compiler reads programming instructions (expressions, operators, statements) in a programming language, it will translate them into machine code only if the input follows the language conventions exactly.
Strict rules prevent more disastrous errors that could arise should the compiler "guess."
There are many (hundreds of) programming languages.

Differences in programming languages are sometimes slight, but at other times substantial.

C++:

if (int_rate > 100) message_box("Interest rate error");

Pascal:

if int_rate > 100 then message_box('Interest rate error');

Programming Language Design and Evolution

Specific and General Purpose Languages

Many programming languages are created with a specific purpose.
- database processing (SQL)
- "artificial intelligence"
- multimedia processing (html)
Special-purpose languages are not used much beyond their area of specialization.
General purpose languages can be used for any task.
- Pascal: designed as a teaching language (purposefully kept simple).
- C: developed to be translated efficiently into fast machine code, with a minimum of housekeeping.
- C++: adds "object oriented programming" aspects to C.

Planned Languages

Planned languages (such as Pascal and Ada) are carefully designed to anticipate the needs of future users.
More thought goes into planned languages.
Features of planned languages tend to be more related to one another.
Designers pay more attention to readability and consistency.
Well designed languages are easier to use and learn.

Incremental Growth

C and C++ are languages that grew in increments; as the users of the language perceived shortcomings, they added features:
- 1972 - original design of C by Dennis Ritchie (link). Many compilers add different features, sprouting dialects of C.
- 1985 - Bjarne Stroustrup of AT&T adds object oriented features to C, creating C++.
- 1989 - ANSI standard of C developed to resolve differences among the several version of C.
- 1998 - Standards developed for most recent version of C++.
Grown languages tend to be messy; different features are added by people with different tastes.
Grown languages are modified in a hurry to solve a specific need, without considering the consequences.
Grown languages accumulate a patchwork of features that do not necessarily interact well together.
Grown languages have an edge in the marketplace (C++ allows programmers to use new features without throwing away old C code).
At this time, C++ is the premier language for general-purpose programming.
The purpose of our course is not to teach you all of C++ but to use C++ for teaching you the art and science of writing computer programs!

Compiling a Simple Program (hello.cpp)

C++ is case sensitive (main, Main and MAIN are different names)
C++ has freeform layout (spaces and line breaks are not important)
- Good taste dictates that you use readable program layout.

#include<iostream> - read the file iostream.h that contains the definition for the stream input/output package.
using namespace std; - all names in the program belong to the "standard namespace"
int main () { ... } defines a function called main. A function is a collection of instructions that carry out a particular task.
The statements (instructions) inside the body (inside the curly braces { ... }) of the main function are executed one by one.
Each statement ends with a semicolon ;
The sequence of characters enclosed in quotations marks ("Hello, World\n") is called a string.
- Escape sequence\n indicates a newline.
- Use \" to display quotes.
return denotes the end of the main function. The zero value is a signal that the program ran successfully.

Syntax 1.1: Simple Program

header files
using namespace std;
int main()
{
   statements
   return 0;
}

Example:	#include <iostream> using namespace std; int main() { cout << "Hello, World!\n"; return 0; }
Purpose:	A simple program, with all program instructions in a `main` function.

Errors (Syntax and Logic Errors)

Syntax error or compile-time error:
- Something violates the language rules.
- Compiler finds the error.
```
cot << "Hello, World!\n";
cout << "Hello, World!\";
```
Run-time error:
- Program compiles and runs but the operation system terminates the execution.
- Impossible operation, for example division by zero.
- Program author must test and find the error.
```
cout << 4 - 2*2;
```
- Overflow and underflow errors can occur when the result of a calculation is outside a computer's numeric range (i.e. either very big, 10¹⁰⁰⁰ or very small, 10^-1000).
Logic error
- Program doesn't do what it's supposed to do - it will compile and run but its output will be wrong.
- Program author must test and find the error.
```
cout << "Hell, World\n";
```

Calculation precision (roundoff error)
- A value cannot be represented precisely
- Example: 1/3 = 0.333333...; 1 - 3*(1/3) = 0.000001
Structuring programs so that an error in place does not trigger a disastrous response is called defensive programming.
A program error is commonly called a bug; special software tools called debuggers help you locate bugs.

The Compilation Process

The C++ source code is your program.
The compiler is a program that translate your C++ code into object code.
Object code consists of machine instructions and information on how to load the program into memory.
A linker program takes the object code from your program and the code from the various libraries and builds them into an executable file.
Libraries contain the (already translated) code used by your program (such as iostream).
hello.cpp --> hello.o or hello.obj --> hello or hello.exe
Edit -> Compile -> Debug Loop

Algorithms

A planning process must precede implementing a computer program.
The computer needs a systematic approach for finding solutions: a series of steps that involves no guesswork.
An algorithm is a solution technique (description of steps) that is unambiguous, executable, and terminating.
- Unambiguous - no room for guesswork or creativity.
- Executable - each step can be carried out in practice.
- Terminating - the process will eventually come to an end.

You put $10,000 into a bank account that earns 5% interest per year. How many years does it take for the account balance to be double the original?

Step 1: Start with the table

After Year	Balance
0	$10,000

Step 2: Repeat steps 2a-2c while balance < $20,000
- Step 2a. Add a new row to the table
- Step 2b. In column 1 of the new row, put one more than the preceding year's value
- Step 2c. In column 2, place the value of the preceding balance value, multiplied by 1.05.

Step 3: Report the last number in the year column as the number of years required to double the investment