Lecture 1

Lecture 1: OVERVIEW OF COMPUTERS AND PROGRAMMING LANGUAGES

TOPICS

Computer Organization Overview: hardware and software
Computer programming and programming life-cycle phases
Algorithms
Programming languages
Procedural and Object-Oriented Programming

OUTLINE

1. Computer Organization Overview

Computer = a programmable device that can store, retrieve, and process data.
Hardware = physical components of a computer (monitor, mouse, keyboard, chips, boards, cables, cards, etc.)
Hardware components (overview):

$Description: Description: Description: C:\Courses-NOW\Webpage\236\LectureNotes\L1-computer.JPG$

CPU = central processing unit - executes the instructions in programs. Components: Control Unit (CU) and Arithmetic Logic Unit (ALU). Location: motherboard
RAM = random-access memory = main memory - stores data that CPU accesses, including instructions. Fast, but temporary memory; wiped out when computer is shut down. Location: motherboard.
ROM = read-only memory. Programmed with a permanent collection of pre-set bytes. Permanent memory. Location: motherboard.
Secondary memory: hard disks, CDs, DVDs, flash memory, etc. Stores data that can be loaded into main memory. Slower, but permanent.
I/O devices = how you communicate with your machine (keyboard, monitor, mouse, speakers, etc.)
Networking equipment = how other machines communicate with your machine: networking cards, cables, etc.
Main memory = a table of bytes indexed by addresses. Computer data consists of ON and OFF pieces (written as 1’s and 0’s). Standard terminology:

bit = a single cell in main memory that can hold either a 0 or 1
byte = a sequence of 8 bits
word = smallest unit of addressable memory (often a sequence of 4 bytes)
1 KB = 1 kilobyte = 2¹⁰ bytes = 1,024 bytes
1 MB = 1 megabyte = 2¹⁰ KB = 1,024 KB
1 GB = 1 gigabyte = 2¹⁰ MB = 1,024 MB

Software = non-physical (“logical”) components of a computer - computer programs (the set of all programs available on a computer). Types: system software and application software.

System software: Operating system: manages computer's resources; typically runs as soon as computer is turned on. Typical responsibilities:

Process management: determines when and how programs will run on CPU time
Memory management: controls access to RAM
I/O, window system, network control: performs low-level drawing, communication operations
Security: manages user IDs, passwords, file protections, etc.

Application software: programs users interact directly with; usually are explicitly run. Examples: word processors, spreadsheets, presentation software, games, etc.

2. Computer Programming

a) Programming = decomposition of a task into a sequence of primitive operations (at the basic level, computer primitive operations are very simple).
Computer programming = Planning a sequence of steps (called instructions) for a computer to follow.
b) Programming life-cycle phases:

1. Problem-solving

Analyze the problem and specify what the solution must do
Develop an algorithm to solve the problem ( See next section for a brief reminder on algorithms)
Verify the correctness of the algorithm

Sample problem: a programmer needs to design an algorithm to determine an employee's weekly wages. First draft of the algorithm:

1. Look up the employee's pay rate
2. Determine the number of hours worked during the week
3. If the number of hours worked is less than or equal to 40, multiply the number of hours by the pay rate to calculate regular wages.
4. If the number of hours worked is greater than 40, multiply 40 by the pay rate to calculate regular wages, and then multiply the difference between the number of hours worked and 40 by 1.5 times the pay rate to calculate overtime wages
5. Add the regular wages to the overtime wages (if any) to determine total wages for the week.

Sample data:

In one week an employee works 50 hours at the hourly pay rate of $25.00. Assume a 40-hour normal workweek and an overtime pay rate factor of 1.5. What are the employee’s wages?

40 x $ 25.00          = $   1000.00
10 x 1.5 x $ 25.00   = $    375.00
                                    $ 1375.00

Weekly wages, in general:

if (hours >= 40)
wages = (40 * payRate) + (hours - 40) * 1.5 * payRate
else
wages = hours * payRate

Recall our real life example:

( 40 x $ 25.00 ) + ( 10 x 1.5 x $ 25.00 ) = $1375.00

The refined algorithm to determine an employee’s weekly wages:

1. Get the employee’s hourly payRate
2. Get the hours worked this week
3. Calculate this week’s regular wages
4. Calculate this week’s overtime wages (if any)
5. Add the regular wages to overtime wages (if any) to determine total wages for the week.

2. Implementation = translating an algorithm into a programming language (programming language = a language with strict grammar rules, symbols, and special words used to construct a computer program), testing, and debugging the program.
3. Maintenance = use and modify the program according to changing requirements or errors that were discovered while using it.

3. Algorithms

Much of computer science involves the study and design of algorithms.
Definition: Step-by-step procedures for solving a problem in a finite amount of time.
Algorithms encompass far more than computer programs. We are learning to write algorithms and the computer is simply a fast and flexible tool for implementing algorithms.
An algorithm is an ordered set of instructions such that:

     (1) There are a finite number of steps.
     (2) It takes a finite amount of time to execute the steps.
     (3) Each step is precise in meaning, and “doable.”
     (4) It is deterministic.
     (5) It solves a general class of problems.
Notes:

Requirements (1)-(2) ensure finite execution time --> should terminate after a bounded number of steps. One example:

STEP 1: Take a coin out of your pocket and give it to your friend
STEP 2: Repeat STEP 1

Requirement (3) ensures that the steps of the algorithm are simple enough that they can be easily understood and are doable (you may replace "doable" with "executable" or "effective".) For example, why the following instructions don't describe an algorithm?

          STEP 1: Make a list of all positive integers
          STEP 2: Arrange this list in descending order (from largest to smallest)
          STEP 3: Extract the first integer from the resulting list
Answer: These instructions don't describe an algorithm because STEP 1 and STEP 2 are impossible to perform: nobody can make a list of all positive integers (infinite list) and nobody can arrange the list in descending order starting with the largest (what is the largest positive integer?)

Requirement (4) ensures that at each step in the set of instructions, it is clear which step follows. In other words, an algorithm must be unambiguous; during the execution of an algorithm, the information must be sufficient to determine uniquely and completely the actions required by each step.
Requirement (5) ensures that the algorithm is general enough that it solves a general set of problems, and not one specific/particular problem.

In conclusion - the execution of each step in an algorithm does not require creative skills, it requires rather only the ability to follow directions. In specifying behavior, an algorithm must be precise, unambiguous, complete, effective, and correct.
Very important: Once the solution algorithm is complete, it must be desk checked. Beginning programmers are tempted to skip this testing phase; however, this often leads to frustrations during the coding stage as the programmer tries to juggle writing code with analyzing the program as a whole. Remember: it is easier to find logical errors in pseudocode than in program code.

4. Programming Languages.

Definition: languages with strict grammar rules, symbols, and special words used to construct a computer program. (Wikipedia: A programming language is an artificial language that can be used to control the behavior of a machine, particularly a computer.) Programming languages, like natural languages, are defined by syntactic and semantic rules which describe their structure and meaning. Thousands of different programming languages have been created, and new languages are created every year.
Machine language and high level languages:

Each computer system understands a low-level language that is specific to that computer (machine language). Programmers usually write programs in a high-level programming language that is easier to understand.
– Machine language: the language that can be directly used and understood by the computer (operations are very low-level, specific to the architecture).

– Computers can only execute machine code.
– Understood by a specific machine, so it is not portable (runs only on a specific type of computer)
– Is made up of binary-coded instructions (strings of 0's and 1's)

– High-level languages (C++, Java, Ada, Modula-2, Pascal, Cobol, Fortran…)

– Similar to natural language (easier to use and debug)
– Are portable (machine-independent)
– Not understood directly by a computer, so they must be converted somehow to machine language: compilers (the whole program is translated into machine language and then executed) and interpreters (the program is translated and executed one line at a time; much slower than compilers). Java uses a hybrid strategy: instead of compiling into machine language, Java programs are compiled into an intermediate language (Java bytecodes) that serves as the machine language for a theoretical/virtual computer (JVM = Java Virtual Machine). Java then interprets those programs by simulating the JVM.

The Compilation Process (C++):

$Description: Description: Description: C:\Courses-NOW\Webpage\236\LectureNotes\L1-Compilation.JPG$

The Java Interpreter:

$Description: Description: Description: C:\Courses-NOW\Webpage\236\LectureNotes\L1-Java.JPG$

– Generations of programming languages:

1^st (1GL): machine language (1940s) - A program is a sequence of instructions and each instruction is a sequence of 0's and 1's.
2^nd (2GL): assembly language (1950s) - Uses mnemonics (strings of characters) for each instruction. Assembly language is not machine language - used assemblers to convert assembly language to machine language.
3^rd (3GL): procedural languages (1960s - now) - Higher-level, universal constructs. Examples: Fortran, Algol, Cobol, Pascal, C, C++, Java, C#. Most 3GLs support structured programming, some support object-oriented programming.
4^th (4GL): domain-specific languages(DSLs) - designed for, and intended to be useful for, a specific kind of task. This is in contrast to a general-purpose programming language, such as C. Problem-oriented languages examples: spreadsheet macros, commercial business software, etc.
5^th (5GL): constraint languages = embedding of constraints in a host language (Prolog). Solving problems using constraints given to the program, rather than using an algorithm written by a programmer.

Programming languages require that we use certain structures to translate algorithms into programs. There are 4 basic control structures common to all programming languages (they stipulate the order in which instructions are executed):

1. Sequence: a series of statements that are executed one after another

$Description: Description: Description: C:\Courses-NOW\Webpage\236\LectureNotes\L1-sequence.JPG$

2. Selection (or branch): conditional structure; executes different statements according to certain conditions

$Description: Description: Description: C:\Courses-NOW\Webpage\236\LectureNotes\L1-if.JPG$

3. Loop: repeats statements while certain conditions are met

$Description: Description: Description: C:\Courses-NOW\Webpage\236\LectureNotes\L1-loop.JPG$

4. Subprograms (or procedures, subroutines, functions; methods in Java): allow us to break a program into smaller units (modules). Subprogram = a meaningful collection of sequence, selection, loop, and subprogram.

$Description: Description: Description: C:\Courses-NOW\Webpage\236\LectureNotes\L1-modularity.JPG$

5. Procedural and Object-Oriented Programming

All programming languages support a particular style of use (programming paradigm): procedural and object-oriented programming.
Procedural programming: programs are a collection of commands; the programmer defines the operations and data structures independently. Also called imperative programming. Examples: FORTRAN, Pascal, C, etc.
Object-oriented programming (OOP) uses "objects" and their interactions to design applications and computer programs; the programmer defines the operations and data structures in a more integrated way. Examples: C++, Java, Visual Basic, etc. In recent years, object-oriented programming has become especially popular in scripting programming languages (Python, Ruby, etc.)
OOP focuses on nouns and entities in a program, rather than verbs or actions. State an behavior are grouped into objects that communicate with each other.
Object Oriented Terminology:

object (instance)= principal entities that are manipulated by the program (nouns). Java: a unit of code that is the basic building block for a program (nothing can exist outside of a class --> each Java program is stored in a class)
class = a “blueprint” that defines the structure for one or more objects
method = Java term for a function (C++), a procedure or a subroutine; this is the code that does something (verbs)
main method = a special method that defines where program execution begins
statements = individual instructions

Java:

originally developed by Sun Microsystems and released in 1995.
derives much of its syntax from C and C++ but has a simpler object model and fewer low-level facilities.
Java's design, industry backing and portability have made Java one of the fastest-growing and most widely used programming languages in the modern computing industry. Used in web, business, telecom applications, etc.
There were five primary goals in the creation of the Java language:

It should use the object-oriented programming methodology. The syntax of Java is largely derived from C++. However, unlike C++, which combines the syntax for structured and object-oriented programming, Java is exclusively an object-oriented programming language. As a result, almost everything is an object and all code is written inside a class. The exceptions are the primitive data types (integer and real numbers, boolean values, and characters), which are not classes for performance reasons.
It should allow the same program to be executed on multiple operating systems (platform independent). Programs written in the Java language must run similarly on any supported hardware/operating-system platform. One should be able to write a program once, compile it once, and run it anywhere.
It should contain built-in support for using computer networks.
It should be designed to execute code from remote sources securely.
It should be easy to use by selecting what were considered the good parts of other object-oriented languages.

Additional Resources:
1. History of Computers (ENIAC): http://en.wikipedia.org/wiki/ENIAC

2. History of Computers (hardware): http://en.wikipedia.org/wiki/History_of_computing_hardware
3. ENIAC (U.S. Army photos): 1, 2, 3, 4, 5, 6, 7, 8, 9
4. CPU components: http://computer.howstuffworks.com/microprocessor3.htm