Discipline: Computer Information Systems
CSC-Computer Science
 Degree Credit  [X]
Non Credit  [ ]
Nondegree Credit  [ ]
Comm Service  [ ]
 

Riverside Community College District
Integrated Course Outline of Record


Computer Information Systems 17A


College: R_X_ M_X_ N_X_
CIS-17A: Programming Concepts and Methodology II: C++
Same as: CSC- 17A
 Lecture Hours: 54
Lab Hours: 18
Units: 3.00
 
COURSE DESCRIPTION
Prerequisite(s): CIS 5: Programming Concepts and Methodology I:C++ or CSC 5: Programming Concepts and Methodology I: C++
The application of software engineering techniques to the design and development of large programs; data abstraction, structures, and associated algorithms. A comprehensive study of the syntax and semantics of the C++ language and the methodology of Object-Oriented program development. 54 hours lecture and 18 hours laboratory. (TBA option)
 
SHORT DESCRIPTION FOR CLASS SCHEDULE
Object-Oriented program development using C++. (Same as CSC-17A)
 
ENTRY SKILLS
Before entering the course, students will be able to:
  1. Write C++ functions and understanding the differences between pass by value and pass by reference.
    • CIS 5 - Create computer programs using the principles of structured programming and demonstrate the use of an IDE with appropriate libraries.  Design, implement, test, and debug programs that use fundamental programming constructs:  basic computation, simple I/O, standard conditional and iterative structures, and functions.

  2. Use C++ array structures for 1 and 2 dimensional problem solutions.
    • CIS 5 - Describe the principles of structured programming and be able to design, implement and test structured programs.

  3. Create procedural and structured computer programs in C++.
    • CIS 5 - Use pseudocode, flowcharts, and a programming language to implement, test, and debug algorithms for solving problems.  Identify the information requirements, synthesize the algorithmic steps needed to transform the data input into the required output information, and organize the output format to facilitate user communication.
    • CIS 5 - Apply the principles of logical and programming concepts to develop solutions for gaming, business, scientific and mathematical problems.
    • CIS 5 - Create computer programs using the principles of structured programming and demonstrate the use of an IDE with appropriate libraries.  Design, implement, test, and debug programs that use fundamental programming constructs:  basic computation, simple I/O, standard conditional and iterative structures, and functions.
    • CIS 5 -  Demonstrate different forms of binding, visibility, scoping, and lifetime management.

  4. Develop specific solutions for gaming, business, scientific and mathematics problems.
    • CIS 5 - Describe the software development life-cycle
    • CIS 5 - Apply the principles of logical and programming concepts to develop solutions for gaming, business, scientific and mathematical problems.
    • CIS 5 - Create computer programs using the principles of structured programming and demonstrate the use of an IDE with appropriate libraries.  Design, implement, test, and debug programs that use fundamental programming constructs:  basic computation, simple I/O, standard conditional and iterative structures, and functions.
    • CIS 5 - Use pseudocode, flowcharts, and a programming language to implement, test, and debug algorithms for solving problems.  Identify the information requirements, synthesize the algorithmic steps needed to transform the data input into the required output information, and organize the output format to facilitate user communication.

  5. Transform data input into the required output with algorithmic procedures.
    • CIS 5 - Describe the principles of structured programming and be able to design, implement and test structured programs.
    • CIS 5 - Apply the principles of logical and programming concepts to develop solutions for gaming, business, scientific and mathematical problems.
    • CIS 5 - Explain what an algorithm is and its importance in computer programming.

  6. Demonstrate the use of a C++ IDE and libraries.
    • CIS 5 - Create computer programs using the principles of structured programming and demonstrate the use of an IDE with appropriate libraries.  Design, implement, test, and debug programs that use fundamental programming constructs:  basic computation, simple I/O, standard conditional and iterative structures, and functions.
STUDENT LEARNING OUTCOMES
 Upon successful completion of the course, students should be able to:

Write programs that use each of the following data structures: arrays, records, strings, linked lists, stacks, queues, and hash tables.

  1. Breadth of Knowledge - Use the symbols and vocabulary of mathematics to solve problems and communicate the results
  2. Information Skills - Locate, evaluate and use information effectively
  3. Critical Thinking - Analyze and solve complex problems across a range of academic and everyday contexts

Implement, test, and debug simple recursive functions and procedures.

  1. Critical Thinking - Analyze and solve complex problems across a range of academic and everyday contexts
  2. Information Skills - Locate, evaluate and use information effectively
  3. Breadth of Knowledge - Use the symbols and vocabulary of mathematics to solve problems and communicate the results

Evaluate tradeoffs in lifetime management (reference counting vs. garbage collection).

  1. Breadth of Knowledge - Use the symbols and vocabulary of mathematics to solve problems and communicate the results
  2. Information Skills - Locate, evaluate and use information effectively
  3. Critical Thinking - Analyze and solve complex problems across a range of academic and everyday contexts

Explain how abstraction mechanisms support the creation of reusable software components.

  1. Critical Thinking - Analyze and solve complex problems across a range of academic and everyday contexts
  2. Information Skills - Locate, evaluate and use information effectively
  3. Communication Skills - Speak with precision and clarity to express complex thought

Design, implement, test, and debug simple programs in an object-oriented programming language.

  1. Critical Thinking - Construct sound arguments and evaluate arguments of others
  2. Communication Skills - Speak with precision and clarity to express complex thought
  3. Information Skills - Locate, evaluate and use information effectively

Discuss the properties of good software design.  Compare and contrast object-oriented analysis and design with structured analysis and design.

  1. Critical Thinking - Construct sound arguments and evaluate arguments of others
 
COURSE CONTENT
  1. Fundamental Data Structures:
    1. write programs that use each of the following data structures: such as arrays, records, strings, linked lists, stacks, queues, and hash tables,  
    2. discuss the representation and use of primitive data types and built-in data structures
    3. describe how arrays, stacks, queues, trees, and hash tables are allocated and used in memory
    4. describe common applications for each data structure,
    5. compare alternative implementations of data structures with respect to performance,
    6. compare and contrast the costs and benefits of dynamic and static data structure implementations, and
    7. choose the appropriate data structure for modeling a given problem. 
      1. The coverage of the fundamental data structures shall include the following:
        1. Primitive types
        2. Arrays
        3. Records
        4. Strings and string processing
        5. Data representation in memory
        6. Static, stack, and heap allocation
        7. Runtime storage management
        8. Pointers and references
        9. Linked structures
        10. Implementation strategies for stacks, queues, and hash tables
        11. Implementation strategies for trees
        12. Strategies for choosing the right data structure
  2. Recursion:
    1. implement, test, and debug simple recursive functions and procedures
    2. describe the concept of recursion and give examples of its use,
    3. identify the base case and the general case of a recursively defined problem,
    4. compare iterative and recursive solutions for elementary problems such as factorial,
    5. describe the divide-and-conquer approach,
    6. describe how recursion can be implemented using a stack,
    7. discuss problems for which backtracking is an appropriate solution, and
    8. determine when a recursive solution is appropriate for a problem. 
      1. The coverage of recursion shall include the following:
        1. The concept of recursion
        2. Recursive mathematical functions
        3. Simple recursive procedures
        4. Divide-and-conquer strategies
        5. Recursive backtracking
        6. Implementation of recursion
  3. Declarations and Types:
    1. evaluate tradeoffs in lifetime management (reference counting vs. garbage collection), 
    2. explain the value of declaration models, especially with respect to programming-in the-large,
    3. identify and describe the properties of a variable such as its associated address, value, scope, persistence, and size,
    4. discuss type incompatibility,
    5. demonstrate different forms of binding, visibility, scoping, and lifetime management, and
    6. defend the importance of types and type-checking in providing abstraction and safety. 
      1. The declaration and types shall include the following:
        1. The conception of types as a set of values together with a set of operations
        2. Declaration models (binding, visibility, scope, and lifetime)
        3. Overview of type-checking
        4. Garbage collection
  4. Abstraction Mechanisms:
    1. explain how abstraction mechanisms support the creation of reusable software components,
    2. demonstrate the difference between call-by-value and call-by-reference parameter passing,
    3. defend the importance of abstractions, especially with respect to programming-in-the-large, and
    4. describe how the computer system uses activation records to manage program modules and their data. 
      1. Abstraction mechanisms shall include the following concepts:
        1. Procedures, functions, and iterators as abstraction mechanisms
        2. Parametrization mechanisms (reference vs. value)
        3. Activation records and storage management
        4. Type parameters and parametrized types - templates or generics
        5. Modules in programming languages
  5. Software Design:
    1. design, implement, test, and debug simple programs in an object-oriented programming language,
    2. compare and contrast object-oriented analysis and design with structured analysis and design,
    3. compare and contrast the notions of overloading and overriding methods in an object-oriented language,
    4. justify the philosophy of object-oriented design and the concepts of encapsulation, abstraction, inheritance, and polymorphism,
    5. describe how the class mechanism supports encapsulation and information hiding,
    6. design, implement, and test the implementation of “is-a” relationships among objects using a class hierarchy and inheritance,
    7. explain the relationship between the static structure of the class and the dynamic structure of the instances of the class, and
    8. describe how iterators access the elements of a container. 
      1. Software design concepts shall include the following:
        1. Fundamental design concepts and principles
        2. Design strategy
  6. Object Oriented Programming:
    1. justify the philosophy of object-oriented design and the concepts of encapsulation, abstraction, inheritance, and polymorphism,
    2. design, implement, test, and debug programs in an object-oriented programming language,
    3. describe how the class mechanism supports encapsulation and information hiding,
    4. design, implement and test the is-a relationships among objects using a class hierarchy and inheritance,
    5. compare and contrast the notions of overloading and overriding methods in an object-oriented language,
    6. explain the relationship between the static structure of the class and the dynamic structure of the instances of the class, and
    7. describe how iterators access the elements of a container. 
      1. OOP concepts shall include the following:
        1. Object-oriented design
        2. Encapsulation and information-hiding
        3. Separation of behavior and implementation
        4. Classes and subclasses
        5. Inheritance (overriding, dynamic dispatch)
        6. Polymorphism (subtype polymorphism vs. inheritance)
        7. Class hierarchies
        8. Collection classes and iteration protocols
        9. Internal representations of objects and method tables
  7. Classes and members
    1. Creating classes with Declaration and Implementation Sections
      1. Encapsulating Class Components
      2. Designing Classes
      3. Implementing Class Functions
    2. Data Hiding and Encapsulations
      1. Using Public Functions to Alter Private Data
    3. Using Private functions
    4. Considering Scope When Defining Member Functions
    5. Using Static Class Members
      1. Defining Static Data Members
      2. Using Static Functions
    6. Understanding the this Pointer
      1. Using the this Pointer Explicitly
      2. Using the Pointer-to Member Operator
    7. Understanding Polymorphism
  8. Class Features and Design Issues
    1. Using member functions
    2. Understanding Constructors
      1. Writing Constructors
      2. Overriding the constructor’s default Arguments
      3. Overloading Constructors
    3. Using Destructors
    4. Using Classes Within Classes
      1. Considering Reusability and Maintenance Issues
      2. Using #ifndef, #define, and #endif
    5. Improving Functions
      1. Selecting Member Data and Function Names
      2. Reducing Coupling Between Functions
      3. Increasing Cohesion Within a Function
  9. Friends
    1. How to Declare a Function as a friend
    2. Using a friend Function to Access Data from Two Classes
    3. Using a Forward Reference
    4. Making a friend of a Member of Another Class
    5. Making a friend of Another Class
  10. Overloading Operators
    1. Using Operators Polymorphically
    2. Overloading Math Operators
    3. Overloading Operators to work with Class Objects
    4. Overloading Input
    5. Overloading Output
  11. Inheritance
    1. Understanding the Advantages Provided by Inheritance
    2. Creating a Derived Class
    3. Inheritance Restrictions
    4. Choosing the Class Access Specifier
    5. Overriding and Overloading Parent Class Functions
    6. Using Constructor Initialization Lists
    7. Providing for Base Class Construction
    8. Overriding Inherited Access
    9. Using Multiple Inheritance
    10. Using Virtual Base Classes
  12. Advanced Input and Output
    1. Using istream and ostream Member Functions
    2. Creating Manipulator Functions
    3. Using Built-in Manipulators
    4. Writing and Reading Objects
  13. Templates
    1. Understanding the Usefulness of Function Templates
    2. Creating Function templates
    3. Using Multiple Arguments to Function Templates
    4. Overloading Function Templates
    5. Using More than one Parametrized Type in a Function Template
    6. Explicitly Specifying the Type in a Function Template
    7. Using Function Templates with Class Objects
    8. Using Template Classes
    9. Creating a Complete Class Template
    10. Using Container Classes
  14. Handling Exceptions
    1. Throwing and Catching Exceptions
    2. Throwing Objects
    3. Using the Default Exception Handler
    4. Using Exception Specifications
    5. Handling Memory Allocation Exceptions
 
METHODS OF INSTRUCTION
 Methods of instruction used to achieve student learning outcomes may include, but are not limited to:

  • Presentation of class lectures/discussions/demonstrations in order to clarify object oriented programming, computer problem solving, and software design concepts.
  • Presentation of class lectures/discussions/demonstrations in order to clarify the principles of object oriented programming.
  • Web-based/web-enhanced/online/distance learning tasks/activities to reinforce understanding of concepts related to object oriented programming skills, computer problem solving, and software design.
  • Online and Laboratory activities and application assignments in order to address areas of improvement in object oriented programming, computer problem solving, and software design.
  • Projects in order to facilitate and demonstrate the acquisition of skills required to create object oriented programs.
  • Collaborative projects/cooperative learning tasks in order to encourage students to develop and apply object oriented programming, computer problem solving, software design, and team work skills.
 
METHODS OF EVALUATION
 Students will be evaluated for progress in and/or mastery of learning outcomes by methods of evaluation which may include, but are not limited to:

  • Computer programs designed to demonstrate the acquisition of object oriented programming, computer problem solving, and software design concepts and skills.
  • Quizzes/examinations designed to measure students’ degree of mastery of fundamental object oriented programming and software design concepts and terminology.
  • Collaborative projects designed to demonstrate successful understanding and application of object oriented programming, computer problem solving, software design, and team work skills.
  • Computer Laboratory assignments/projects designed to clarify students’ individual object oriented programming, computer problem solving, software design strengths and areas of improvement related to these skills.
  • Final examination designed to evaluate students’ overall achievement of course objectives in object oriented programming, computer problem solving, and software design concepts.
SAMPLE ASSIGNMENTS

Outside-of-Class Reading Assignments
  • The primary assignments for this course involve the creation of programs using C++. To support that, students will be assigned textbook reading and/or other resource reading that covers programming concepts and demonstrates usage of C++.

Outside-of-Class Writing Assignments
  • Assignments for this course involve writing C++ programming statements to form complete programs that carry out specific tasks.
  • Students will also be asked to document their work with written explanations that clarify their programming code.

Other Outside-of-Class Assignments
  • The primary assignments for this course involve the creation of programs using C++.
 
COURSE MATERIALS
 All materials used in this course will be periodically reviewed to ensure that they are appropriate for college level instruction. Possible texts include:

  • Deitel, H. M. and P. J. Deitel. C++ How to Program . 8th ed. Prentice Hall, 2011.
  • Farrell, Joyce. Object-Oriented Programming Using C++ . 4th ed. Cambridge, MA: Course Technology, 2008.
  • Gaddis, Tony. Staring Out With C++ . 7th ed. Pearson Education, 2011.
  • Cygwin. http://www.cygwin.com/, 1.7.9 ed.
  • Bloodshed. http://www.bloodshed.net/devcpp.html, 5th ed.
  • Netbeans. http://netbeans.org/, 7th ed.
01/22/2013
4812