Programming Logic and Design Fourth Edition, Comprehensive

1
Programming Logic and Design Fourth Edition,
Comprehensive

• Chapter 4
• Designing and Writing
• a Complete Program

2
Objectives

• Plan the mainline logic for a complete program
• Describe typical housekeeping tasks
• Describe tasks typically performed in the main
  loop of a program
• Describe tasks performed in the end-of-job
  module
• Understand the need for good program design

3
Objectives (continued)

• Appreciate the advantages of storing program
  components in separate files
• Select superior variable and module names
• Design clear module statements
• Understand the need for maintaining good
  programming habits

4
Understanding the Mainline Logical Flow Through a
Program

• Understand what the goals are
• Ask the user to clarify if necessary

5
Understanding the Mainline Logical Flow Through a
Program (continued)

• Ensure you have all the data required to produce
  the desired output

6
Understanding the Mainline Logical Flow Through a
Program (continued)

• Understand the big picture first

7
Understanding the Mainline Logical Flow Through a
Program (continued)

• Procedural program one procedure follows another
  from beginning to end
• Mainline logic has three distinct parts
• Housekeeping steps to get ready
• Main loop instructions executed for every input
  record
• End-of-job steps taken at end of program
• Break the logic down into at least three modules

8
Understanding the Mainline Logical Flow Through a
Program (continued)
9
Understanding the Mainline Logical Flow Through a
Program (continued)

• Modularization of the program
• Keeps the job manageable
• Allows multiple programmers to work
  simultaneously
• Keeps the program structured

10
Housekeeping Tasks

• Housekeeping tasks include all steps that occur
  at the beginning of the program
• Declare variables
• Assumption in this book is the variables will be
  global variables!
• Open files
• Perform one-time-only tasks such as printing
  headings
• Read the first input record

11
Declaring Variables

• Assign identifiers to memory locations
• Specify the name and data type
• Use meaningful names and follow standards
• Prefixes may be used to group related variables
• Declare a variable for each field in a data file

12
Declaring Variables (continued)
13
Declaring Variables (continued)

• Group name
• Name for a group of associated variables
• Can handle the entire group with a single
  instruction

14
Declaring Variables (continued)

• Initializing (or defining) the variable
  providing an initial value
• Some languages provide default initial values
• Other languages leave variables with an unknown
  or garbage value
• Variables representing data fields in files do
  not need to be initialized

15
Declaring Variables (continued)

• Can use variables for report headings
• Embed any required spaces
• Heading can be printed using these variables

16
Declaring Variables (continued)

• Every language provides methods for NOT
  TRUE!
• Advancing the paper to top of page
• Printing single, double, or triple spaced lines
• Use annotation symbol to show variables

17
Opening Files

• Specify file name and path (location)
• Issue a file open command
• If no input file is opened, input may be accepted
  from the standard input device (e.g., keyboard)
• You must open both input and output files to be
  used, including printer output device
• If no output file is opened, standard output
  device (e.g., monitor) may be used

18
A One-Time-Only TaskPrinting Headings

• Printing headings for reports usually is done at
  beginning of the program

19
Reading the First Input Record

• Reading the first input record is the last
  housekeeping task
• Interactive application
• Interacts with users via keyboard or mouse input
• Program pauses when the read command is executed
  until the user enters data
• Delimiter a character designated as a separator
  between data values
• Prompt an output statement that asks the user to
  enter specific data

20
Reading the First Input Record (continued)

• Interactive input

21
Reading the First Input Record (continued)

• Input from a data file
• Input from a data file using a group name

22
Checking for the End of File ( EOF )

• First task after housekeeping
• For an interactive program, EOF may be determined
  when
• User enters a predetermined sentinel value
• User selects a screen option using a mouse
• For input from a file, the input device
  recognizes EOF
• If no data in the file, EOF occurs on the first
  read
• If there is data, each record is processed before
  the next read occurs

23
(No Transcript)
24
(No Transcript)
25
(No Transcript)
26

• Handling the report headings in a separate module

27
Writing the Main Loop

• Each data record passes through the main loop
  once
• Inventory program main loop steps
• Calculate the profit for an item
• Print the items information on the report
• Read the next inventory record

28
Writing the Main Loop (continued)

• Must declare additional variables for calculation
  results

29
(No Transcript)
30
Writing the Main Loop (continued)

• Detail lines are printed one line at a time
• Calculations can be done within the print
  statement
• Work variable (or work field) a variable used to
  temporarily hold a calculation ( aka calculated
  field )

31
Performing End-of-Job Tasks

• End-of-job tasks may include
• Printing summaries or grand totals
• Printing End of Report message
• Closing any open files
• Footer line (or footer) end-of-job message line

32
(No Transcript)
33
(No Transcript)
34
(No Transcript)
35
Understanding the Need for Good Program Design

• Good design is
• Critical for very large programs
• Needed to guarantee that components work together
  properly
• Well-designed program modules should work
• As stand-alone modules
• As part of larger systems

36
Storing Program Components in Separate Files

• Large programs may contain hundreds of variables
  and thousands of lines of code
• Manage lengthy programs by breaking into modules
• Many languages allow program components to be
  stored in separate files
• Storing components separately simplifies reuse
• Accessing modules from separate files is done
  with a statement like include, import, or copy

37
Storing Program Components in Separate Files
(continued)
38
Storing Program Components in Separate Files
(continued)

• Advantages of storing components separately
• Simplifies reuse
• Can be provided in compiled form only, to hide
  details
• Implementation hiding hiding details of how a
  program or module works

39
Selecting Variable and Module Names

• Using meaningful names
• Improves code readability
• Is a form of self-documenting the program
• Use pronounceable names
• Commonly used abbreviations are ok (e.g., SSN)
• Avoid digits in a name to avoid confusing
• Zeros and Os
• Ones and lowercase Ls

40
Designing Clear Module Statements

• Follow these rules
• Select good identifier names
• Avoid confusing line breaks
• Use temporary variables to clarify long
  statements
• Use constants where appropriate

41
Avoiding Confusing Line Breaks

• Free-form coding allows programmer to decide
  where to break lines of code

42
Using Temporary Variables to Clarify Long
Statements

• Use temporary variables to store intermediate
  results

43
Using Constants Where Appropriate

• Named constant a constant whose value never
  changes during execution
• Advantages
• Improves code readability
• If the value changes later, there is only one
  place in the code to make the change
• Usually written with all uppercase letters
• ATHLETIC_FEE
• TUITION_PER_CREDIT_HOUR

44
Using Constants Where Appropriate (continued)
45
Maintaining Good Programming Habits

• Program will be better written if you plan before
  you code
• Walk through program logic on paper before coding
  (desk-checking)
• Select good variable and module names for
  readability

46
Summary

• Three steps to designing a good program
• Understand the output that is required
• Ensure you have the necessary input data
• Plan the mainline logic
• Housekeeping tasks done at the beginning of the
  program declaring variables, opening files,
  printing headings
• Main loop is controlled by EOF decision
• Each data record passes through the main loop
  once

47
Summary (continued)

• End-of-job steps done at end of the program
  printing summaries, closing files
• Good design becomes more critical as programs get
  larger
• Program components can be stored in separate
  files
• Select meaningful, pronounceable names
• Avoid confusing line breaks, use temporary
  variables, and use constants where appropriate