CH2 Key Terms: Programming Logic & Design - Python

Abstraction

The process of paying attention to important properties while ignoring nonessential details.

Alphanumeric Values

The set of values that includes alphabetic characters, numbers, and punctuation.

Annotation Symbol

A flowchart symbol used to hold comments; it is most often represented by a three-sided box connected with a dashed line to the step it explains.

Assignment operator (=)

The operator that assigns a value to a memory location on its left side; the equal sign.

Assignment statement

A statement that stores a value on its right side to the named location on its left side.

Binary operator

An operator that requires two operands — one on each side.

Call a module

To use a module’s name to invoke it, causing it to execute.

Camel Casing

A naming convention in which the initial letter is lowercase, multiple-word names are run together, and each new word within the name begins with an uppercase letter.

Data dictionary

A list of every variable name used in a program, along with its type, size, and description.

Data type

The characteristic of a program value; a variable or constant’s data type describes the kind of values it can hold and types of operations that can be performed with it.

Declaration

A statement that names a variable and its data type.

Detail loop tasks

The steps that are repeated for each set of input data.

Echoing input

The act of repeating input back to a user either in a subsequent prompt or in output.

Encapsulation

The technique of containing program elements within a module.

End-of-job tasks

The steps at the end of a program to finish an application.

External documentation

All of the external material that programmers develop to support a program.

Floating-point values

Numeric values that contain decimal points.

Function

A program unit that contains a series of statements that carry out a task.

(Similar but different to method, procedure, and subroutine)

Functional cohesion

The extent to which all operations in a method contribute to the performance of only one task.

Functional Decomposition

The act of reducing a large program into more manageable modules.

Garbage

Describes the unknown value stored in an unassigned variable.

Global

describes variables that are known to an entire program.

Housekeeping tasks

Tasks that must be performed at the beginning of a program to prepare for the rest of the program.

Hungarian notation

A naming convention that stores a data type or other information as a part of a name.

Identifier

A program component’s name.

In scope

The characteristic of variables and constants that describes the extent to which they are available for use.

Initializing a variable

The act of assigning the first value to a variable, often at the same time that the variable is created.

Integer values

Numeric whole number values without decimal points.

Internal documentation

Documentation within a program.

Kebob case

A term sometimes used to describe the name convention in which dashes separate parts of a name.

Keywords

The limited words set that is reserved in a language.

Left-to-right associativity

Describes operators that evaluate the expression to the left first.

Literal numeric constant

A number without an identifier.

Literal string constant

A group of characters enclosed without quotation marks.

Local

Describes variables that are declared within the method that uses them.

Lower camel casing

A naming convention in which the initial letter is lowercase, multiple-word names are run together, and each new word within the name begins with an uppercase letter.

Ivalue

The memory address identifier to the left of an assignment operator.

Magic number

An unnamed numeric constant whose purpose is not immediately apparent.

Main program

A program that runs from start to stop and often calls other modules.

Mainline Logic

The overall logic in a program’s main module.

Method

A program unit that contains a series of statements that carries out a task.

(Similar to function, procedure, and subroutine)

Mixed case with underscore

A naming convention similar to snake casing, in which words are separated by underscores, but new words start with an uppercase latter.

Modularization

The process of breaking down a program into modules.

Module

A program unit that contains a series of statements that carry out a task.

(Similar but different to function, method, and subroutine.)

Module body

The part of a module that contains all of these statements.

Module header

The part of a module that includes the module identifier and, possibly, other necessary identifying information.

Module return statement

The part of a module that marks its end and identifies the point at which control returns to the program or module that called the module.

Named constant

A named memory location whose value never changes after the assignment; conventionally, constants are named using all capital letters.

Numeric

Describes data that consists of numbers and with which numeric operations can be performed.

Numeric Constant

A number without an identifier.

Numerical variable

A variable that holds numeric values.

Operand

A value used by an operator.

Order of operations

Rules that dictate the order in which operations in the same statement are carried out.

Overhead

All the resources and time required by an operation.

Pascal casing

A naming convention in which the initial letter is uppercase, multiple-word names are run together, and each new word within the name begins with an uppercase letter.

Portable

Describes a module that can easily be reused in multiple programs.

Procedure

A program unit that contains a series of statements that carry out a task.

(Similar but different to function, method, module, and subroutine).

Program Comments

Nonexecuting statements placed within code to explain program statements in English.

Program Hierarchy chart

A diagram that illustrates program module’s relationship to each other.

Prompt

A message that displayed on a screen, asking the user for a response.

Real number

Floating-point numbers; numbers that contain a decimal point.

Reliability

The feature of a program or module that ensures that it has been tested and proven to function correctly.

Remainder Operator

An arithmetic operator that provides the remainder after values are divided.

Reusability

The feature of a module that allows it to be used in a variety of applications.

Right-associativity.

Describes operators that evaluate the expression to the right first.

(Also called Right-to-left associativity)

Right to left associativity

Describes operators that evaluate the expression to the right first.

(Also called Right associativity)

Rules of precedence

Rules that dictate the order in which operations in the same statement are carried out.

Self-documenting

Describes programs that contain meaningful and descriptive identifiers.

Snake casing

A naming convention in which parts of a name are separated by underscores.

Stack

A memory location that holds the memory addresses to which a program’s logic should return after a method executes.

String

Describes data that is nonnumeric.

String constant

A group of characters enclosed within quotation marks.

String variable

A variable that can hold text that includes letters, digits, and special characters, such as punctuation marks.

Subroutine

A program unit that contains a series that carry out a task.

(Similar but different to function, method, module, and procedure)

Temporary Variable

A variable that holds intermediate results during a program’s execution.

Type-safety

The feature of programming language that prevents assigning values of an incorrect data type.

Unnamed constant

A literal value

Unnamed numerical constant

A literal numeric value.

Unnamed string constant

A literal string value.

Upper camel casing

Another name for the Pascal casing naming convention.

Visible

A characteristic of data items that means they “can be seen” only within the method in which they are declared.

Work Variable

A variable that holds intermediate results during a program’s execution.