Advanced Placement Information for CS and Informatics Majors

New Guidance

Please read this page carefully before your summer advising meeting. There is a new placement procedure for students entering CICS in Fall 2024 who took the CS-A Advanced Placement exam. 

During your meeting, if you received (or expect to receive) a 4 or 5 on this AP exam, you will be asked to select placement in CICS 160 or CICS 210 based on the information presented below. 

Message from the Undergraduate Program Director

Welcome again to UMass; we hope you will have a successful first semester. In preparation for your advising and course registration meeting, this message is meant to help you choose the best option for your first programming course.

The Manning College of Information and Computer Sciences (CICS) has recently revised its introductory course sequence with the aim of supporting all of our incoming students to be successful, whatever their programming background. View additional details about the new introductory course sequence. All courses in this sequence are designed to make students successful in their academic careers at CICS. Regardless of which course in this introductory sequence you take first, you can be certain that you will be well on your way to achieving your academic goals. The courses vary in the assumed previous exposure to computer programming, so you should choose based on your experience with these topics, as outlined below. 

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 of you may have also covered a significant part of the material in CICS-160. Therefore, starting this semester, you also 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 including materials from both CICS 160 and CICS 210 so you can make the best choice that fits your individual preparation and background. Here are some relevant points you should consider:

  • The most important thing is to start your first semester with the course you feel most comfortable with (this is why you are given the choice). 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 you 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 you do not have Python programming experience, revisiting object-oriented programming concepts in a new language can give you 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 gives you the needed prerequisites to enroll in COMPSCI 240: Reasoning with Uncertainty and COMPSCI 250: Introduction to Computation – that is, you can plan the same schedule for two of the four 200-level core courses. Moreover, the curriculum has a flexible structure; you can start taking electives at your own pace even before completing all core courses.

Regardless of which course you start with, congratulations again for your admission into our program! We look forward to fruitful semesters of growing intellectually together.


 

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.