Douglas College wordmark
Facebook logo Twitter logo Instagram logo Snapchat logo YouTube logo Wordpress logo

Registration for the Fall 2019 semester begins June 25.  Watch your email for more details.

back to search

Computer Programming I

Course Code: CMPT 1109
Faculty: Science & Technology
Department: Computing Science
Credits: 3.0
Semester: 15 Weeks
Learning Format: Lecture, Lab
Typically Offered: TBD. Contact Department Chair for more info.
course overview

This course provides an introduction to computing science and programming, intended for students with little or no programming background. Students will learn how to analyze problems and design algorithms as well as implement their solutions using a high-level programming language such as C++. Topics include structured programming fundamentals, control structures, procedural programming, recursion, arrays, basic sorting and searching algorithms, strings, pointers, dynamic memory allocation, files, exceptions, and an introduction to object-oriented programming.

Course Content

  • Introduction to computing systems and programming
    • Hardware and software
    • Programming languages, compilers, and interpreters
    • Software development cycle
    • Algorithm design and programming process
    • Programming errors and code debugging
    • Integrated Development Environments
  • Programming fundamentals
    • Basic data encoding and numeral systems
    • Primitive data types
    • Variables, literals, constants, and identifier naming conventions
    • Assignment operator
    • Basic I/O and output formatting
    • Expressions and arithmetic operators
    • Type casting
    • Comments and code documentation
  • Conditional and iterative constructs
    • Decision-making structures
    • Relational and logical operators
    • Repetition structures and loop design strategies 
    • Nested constructs
  • Procedural programming and functions
    • Problem solving and code modularization
    • Defining and calling a function
    • Local, global, and static local variables
    • Reference and constant reference variables
    • Passing parameters by value and by reference
    • Default arguments
    • Inline functions
    • Function overloading
    • Function abstraction
    • Unit and integration testing
    • Mathematical library functions
  • Recursion
    • Problem solving using recursion
    • Recursive vs iterative implementations
  • Arrays and C-Strings
    • Array basics
    • Arrays and static memory allocation
    • Passing and returning arrays to/from functions
    • Range-based for loop
    • Multi-dimensional arrays
    • Arrays of characters and C-Strings
    • C-String and character manipulation library functions
  • Sorting and searching algorithms
    • Basic sorting algorithms
    • Elementary searching algorithms
    • An introduction to the efficiency analysis of algorithms
  • Pointers and dynamic memory management
    • Pointer basics
    • Constant pointers and pointers to constant data
    • Arrays of pointers
    • Pointers as function parameters and return values
    • Dynamic memory allocation
  • An introduction to object-oriented programming
    • Procedural vs. object-oriented programming
    • Classes as abstract data types
    • Class design guidelines
    • Attributes and methods
    • Private vs public class members
    • Class constructors, destructors, and constructing objects
    • Setter and getter member functions
    • Arrays of objects
    • Pointer to objects and the this pointer
    • The string class
    • Structures and enumerated data types
  • File input and output
    • Text files vs. binary files
    • Sequential vs. random-access files
    • Basic file operations
  • Exceptions
    • Throwing an exception
    • Exception classes
    • Exception propagation
    • Rethrowing exceptions
    • Catching and handling exceptions

Methods of Instruction

Lectures, labs, and self-directed learning (programming assignments)

Means of Assessment

Evaluation will be carried out in accordance with Douglas College policy. The instructor will present a written course outline with specific evaluation criteria at the beginning of the semester. Evaluation will be based on the following.


10% - 20%
Assignments 10% - 20%
Quizzes 0% - 10%
Midterm Exam 25% - 35%
Final Examination 30% - 40%
Total 100%

** In order to pass the course, in addition to receiving an overall course grade of 50%, students must achieve a grade of at least 50% on the combined weighted examination components (including quizzes, midterm and final examinations.)

Learning Outcomes

Upon the completion of this course, successful students will be able to:

  • Explain the major components of a computer system, different types of programming languages, and related terminology
  • Comprehend numeral systems and data representation in memory
  • Design algorithms for small problems and discuss the program development process
  • Identify code quality factors and use them to create high-quality programs
  • Develop simple programs involving the fundamental programming constructs: variables, expressions, operators, basic I/O, and control structures
  • Analyze, test, and debug programs for syntax, logic, and run-time errors
  • Apply consistent documentation and program style standards to create readable and maintainable software
  • Explain the importance of modularization in programming
  • Comprehend procedural programming to break up a program into functions
  • Use and compare different methods of passing parameters to a function
  • Write programs that use advanced data structures like arrays, structs, strings, enumerated data types
  • Discuss and implement basic sorting and searching algorithms
  • Identify divide-and-conquer algorithms, implement recursive functions, and compare recursive and iterative functions
  • Describe the concept of dynamic memory allocation and compare it with the method of static memory allocation
  • Explain the concept of pointers and use them to manage dynamic data structures in a program
  • Use basic file I/O to write programs that store and retrieve data to/from files
  • Comprehend runtime errors to throw and handle exceptions appropriately

course prerequisites

Minimum C grade in Pre-Calculus 11 or Foundations of Math 11, or minimum C- grade in MATU 0411


Not Specified


Note: Students who have received credit for CMPT 1110 will not receive further credit by taking CMPT 1109.

curriculum guidelines

Course Guidelines for previous years are viewable by selecting the version desired. If you took this course and do not see a listing for the starting semester/year of the course, consider the previous version as the applicable version.

course schedule and availability
course transferability

Below shows how this course and its credits transfer within the BC transfer system. 

A course is considered university-transferable (UT) if it transfers to at least one of the five research universities in British Columbia: University of British Columbia; University of British Columbia-Okanagan; Simon Fraser University; University of Victoria; and the University of Northern British Columbia.

For more information on transfer visit the BC Transfer Guide and BCCAT websites.


If your course prerequisites indicate that you need an assessment, please see our Assessment page for more information.