1 / 46

How Are Computers Programmed?

How Are Computers Programmed?. CPS120: Introduction to Computer Science Lecture 5. Problem Solving. Is an art, not a science It must be experienced, it can't be taught Guidelines can be provided Based on experience Sound like platitudes Are internalized as we learn to solve problems

ayanna
Download Presentation

How Are Computers Programmed?

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. How Are Computers Programmed? CPS120: Introduction to Computer Science Lecture 5

  2. Problem Solving • Is an art, not a science • It must be experienced, it can't be taught • Guidelines can be provided • Based on experience • Sound like platitudes • Are internalized as we learn to solve problems • It requires patience

  3. Problem Solving Tasks • Establish the context of the problem • Understand the problem • Determine the primary goals of the solution • Create a solution

  4. Problem Solving Guidelines • One big problem is unsolvable • Many small problems can be managed • Understand the problem: What is needed? • Write on paper what results are expected • What functions (procedures) will be required to generate these results • What information will need to be given to these functions • Describe what the functions do before you write a single line of code

  5. Programs • A program is a set of step-by-step instructions that directs the computer to do the tasks you want it to do and produce the results you want.

  6. The Program Development Cycle

  7. Understand the problem • Become familiar with what the program is trying to accomplish • Read the specifications • Ask questions • Understand the specifications • Eliminate extraneous information

  8. Plan the Program’s Logic • Decide how to best meet the program’s specifications • Often uses a flowchart or pseudocode • Divide the program into subroutines, functions or modules • Subroutines cost less and take less time to maintain • Can be used in other programs • Several programmers can work on the same project

  9. Code the Program • Put the solution, generally documented with pseudocode or a flowchart into a programming language

  10. Machine-Readable Form • Key the program into a computer

  11. Translate the program • Translated into machine language using an assembler, a compiler or an interpreter • Includes the elimination of syntax errors • Generate executable file

  12. Test the Program • Logic errors are not listed during the translation projects • Only way to find logic errors is to do program testing • Involves using sample data as input • Executing the program • Checking the results manually • Know as debugging

  13. Document the Program • Internal Documentation • Comments • External Documentation • Program specification • Layout chart • Hierarchy chart • Program flowchart • Pseudo-code • Data Dictionary • Input, Output, Work Area • Name, description, type, initial value, calculation • Source listing • Test Plan

  14. Programming Languages • A programming language is a set of rules that provides a way of telling a computer what operations to perform.

  15. Levels of Programming Languages • Machine language • Assembly Language • High Level Languages • Fourth Generation Languages (4GL)

  16. Machine Languages • different for each computer processor 0100 001101 100000 001101 110001 00101 10001 10000 01110 111001 . . .

  17. Assembly Languages • different for each computer processor main proc pay mov ax, dseg mov ax, 0b00h add ax, dx mov a1, b1 mul b1, ax mov b1, 04h

  18. High-Level Languages • Higher Level Languages • Use traditional programming logic where the programming instructions tell the computer what to do and how to perform the required operations. • 4GLs • Use high-level English-like instructions to specify what to do, not how to do it .

  19. Interpreter vs. Compiler • Interpreter • Translates instructions to machine code line-by-line. • Compiler • Translates the entire program to machine code before running it.

  20. Types of Programming Languages • Machine language • Procedure-oriented languages • Object-oriented languages • Event-driven languages

  21. Early Language History • FORTRAN (short for Formula Translator, developed in the 1950s by IBM • In 1958, a language called ALGOL (Algorithm Language) was developed • COBOL (Common Business Oriented Language) was created in 1960 to serve as the primary language for large-scale programs • In 1964, the BASIC language (Beginners All-Purpose Symbolic Instruction Code) was first used • In 1965, a language called PL/I was developed in hopes of being everything to everyone. • PL/I proved to be too complex. • In the late 1960s, Niklaus Wirth developed a teaching language called Pascal.

  22. Later Language History • Ada, which was developed in 1983, is large and complex. • Smalltalk is graphical and object-oriented. Concepts developed with Smalltalk were important to the development and continued development of languages like C++ and Java • The C language was derived from ALGOL. • C++ is C with the addition of object-oriented concepts.

  23. Procedure-Oriented Languages • FORTRAN • COBOL • Pascal • C • Ada

  24. OOED Languages • Object-oriented languages • Smalltalk • C++ • Ada 95 • Event-driven languages • Visual Basic • most Visual languages

  25. What Can a Program Do? • A program can only instruct a computer to: • Read Input • Sequence • Calculate • Store data • Compare and branch • Iterate or Loop • Write Output

  26. Fundamental Programming Concepts • Assignment of values to a variable • Iteration (Looping) • Over a set of set of statements • With respect to a logical expressions (conditions) • Delegation of sub-tasks to functions / procedures

  27. The Structure Theorem The Structure Theorem states that any algorithm can be built from three basic control structures. • One-after-another (Sequence) • Decision-making (Selection) • Making choices between 2 or more alternatives • Repetition (Iteration) • Concerned with repetitive tasks (and the termination conditions of loops)

  28. C++ Control Structures • "Sequence statements" are imperatives • "Selection" is the "if then else" statement • AND, OR, NOT and parentheses ( ) can be used for compound conditions • "Iteration" is satisfied by a number of statements • "while" • " do " • "for" • The case-type statement is satisfied by the "switch" statement. • CASE statements are used for most non-trivial selection decisions

  29. Sequence Control Structures • Sequence control structures direct the order of program instructions. • The fact that one instruction follows another—in sequence—establishes the control and order of operations.

  30. Calculate • A program can instruct a computer to perform mathematical operations. Add 1 to Counter

  31. Store • A program will often instruct a computer to store intermediate results. Place 1 in Counter

  32. Compare and Branch • A program can instruct a computer to compare two items and do something based on a match or mismatch which, in turn, redirect the sequence of programming instructions. • There are two forms: • IF-THEN • IF-THEN-ELSE

  33. Entry false true Exit True statement a IF-THEN Test condition p

  34. Entry Test condition p false true “false” statement a “true” statement a Exit IF-THEN-ELSE

  35. Iterate • A program loop is a form of iteration. A computer can be instructed to repeat instructions under certain conditions.

  36. Iteration Control Structures • Iteration control structures are looping mechanisms. • Loops repeat an activity until stopped. The location of the stopping mechanism determines how the loop will work: • Leading decisions • Trailing decisions

  37. Leading Decisions • If the stop is at the beginning of the iteration, then the control is called a leading decision. • The command DO WHILE performs the iteration and places the stop at the beginning.

  38. Entry Exit No Test condition p Yes Loop statement a DO WHILE Loop

  39. Trailing Decisions • If the stop is at the end of the iteration, the control mechanism is called a trailing decision. • The command DO UNTIL performs the iteration and puts the stop at the end of the loop.

  40. Entry Exit No Yes Test condition p DO UNTIL Loop Loop statement a

  41. Programmer Productivity Tools • Modular Programming • Structured Programming • Object-oriented Programming

  42. Modular Programming • Large programs are divided by functional parts into subroutines • Strong cohesion • Loose coupling

  43. Structured Programming • Composed of sequence, decision (selection), and repetition (looping or iteration) structures • Structured program languages lend themselves to flowcharts, structure charts, and pseudocode. • Structured programming languages work best where the instructions have been broken up into small, manageable parts. • Looks at a problem as procedures • Data are maintained separately from data

  44. Structured Program Rules • Use only sequence, decision, and repetition • Only one entrance into and one exit from a structure • Connectors only allowed when continuing processing from one column or page to another • Decision and repetition structures can be nested • Only one STOP instruction is permitted. It must be in the MAINLINE routine

  45. Structured Programming Advantages • Standard method for solving problems • GO-TO less • Easier to test and debug • Written by more than one programmer • Reusability • Thrashing minimized

  46. Object-Oriented Programs • Developed to respond to programming issues that structured programming did not adequately address • Rarely possible to anticipate the design of a completed system before implementation • GUIs were difficult to develop in traditional procedure-oriented languages • Sharing data across routines is error prone • Information hiding allows programmers to determine what data is exposed to various routines

More Related