CTSPlanner
Sign-in not configured
← Computing Science

CSE2110 Procedural Programming 1

Intermediate · 1 credit · BIT - Business, Admin, Finance and IT

Description
Students develop their understanding of the procedural programming paradigm. They move from a structured programming approach in which modules were handled through the use of program blocks to a more formal modular programming approach in which they are handled through subprograms. In the process, students also learn to use a number of new design approaches made possible by the new paradigms. As part of this process, they also learn what types of problems are amenable to modular algorithms and programs.
Prerequisite
CSE1120: Structured Programming 2
Parameters
Access to appropriate computer equipment, software, support materials, the Internet and a programming environment that encourages modular programming through the use of subprograms.
Supporting courses
CSE2010: Computer Science 2 CSE2120: Data Structures 1 CSE2130: Files & File Structures 1, and/or any Intermediate project course involving imperative programming

Outcomes The student will:

  • 1 demonstrate an understanding of modular programming

    • 1.1 describe the advantages of programming with modules or subroutines including:

      • 1.1.1 reducing the duplication of code in a program

      • 1.1.2 enabling the reuse of code in more than one program

      • 1.1.3 decomposing complex problems into simpler pieces to improve maintainability and extendibility

      • 1.1.4 improving the readability of a program

      • 1.1.5 hiding or protecting the program data

    • 1.2 select a programming environment and describe how it supports procedural programming including:

      • 1.2.1 the type of subprograms supported; e.g., procedures, functions, methods

      • 1.2.2 the level or type of modularity provided

      • 1.2.3 the level of protection provided from unwanted side-effects

  • 2 demonstrate basic procedural programming skills by writing algorithms employing a modular approach to solve problems

    • 2.1 analyze a data processing problem and use a top-down design approach to decompose it into discreet input, processing and output modules

    • 2.2 analyze and refine modules into submodules that are a manageable size for each process; e.g., input submodules, processing submodules and output submodules

    • 2.3 describe and represent, using pseudocode or an appropriate diagramming approach, the relationship among the modules

    • 2.4 analyze and rewrite algorithms for each module identifying the pre- and post-conditions and required program control of flow mechanisms.

    • 2.5 analyze and evaluate algorithms for each developing module with appropriate data and revise, as required

  • 3 translate algorithms into source code, convert the source code into machine executable form, execute and debug, as required

    • 3.1 convert an algorithm into a program of linked subprograms with a main or client module calling other modules in a manner that reflects the structure of the algorithm

    • 3.2 use appropriate types of subprograms to implement the various sections of the algorithm; e.g., functions (subprograms that return a value) and procedures (subprograms that do not return a value)

    • 3.3 analyze and determine the type of scope required to protect and/or hide data and keep implementation decoupled from the calling modules and to avoid unwanted side-effects with consideration to:

      • 3.3.1 use of appropriate parameters for importing and exporting data to and from subprograms

      • 3.3.2 use of local variables and nested subprograms to enhance cohesion

      • 3.3.3 one- and two-way parameter passing for importing and exporting data to and from subprograms

    • 3.4 analyze for, and maintain, an appropriate balance between the coupling or dependency and cohesion or focus of subprograms

    • 3.5 create both internal and external documentation

    • 3.6 analyze the program and eliminate syntax, run-time and logic errors by using appropriate test data for each programming task at each stage of development

  • 4 compare the results of the program with the intent of the algorithm and modify, as required

    • 4.1 use appropriate error trapping mechanisms built into the programming environment, as well as programmer-directed error-trapping techniques, to eliminate logic errors and debug the program

    • 4.2 compare the congruency between the outcomes of the debugged program and the original intent of the algorithm and modify, as required

  • 5 demonstrate basic competencies

    • 5.1 demonstrate fundamental skills to:

      • 5.1.1 communicate

      • 5.1.2 manage information

      • 5.1.3 use numbers

      • 5.1.4 think and solve problems

    • 5.2 demonstrate personal management skills to:

      • 5.2.1 demonstrate positive attitudes and behaviours

      • 5.2.2 be responsible

      • 5.2.3 be adaptable

      • 5.2.4 learn continuously

      • 5.2.5 work safely

    • 5.3 demonstrate teamwork skills to:

      • 5.3.1 work with others

      • 5.3.2 participate in projects and tasks

  • 6 identify possible life roles related to the skills and content of this cluster

    • 6.1 recognize and then analyze the opportunities and barriers in the immediate environment

    • 6.2 identify potential resources to minimize barriers and maximize opportunities

Program of Studies 2009. Source document, © Alberta Education.