CS5001: Intensive Foundations of CS Course Charter

Introduction

CS5001 is an introduction to computing and programming. The course is meant to introduce the basic rules of computation and the principles of systematic problem solving through programming.

The aim of this document is to lay out the objectives and outcomes for CS5001.

Example Course Page (PDF)

Goals

The course serves as the first programming course in the Align program that focuses on program design. Align students vary in their computing background. The course aims to provide a more uniform computing background for each student by introducing the student to programming and program design and/or by augmenting (and sometimes correcting) students’ pre-existing knowledge in the field.

Specifically:

Experience with problem solving through programming. Get comfortable with reading, understanding and analyzing fairly detailed problem statements. Decompose and propose a solution. Code the proposed solution. Test, debug, iterate.

Experience with elementary data structures and algorithmic techniques. Gain exposure to and practice with elementary data structures as well as algorithmic techniques. Begin to understand the consequences (time and space implications) of different algorithms and implementations.

High-Level Learning Objectives

The course’s outcomes are captured in the following list of high-level learning objectives.

  1. Write correct and clearly documented small- to medium-sized programs that others can read, understand, and modify.
  2. Read one’s own and others’ code; trace execution; determine functionality of short segments of code.
  3. Break large problems into an appropriate design for implementation.
  4. Use generalization for data and functions to limit code duplication.
  5. Select appropriate data types to represent information.
  6. Develop tests to exercise implemented code and appreciate the importance of good testing in the software development process.
  7. Appreciate the impact of data structure and algorithm choice on the running time and storage space needed to run a program.
  8. Be familiar with common library classes; use objects and methods.

Implementation Details

The programming language used in this course is Python. Languages used in other Align bridge courses include Java (in CS5004: Object Oriented Design) and C (in CS5007: Systems, as well as CS5006: Algorithms). The choice of Python in 5001 is due to its accepted utility in industry, as well as its C-like syntax, which should allow students to more easily move among the languages used in the bridge.

The course evaluates students through

  1. Weekly programming assignments. Toward the end of the term, it is helpful to run a multi-week assignment (or a large assignment with weekly deliverables) that gives students the experience of working on a larger project.
  2. Weekly lab sessions.
  3. Exams. There are typically 2 exams, midterm and final.

Topics and Learning Outcomes

Note that the topics and learning outcomes are the minimum to be achieved in CS5001. Faculty may choose to present additional material or cover a topic in greater depth. The order of topics here does not imply an ordering for the course itself. Faculty are encouraged to develop syllabi that complement their teaching style. Faculty are also encouraged to share syllabi and other materials with each other.

A note on levels of mastery, which are taken from CS2013 (see cs2013.org): For levels of mastery, CS2013 takes inspiration from (but does not directly follow) Bloom’s Taxonomy. CS2013 defines three levels:

  • Familiarity: The student understands what a concept is or what it means. This level of mastery concerns a basic awareness of a concept as opposed to expecting real facility with its application. It provides an answer to the question “What do you know about this?”
  • Usage: The student is able to use or apply a concept in a concrete way. Using a concept may include, for example, appropriately using a specific concept in a program, using a particular proof technique, or performing a particular analysis. It provides an answer to the question “What do you know how to do?”
  • Assessment: The student is able to consider a concept from multiple viewpoints and/or justify the selection of a particular approach to solve a problem. This level of mastery implies more than using a concept; it involves the ability to select an appropriate approach from understood alternatives. It provides an answer to the question “Why would you do that?”

Note that course topics appear in regular font.  Learning outcomes appear in italics.

Also note that some learning outcomes apply to many course topics. More specific learning outcomes appear with their respective topics.

Course Topics Learning Outcomes
Basic syntax and semantics of a higher-level language
  • Expressions and assignments
  • Simple I/O
  • Functions and parameter passing
  • Model a problem solution as an algorithm. [Usage]
  • Use a programming language to implement, test, and debug algorithms for solving simple problems. [Usage]
  • Design, implement, test, and debug a program that uses each of the following fundamental programming constructs: basic computation, simple I/O, standard conditional and iterative structures, the definition of functions, and parameter passing. [Usage]
  • Analyze and explain the behavior of simple programs involving the fundamental programming constructs: variables, expressions, assignments, I/O, control constructs, functions, parameter passing, and recursion. [Assessment]
  • Apply the techniques of decomposition to break a program into smaller pieces. [Usage]
Variables and primitive data types (e.g., numbers, characters, Booleans)
  • Identify the appropriate primitive data type to represent a particular entity. [Assessment]
  • Write programs that use primitive data types. [Usage]
File I/O
  • Write a program that uses file I/O to provide persistence across multiple executions. [Usage]
Conditional and iterative control structures
  • Modify and expand short programs that use standard conditional and iterative control structures. [Usage]
  • Choose appropriate conditional and iteration constructs for a given programming task. [Assessment]
Strings, Lists, Tuples, Sets, Dictionaries
  • Strings and string processing
  • Lists and list processing
  • Simple numerical algorithms, such as computing the average of a list of numbers,
  • finding the min, max, and mode in a list, approximating the square root of a number, or finding the greatest common divisor
  • Implement basic numerical algorithms. [Usage]
  • Describe common applications for each of the following: strings, lists, tuples, sets, and dictionaries. [Familiarity]
  • Write programs that use strings, lists, tuples, sets, and dictionaries. [Usage]
Recursion
  • Describe the concept of recursion and give examples of its use. [Familiarity]
  • Identify the base case and the general case of a recursively-defined problem. [Assessment]
  • Implement, test, and debug recursive functions and procedures. [Usage]
  • Determine whether a recursive or iterative solution is most appropriate for a problem. [Assessment]
Program correctness
  • Types of errors (syntax, logic, run-time)
  • Apply a variety of strategies to the testing and debugging of simple programs. [Usage]
  • Construct, execute, and debug programs using a modern IDE and associated tools such as unit testing tools and visual debuggers. [Usage]
Objects and methods
  • Object-oriented design and implementation
  • Definition of classes: fields, methods, and constructors
  • Use common library classes and methods. [Usage]
  • Design and implement a class. [Usage]
Sequential and binary search algorithms
  • Brute-force algorithms
  • Divide-and-conquer
  • Worst case quadratic sorting algorithms (e.g., selection, insertion)
  • Discuss how a problem may be solved by multiple algorithms, each with different properties. [Familiarity]
  • Implement simple search algorithms and explain the differences in their time complexities. [Assessment]
  • Implement sorting algorithms recursively, both to understand them and to gain additional practice with recursion. [Usage]
  • Discuss the runtime and memory efficiency of principal algorithms for sorting and searching. [Familiarity]
  • Discuss factors other than computational efficiency that influence the choice of algorithms, such as programming time, maintainability, and the use of application-specific patterns in the input data. [Familiarity]
  • If provided alternative algorithms for solving a problem, demonstrate the ability to evaluate them, to select one, to provide justification for that selection, and to implement the algorithm in a particular context. [Assessment]
  • For each of the strategies (brute-force, divide-and-conquer), identify a practical example to which it would apply. [Familiarity]
  • Implement a divide-and-conquer algorithm to solve an appropriate problem. [Usage]
Stacks and Queues (use natural list structure of Python)
  • Describe common applications for stacks and queues. [Familiarity]
  • Write programs that use stacks and queues. [Usage]
  • Choose the appropriate data structure for modeling a given problem. [Assessment]