Content of Introductory Courses

Course Description: An introduction to computer programming and problem-solving using computers. This course teaches you how real-world problems can be solved computationally using programming constructs and data abstractions of a modern programming language. Concepts and techniques covered include variables, expressions, data types, objects, branching, iteration, functions, classes, and methods. We will also cover how to translate problems into a sequence of instructions, investigate the fundamental operation of a computational system and trace program execution and memory, and learn how to test and debug programs. No previous programming experience is required.

Prerequisites: R1 (or a score of 15 or higher on the math placement test Part A), or one of the following courses: MATH 101&102 or MATH 104 or MATH 127 or MATH 128 or MATH 131 or MATH 132.

Learning Outcomes: The objective of this course is to introduce the fundamentals of computing and programming using a general-purpose programming language from a modern perspective. This includes understanding the operation of a machine from a programming language perspective and what it means to execute a whole program as well as its individual parts, how to solve problems using constructs that a programming language provides such as variables, data types, objects, branching, iteration, functions, and classes, and how to write programs that receive data from various sources, process that data, and produce output in various forms.

Language used: Python

Draft Syllabus: CICS 110 Syllabus.pdf

Topics Covered:

1. Introduction to Programming
2. Variables and Expressions
3. Types: strings, lists, tuples, and sets
4. Types: dictionaries
5. Functions
6. Functions, Branching, and Control Flow
7. Branching, Detection, and Iteration
8. Iteration and Functional Iteration
9. Strings, Dates, and Lists
10. List Comprehensions and Dictionaries
11. Introduction to Classes
12. Class Interfaces, and Exceptions
13. Files and Plotting
14. Modules and Libraries

Course Description: This course will expose students to programming practices beyond the introductory level, concentrating on Object Oriented Programming techniques and an introduction to Data Structures. Students will also study and analyze the complexity of both the algorithms presented in class and of the algorithms they develop. Before taking this course, students are expected to have been exposed to the following concepts through a college-level course or equivalent in some high level computer programming language: input and output operations, conditional statements, loops, arrays, recursion, and functions/methods. The course places an emphasis on the careful design and testing of programs, as well as in the analysis of said programs.

Prerequisites: CICS 110 or INFO 190S or COMPSCI-121 with a grade of C or better or a score of 4 or higher on the CS AP exam.

Learning Outcomes: By the end of this course, successful students will be able to: Explain key concepts of the object-oriented programming paradigm, including data encapsulation, information hiding, inheritance, polymorphic methods, and others; solve programming tasks by decomposing them into smaller tasks through the careful development of algorithms; make use of object-oriented practices in order to solve programming problems of medium to advanced complexity;  appropriately test the code they develop; explain the concept of Abstract Data Types (ADT), specify the ADT of objects and classes they design, and interact with data structures designed and implemented by other by using their ADT specifications; correctly reason about and explain the complexity of the algorithms and programs seen and developed in class; understand and make use of basic data structures such as lists, stacks, queues, and trees; implement linear data structures such as different types of lists.

Language used: Python and Java

Draft Syllabus: CICS 160 Syllabus.pdf

Topics Covered:

1. Python review
2. Classes and Objects
3. Inheritance
4. Testing (with unit test)
5. Type hints.
6. Introduction to complexity analysis
7. Searching in a list
8. Implementing linked lists
9. Searching in a sorted list
10. Sorting methods
11. Recursion
12. Sorting recursively
13. The implementation of lists with arrays
14. Introduction to Java (inheritance, abstract classes, interfaces)
15. Ordered lists
16. Implementing lists in Java
17. Abstract classes in Python
18. Queues and stacks

Course Description: An introduction to the design, analysis, and implementation of data structures. This course teaches you how to build, test, debug, document, and evaluate objects that encapsulate data and their associated operations using programming constructs and data abstractions of a modern programming language. Concepts and techniques covered include linear and non-linear structures, recursive structures and algorithms, traversal algorithms, binary search trees, balanced trees, priority queues, union-find, hash tables, Bloom filters, and graphs. We will also informally compare and contrast the run time efficiency of algorithms and their performance characteristics including the concept of worst-case running time analysis and the classification of algorithms in terms of constant, logarithmic, linear, log linear, quadratic, and exponential time using Big-O notation.

Prerequisites: CICS 160 or INFO 190T with a grade of C or better.

Learning Outcomes: At the completion of this course you will be able to: Design, implement, and analyze fundamental abstract data types and data structures such as lists, stacks, queues, priority queues, trees, sets, hash tables, union-find, heaps, Bloom filters, and graphs; Define and implement recursive structures and algorithms over those structures; Demonstrate an understanding of iteration and traversal to implement iterators for the aforementioned data structures; Define and implement the operations and algorithms associated with fundamental data structures; Compare data structure tradeoffs to select the appropriate implementation for an abstract data type; Informally explain, compare, and contrast the run time efficiency of algorithms and their performance characteristics including the concept of worst-case running time analysis and the classification of algorithms in terms of constant, logarithmic, linear, log linear, quadratic, and exponential time; Explore and use various programming abstraction techniques including object-oriented and functional approaches to implement data structures; Identify and remedy flaws in a data structure implementation that may cause its behavior to differ from the intended design through debugging and testing; Increase your proficiency in writing code including designing, documenting, writing, testing, and debugging.

Language used: Java

Draft Syllabus: CICS 210 Syllabus.pdf

Topics Covered:

1. Introduction to Data Structures and Algorithms (Java, abstract data types, generics)
2. Linear Structures Review: Stacks and Queues (array and linked implementations)
3. Big O Analysis, Searching, and Algorithm Analysis (linear, binary search)
4. Amortization and Extendable Arrays
5. Trees (binary search trees)
6. Balanced Trees (AVL and B-trees)
7. Priority Queues (heaps and treaps)
8. Union-Find / Merge Sort
9. Hash Tables
10. Bloom Filter
11. Graphs (BFS and DFS search algorithms)