Introduction to programming structure l.jpg
Sponsored Links
This presentation is the property of its rightful owner.
1 / 50

Introduction to Programming Structure PowerPoint PPT Presentation


  • 69 Views
  • Updated On :
  • Presentation posted in: General

Introduction to Programming Structure. Lesson 4. Overview. Guidelines Modules & Functions Cohesion & Coupling Local & Global Variables Parameters Variable Names & Data Dictionaries Three Logic Structures. Guidelines on Program Structure. Use Modules

Download Presentation

Introduction to Programming Structure

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Introduction to Programming Structure

Lesson 4

COP1000


Overview

  • Guidelines

  • Modules & Functions

  • Cohesion & Coupling

  • Local & Global Variables

  • Parameters

  • Variable Names & Data Dictionaries

  • Three Logic Structures

COP1000


Guidelines on Program Structure

  • Use Modules

    • Each part should have a particular function

  • Use the three logic structures

    • Sequential, Decision & Iteration

  • Don’t reinvent the wheel

    • Avoid rewriting identical processes

  • Use techniques to improve readability

COP1000


Cohesion & Coupling

Making Modules Better!

COP1000


Cohesion & Coupling

  • Each module should

    • Be functionally independent

    • Perform one problem-related task

      • Calculating IRS Withholding is one problem-related task, but may have multiple operations within the module

    • When connected, use the smallest interface possible.

COP1000


Cohesion

  • The degree of interaction within a module.

    • Each module should perform one functionally-related task…not necessarily one assignment statement.

    • Concentration is on what goes on within the module.

Term was coined by Larry Constantine in mid-1960’s

COP1000


Type MeasureBlack Box

Functional BestBlack Box

Informational ** Best

Sequential

Communicational

ProceduralGray Box

Temporal

Logical

Coincidental WorstTransparent

or White Box

**Originally not part of Scale

Scale of Cohesion

  • Stevens, Myers, Constantine, and Yourdon developed the Scale of Cohesion as a measure of the “black boxiness” of a module, and as a result, the maintainability of a module.

COP1000


Best (Lowest Interaction)

Normal

Data

Stamp

Control

Common

Content

Worst (Highest Interaction)

Coupling

  • The degree of interaction between two modules.

    • Interaction is the interface, or lack thereof, between two modules.

      • The interface is the parameter list.

    • Create it, use it, lose it

COP1000


Effects?

  • Which pieces affect Cohesion and which affect Coupling?

Private Sub Minimum(min As Long, y As Long, z As Long)

If y < min Then

min = y

End If

If z < min Then

min = z

End If

lblSmallest.Caption = "Smallest value is " & min

End Sub

What does this code do?

COP1000


What is the code doing?

  • What are the parameters? Variables?

Private Sub Minimum(Scully As Long, Mulder As Long)

Dim Temp As Long

If Scully < Mulder Then

Temp = Scully

Scully = Mulder

Mulder = Temp

End If

End Sub

Global &Parameters

Local Variable

COP1000


Each Goal

  • Cohesion’s Goal

    • To create a procedure that performs one functionally-related task.

  • Coupling’s Goal

    • To protect global data and local data from being used within a procedure without declaring it on the procedure’s header

      • Create as close to where you’re going to use it as possible, use it, then lose it as soon as possible

COP1000


Goal of Cohesion & Coupling?

  • High Cohesion

    • Functional or Information

  • Low Coupling

    • Data, Stamp, Control

COP1000


Modules, Procedures & Functions

The subparts to a Program

COP1000


Modules

  • “A module is a lexically contiguous sequence of program statements, bounded by boundary elements, having an aggregate identifier.” Yourdon & Constantine(1979)

    • A part of a larger system

    • Written and tested separately

    • Combined with other modules to form a complete system

    • Used in top-down programming

    • Procedures & Functions

COP1000


Procedures

  • A smaller part of the main program.

  • 2 Advantages

    • Eliminates the need to program the same thing more than once.

    • Larger programs are easier to read when broken into procedures (and functions).

COP1000


Functions

  • Functions

    • A subprogram that acts like a mathematical function:

      • given a particular set of argument values, the function returns a unique result.

      • Big Difference Between Procedures & Functions:

        • Use Return values that are associated with the name of the function

COP1000


Function Examples

  • Pascal

    FUNCTION doublenum(b : Integer) : Integer;

    BEGIN

    doublenum := 2 * b

    END;

  • Visual Basic

    Private Function Doublenum(b As Integer) As Integer

    Doublenum = 2 * b

    End Function

  • C++

    Intdoublenum ( int b)

    {

    return 2 * b;

    }

All three do the same thing, just with different syntax

COP1000


What Do They Have In Common?

  • Each module

    • is an entity by itself

    • has a single purpose

    • should be easily read, modified and maintained

    • Length is governed by function and number of instructions contained within

    • Controls the order of processing

COP1000


An Example of Control

VB Example

COP1000


Types of Modules/Procedures

  • Control

    • Demonstrates overall flow of data

  • Initialization & Wrap-Up

    • Processes instructions to be performed once (either at beginning or at the end of the program)

    • Used typically in batch processing

  • Process Data

    • Calculation

    • Print

    • Read and Validation

  • Event

    • Used in OO and some event driven programming languages

    • More about these later

COP1000


Control Modules

  • Most often called “Main”

  • All other modules, procedures and functions are subordinate to the control module

    Sub Main

    Call ProcedureA(X, Y)

    Call ProcedureB(A, B)

    End Main

COP1000


Init Module

  • Used in some languages to initialize variables or processes

    • Examples

      • Opening files

      • Initializing variables

      • Printing report headings

        Procedure Begin

        Dim X, Y, Z As Integers

        Open Payroll file

        End Procedure ‘Begin

Does this violate Cohesion or Coupling?

COP1000


Process Data Modules

  • Calculation

    • Performs

      • Arithmetic operations

      • Accumulations

      • Sorting or Searching

        Private Sub Double (X, Y)

        Dim Temp as Integer

        Temp = X * Y

        End Sub

  • Read and Data Validation

    • Reads and validates input data

      • Usually separate modules

  • Private Sub Verify(X)

  • If X < 0 Or X > 10 Then

  • lblMessage.Text = “Data Error”

  • End If

  • End Sub

COP1000


Wrap Up Module

  • Used to close out processes

    • Examples

      • Closing files

      • Printing reports

      • Returning updated data to database

        Procedure LastProcedure

        Close Employee file

        Close Payroll file

        End Procedure ‘LastProcedure

Does this violate Cohesion or Coupling?

COP1000


Global or Local Variables

Scope!

COP1000


Scope

  • The area of a program where an identifier (variable) is visible

  • When an identifier has multiple declarations in different modules, the most local declaration is used each time that identifier is referenced. (overloading)

  • Global or “non-local” variables subject to side effects.

COP1000


Side Effects

  • Caused when the value of a global variable is changed within a procedure or function

    • Any effect of one module on another module that is not a part of the explicitly defined interface between them

  • Also caused when a variable name is used in globally and locally (causes overloading)

  • A nasty effect that should be avoided!

COP1000


X, Y, Z

A

C

B

Global Scope

  • Declared within the main program

  • Can be referenced anywhere in the program

    • Is visible and accessible everywhere

X, Y & Z are Global to modules A, B & C

COP1000


X, Y, Z

A m

C p

B n

Local Scope

  • Declared within a module

    • Has no effect outside the procedure or function in which it is declared

  • Can be referenced only within a procedure or a function

Within A, Variable m is defined, but can also see X, Y, & Z

Within B, Variable n is defined , but can also see X, Y, & Z

Within C, Variable p is defined , but can also see X, Y, & Z

COP1000


Global or Local?

Private Sub Minimum(Scully As Long, Mulder As Long)

Dim Temp As Long

If Scully < Mulder Then

Temp = Scully

Scully = Mulder

Mulder = Temp

End If

End Sub

Scully & Mulderare what type of variables?

What type of variable is Temp?

VB Example

COP1000


Another Example

program ShowScope;

var X, Y, Z : Real;

procedure Procedure1 (var M, N, Me : Real);

var X, You : Real;

begin{Procedure1}

.......

end;{Procedure 1}

begin {ShowScope}

Procedure1(X, Y, Z)

end.{ShowScope}

Scope of X, Y, Z, Procedure1

Scope of M, N,

Me, X, You

Pascal Example

COP1000


Parameters

How we avoid side effects!

COP1000


Parameters

  • Are the variables that are passed into and out of modules

  • Use global parameters

    • (to the procedure or function)

  • Pass values through the use of variables

  • Actual and Formal parameters

  • Call-by-reference & Call-by-value

COP1000


Parameter Communication

  • A measure of the quantity of data passing through a module’s interface.

  • Is also a measure of the module’s coupling.

  • The goal is to strive for a minimal amount of information being passed.

COP1000


How Parameters are Used

  • Input Parameter

    • Information passed into a procedure, but not returned or passed out of the procedure.

  • Output Parameter

    • Information returned to the calling program from a procedure.

  • Input/Output Parameter

    • Information passed into a procedure, perhaps modified, and a new value returned.

Programmers now determine how their parameters are used.

COP1000


Parameters

  • Provide the communication links between the main program and its modules.

  • Make procedures and functions more versatile.

    • Different data can be manipulated each time the module is called.

  • Come in two types:

    • Actual

    • Formal

COP1000


Actual Parameters

  • Are substituted for the formal parameter at the time the procedure is called.

    • Parameters used in the call statement

      • Statements that transfer control to a procedure.

    • Data types must be assignment compatible with its corresponding formal parameter

      • If they don’t, your program will blow up!

    • Can be a variable, constant or an expression

    • Can be call-by-value or call-by-reference

COP1000


Formal Parameters

  • Is a list of “place marker” names used in the procedure’s declaration.

  • Parameters declared in the procedure header

  • Can include the data type of the valued parameters.

  • Must be a variable

  • Can be call-by-value or call-by-reference

COP1000


Parameter Correspondence Rules

  • Determined by position in respective parameter lists

  • Lists must be the same size, although the names may differ

  • Data Types of corresponding actual and formal parameters must be identical

COP1000


Formal Parameters

Actual Parameters

Var1

Var2

Num1

Num2

8.0

8.0

10.0

10.0

Local Variables

Sum Average

?

?

Data Areas After a Call

Main program data area Procedure data area

COP1000


Valued & Variable Parameters

  • By Reference (Call-by-Reference)

    • Passing a variable to a procedure is called passing an argument by reference, because a variable can be modified by a procedure and returned to the calling module.

    • You can use it AND you CAN change it!

  • By Value (Call-by-Value)

    • Passing a literal value (such as a string in quotation marks) to a procedure is called passing an argument by value, because a value cannot be modified by a procedure.

    • You can use it BUT you CAN’T change it!

COP1000


Call-by-Reference

  • The default for parameter passing

  • Gives access to the contents of the storage area where values are stored

  • Giving the called procedure the ability to directly access the caller’s data

  • Allowing changes in the data

COP1000


Call-by-Value

  • Protects the data being passed

  • Accomplished by creating a copy of the value

    • without affecting the original value of the variable

  • Thus…

    • Called procedure is unable to change the values stored in the variable’s storage area

  • Helps avoid Side Effects!

COP1000


Parameter Relationships

Call Statements

Actual Parameters

  • Valued

  • Variable

Parameter Interface using Global Variables

Procedure Header Parameters

Formal Parameters

Valued

Variable

COP1000


Another Look at Variables

Names & the Data Dictionary

COP1000


Variable Names-Reminder

  • Use mnemonic terms

    • Use a variable name that relates the name of the variable to its usage

  • Contributes to self-documenting code

    • Which reduces the amount of commenting required

    • Z = X * Y What is it doing (besides multiplication?)

    • SalesTax = SalesTaxRate * Cost (this you know)

  • Examples

    • SalesTax, SalesRate, Sales_Rate, PayRate, Temp

COP1000


The Data Dictionary

  • Defines all of the variables used within a program

  • Lists:

    • Item Name

    • Variable Names

    • Domain(range of possible values)

    • Data type

    • Location defined & accessed

    • Test Data (or error checking)

Required!

COP1000


DD Example

COP1000


The Three Logic Structures

  • Sequential

    • One statement follows another

  • Selection(Decision)

    • Allows choices based on the data

    • IfThenElse, Nested If’s, Case, Switch

  • Iteration (Looping or Repetition)

    • Allows statements to be repeated a specified number of times

    • While, Do, For, Do Until, Repeat

COP1000


Next?

Problem Solving

with Sequential Logic

COP1000


  • Login