Programming Modules Quiz

Programming Logic and Design - Chapter 5: Modules

• Modules are groups of statements designed for specific tasks in a program
• Complex programs are effectively broken down into smaller subtasks (divide and conquer)
• This simplification enhances code readability and manageability.

Learning Objectives

• 5.1 Introduction: Overview of modules
• 5.2 Defining and Calling a Module: Defining and invoking modules
• 5.3 Local Variables: Scope and usage of local variables
• 5.4 Passing Arguments to Modules: Passing data between modules
• 5.5 Global Variables and Global Constants: Introduction to global variables/constants
• 5.6 Focus on Languages (Java, Python, C++): Implementation details in various languages

5.1 Introduction (1 of 2)

• A module is a segment of code for accomplishing specific tasks
• Large programs are divided into smaller modules to boost readability, testing, and reusability

5.1 Introduction (2 of 2)

• Using modules improves code clarity
• Modules are reusable and simplify testing.
• Modules facilitate teamwork by dividing tasks

5.2 Defining and Calling a Module (1 of 7)

• Module definition: the code that forms a module

• Example module (showMessage()):

  • Module showMessage()
  • Display "Hello world."
  • End Module

• To run the module: call it as a statement within the program.

  • Call showMessage()

5.2 Defining and Calling a Module (2 of 7)

• Module names should be clearly descriptive
• No spaces or punctuation marks in module names.
• Cannot start with a number

5.2 Defining and Calling a Module (3 of 7)

• Module Definitions consists two parts:
  • Header: starting point of module
  • Body: statements within module

5.2 Defining and Calling a Module (4 of 7)

• To carry out statements within the module, a call has to be made to the module.
• Program execution starts at main module

5.2 Defining and Calling a Module (5 of 7)

• Flowcharting programs with modules illustrates each module separately.
• Modules are depicted in a flow chart separately to improve visualization.

5.2 Defining and Calling a Module (6 of 7)

• Top-down design is a step:by-step approach to create algorithms into modules.
• Subtasks are identified and broken down.
• Subtasks are then converted to coded modules.

5.2 Defining and Calling a Module (7 of 7)

• A hierarchy chart visualizes the relationships between different modules in a program
• Hierarchy charts abstract away program details, focusing on module interactions

5.3 Local Variables (1 of 3)

• Local Variables: declared within a module and not accessible from outside the module.

5.3 Local Variables (2 of 3)

• Variable scope: the part of the program where a variable is accessible.

5.3 Local Variables (3 of 3)

• Duplicate variable names (in same scope): cannot have duplicate local variable names
• Variables in different scopes can have same names (e.g. different modules).

5.4 Passing Arguments to Modules (1 of 3)

• Arguments are data values sent to a module during a call
• Parameters are variables that receive arguments

5.4 Passing Arguments to Modules (2 of 3)

• Argument and parameter data types should be compatible

5.4 Passing Arguments to Modules (3 of 3)

• Multiple arguments can be sequentially passed into a module.
• Passing arguments by value/reference

5.5 Global Variables & Global Constants (1 of 2)

• Global variables are accessible from any module in a program.
• Avoid using global variables for better program structure and modularity. - They can lead to unintended side effects.

5.5 Global Variables & Global Constants (2 of 2)

• Global constants: named constants available to all modules.
• Global constants are preferable over global variables due to immutability.

5.6 Focus on Languages: Java (1 of 9)

• In Java, modules are known as methods
• Method definitions include:
  • Header: specifies method name
  • Body: statements executed when method is called

5.6 Focus on Languages: Java (2 of 9)

• Method calls cause the program to jump to and execute statements within the method's body

5.6 Focus on Languages: Java (3 of 9)

• Local Variables: declared and accessible only within scope of method

5.6 Focus on Languages: Java (4 of 9)

• Passing arguments to methods: use parameter variables in the method header

5.6 Focus on Languages: Java (5 of 9)

• Passing arguments to methods (continued)

5.6 Focus on Languages: Java (6 of 9)

• Passing multiple arguments to Java methods

5.6 Focus on Languages: Java (7 of 9)

• Arguments in Java methods are passed by value

5.6 Focus on Languages: Java (8 of 9)

• Global constants in Java are declared outside method

5.6 Focus on Languages: Java (9 of 9)

• Global constants in Java are accessible to methods within class.

5.6 Focus on Languages: Python (1 of 10)

• Functions in Python are used for modularizing code
• Define functions using the def keyword
• Function definitions consist of: header and body

5.6 Focus on Languages: Python (2 of 10)

• Calls executed by function names.

5.6 Focus on Languages: Python (3 of 10)

• Indentation is crucial in Python for code blocks

5.6 Focus on Languages: Python (4 of 10)

• Local variables are accessible only within functions.

5.6 Focus on Languages: Python (5 of 10)

• Passing arguments to Python functions: parameter variables must match data type

5.6 Focus on Languages: Python (6 of 10)

• Passing multiple arguments to functions

5.6 Focus on Languages: Python (7 of 10)

• Arguments in Python functions are passed by value

5.6 Focus on Languages: Python (8 of 10)

• Global variables defined outside functions

5.6 Focus on Languages: Python (9 of 10)

• Global variables accessed in any function.

5.6 Focus on Languages: Python (10 of 10)

• Python does not support true global constants, global variables can simulate

5.6 Focus on Languages: C++(1 of 8)

• Functions are used for modular code in C++
• Function definitions include a header (specifying the function name) and a body (statements).

5.6 Focus on Languages: C++ (2 of 8)

• Function calls cause program execution to transfer to function; execution continues in that function; then back to main

5.6 Focus on Languages: C++ (3 of 8)

• Local variables are accessible only inside functions

5.6 Focus on Languages: C++ (4 of 8)

• Passing arguments to C++ functions: parameter variables need matching data type.

5.6 Focus on Languages: C++ (5 of 8)

• Passing multiple arguments to functions.

5.6 Focus on Languages: C++ (6 of 8)

• Arguments are passed by value in C++ functions.

5.6 Focus on Languages: C++ (7 of 8)

• Reference variables in C++ enable modification of a variable, the value is directly passed.

5.6 Focus on Languages: C++ (8 of 8)

• Global variables are accessible in any function. Global constants (declared outside functions) are accessible to all functions in a program.