Advanced Placement Information for CS and Informatics Majors

Please read this page carefully before the New Student Advising and Course Registration meeting. 

The Manning College of Information and Computer Sciences (CICS) has an introductory course sequence with the aim of supporting all incoming students in their success, whatever their programming background. View additional details about the new introductory course sequence. Regardless of which course in this introductory sequence is taken first, students can be certain they will be well on their way to achieve their academic goals. 

The initial course in our computer programming sequence is CICS-110: Foundations of Programming. It is taught in small sections of 50-60 students and requires no prior programming experience.

Students who have taken the AP Computer Science A exam with a score of 4 or better receive credit for CICS 110. For those students, the default placement is into the second course, CICS 160: Object Oriented Programming. Some students may have also covered a significant part of the material in CICS-160. Therefore, students have the option of directly entering the third course, CICS 210: Data Structures. In this case, the program requirement for CICS 160 will be waived upon successful completion of CICS 210.

We are providing materials from both CICS 160 and CICS 210 so students can make the best choice that fits their individual preparation and background. Here are some relevant points to consider:

  • The most important thing is to start the first semester in a course that is comfortable. CICS 160 offers a solid college-level grounding in object-oriented programming and elementary data structures. Together with the additional programming experience, this is designed to help students succeed in CICS 210 and fully appreciate its more advanced material (especially in the latter part).
  • CICS 210 is taught in Java. CICS 160 is taught in Python (with a brief introduction to the language) and a transition to Java at the end. Python is a very useful language; if students do not have Python programming experience, revisiting object-oriented programming concepts in a new language can provide a better perspective that will be helpful later on.
  • Choosing one course over the other does not mean a one-semester gap. Taking either CICS 160 or CICS 210 provides the needed prerequisites to enroll in COMPSCI 240: Reasoning with Uncertainty and COMPSCI 250: Introduction to Computation – that is, students can plan the same schedule for two of the four 200-level core courses. Moreover, the curriculum has a flexible structure, allowing students to start taking electives at their own pace even before completing all core courses.

 

CICS 110 is designed to introduce students to the basics of algorithmic computations. This course is ideal for students just getting started with computer programming or for any student who wants to review programming fundamentals. The course, taught in the Python programming language, covers variables and types, expressions, input and output, conditional (if-else) statements, while loops, for loops, lists, and functions. If any of those topics are new to you, or if you want to practice more with them, CICS 110 is the right course for you to begin with.

Students with enough prior programming experience to skip CICS 110 and move on to CICS 160 should be able to write Python solutions to the programming tasks of the types presented here. 
 

CICS 160 gives students a solid introduction to object-oriented programming (OOP), an important concept in computer programming. It also introduces students to the Java programming language and how it incorporates many concepts of OOP. Emphasis is placed on the design of objects and classes, information hiding, inheritance, polymorphism, data abstraction, and interfaces.

CICS 210 expects students to have completed CICS 110 and 160 (or equivalents). Conceptually, students should be familiar with:

  • the operation of a computer from the perspective of at least one programming language. For most novice programmers, this means understanding how to represent data, the difference between values and variables, what a "reference" or "pointer" refers or points to, and what various parts of the language "do" (that is, their semantics). In other words, programmers should have an accurate "mental model" of what the various parts of their programming language of choice do.
  • how to group data in various ways (depending on the language: arrays, tuples, structs, lists, dictionaries/maps/hash tables, records, objects, etc.), and practice using those tools in a logical way to organize data within programs.
  • decomposing problems into smaller, more tractable parts and building larger programs out of those parts. These parts might be standalone functions or procedures in a purely imperative approach or objects and methods in an object-oriented approach.
  • the key concepts of the object-oriented programming paradigm, including data encapsulation, information hiding, inheritance, and polymorphic methods, in at least one programming language (ideally Python and/or Java).
  • the informal notion of abstract data types (ADTs), defining data types from the point of view of their user in terms of the operations permitted on that data type. For example, a "List ADT" might support insertion, deletion, and querying the size of the list.
  • the basics of "complexity analysis." In particular, students should be able to analyze small functions and determine if their "worst-case running time" (sometimes called "big-O" or "O()") is constant, linear, quadratic, or otherwise, in terms of some variable.

In terms of more concrete programming experience, students should have significant (at least one year), guided (in a classroom or other evaluative setting) practice in at least one programming language; that practice should have included object-oriented programming. If that language was not Java, students should additionally have at least a month of Java experience and be able to write nontrivial Java programs. That practice should have resulted in:

  • a firm grasp of the fundamentals of imperative programming. They should know how to use values and variables of various types, along with conditional statements and loop statements, in order to compute a value, transform data, model a scenario, or otherwise solve a problem computationally.
  • significant practice with various approaches to debugging. This practice should encompass one or more of the following: 
    • simulating programs on paper 
    • using "print" statements to determine the state of running programs 
    • using the debugger — including breakpoints and watchpoints — to inspect running programs that are not behaving as expected.
  • practice using and writing "unit tests," small functions or methods that test other parts of a program. 
  • practice implementing simple linear data structures, such as stacks, queues, and/or lists, using more foundational language features such as arrays and references.

Students who have completed the AP CS exam with a score of 4 or 5 generally meet these expectations.
 

Students who have enough programming experience to skip CICS 160 and move into CICS 210 should be able to write Java solutions to the programming tasks of the types presented here.

For students who do not have at least a score of 4 on the AP Computer Science A exam, we offer a placement exam that covers the material of CICS 110 Foundations of Programming. The exam will be offered in person on the first day of the fall semester; more information will be provided to eligible students who are registered for CICS 110. Students successful in the placement test can take CICS 160 and will receive a waiver for CICS 110.