Masters Programs Prerequisites

All students need the equivalent knowledge of COMP 170: Introduction to Object-Oriented Programming and COMP 271: Data Structures. The topics for these courses are outlined in Two Basic Programming Prerequisites. This knowledge is prerequisite to essentially all the graduate courses in the Computer Science Department, with the exception of COMP 417: Social, Legal, and Ethical Issues in Computing.

Students in the Computer Science Graduate Program need the strongest preparation. Most will have an undergraduate degree or at least the first two years of foundational undergraduate courses. This would include the addition of equivalents of our COMP 163: Discrete Structures and COMP 264: Introduction to Computer Systems and COMP 363: Design and Analysis of Computer Algorithms to the two courses already listed above.

Software Engineering students are in the middle. The background for the Computer Science student is helpful, but adept transitioning students may manage with the two basic courses that the IT students need.

Many of our best students in Information Technology and Software Engineering have transitioned from other fields.

You can handle missing prerequisite knowledge in a number of ways:

  1. Take them somewhere else (possibly cheaper and more convenient to your location, but possibly not as good or not covering mostly what we want)
  2. Take them at Loyola: Take just the courses we want, with support of our faculty, giving you an opportunity to get into our community and build relationships with faculty and students.
    • This can be done before entering the Graduate program as a non-degree undergrad (cheaper undergraduate tuition).
    • You can get both prerequisites in one semester with our special compressed sections (section number 400) of COMP 170: Introduction to Object-Oriented Programming and COMP 271: Data Structures. See a fuller discussion below.
    • The compressed prerequisites can be taken after admission to the graduate program. Then you become a full-time graduate student if you add a third course - a graduate course not requiring the prerequisites. (faster full-time finish!)

Compressed prep courses: In fall or spring you have the opportunity to take a compressed intensive sequence of the COMP 170: Introduction to Object-Oriented Programming and COMP 271: Data Structures prerequisites in one semester: two 7-8 weeks courses in succession, each with the same total contact hours of regular 15 week courses. To be a full-time graduate student at the same time, the most common additional course is the required COMP 417: Social, Legal, and Ethical Issues in Computing, which has no prerequisite. Note that 6 1/4 hours of class a week in the compressed prerequisites with all the work that goes with them does require some dedication! Many transitioning students with full-time jobs have found this to be too much to take on even without an additional grad course. You can see the speed of topics in the first course in fall 2016 by looking at the course website,, though there will be a change of language and book for Fall 2017, starting with Python from and then a comparison and brief transition to Java in preparation for the next course.

Comp 170 does not require any background in programming, but if you have no background in programming, then it IS important to have a math background in which you are comfortable with the material in a precalculus course like our Math 118, which includes significant manipulation of functions. If you have a previous modest introduction to programming, including defining and using functions, then the formal math background is not so important.

Students who neither have this math background nor any programming at all may well want to get a more gentle introduction to programming first, as in our COMP 150: Introduction to Computing. It is offered fall and spring and online in the summer. If you do need the extra preparation like in Comp 150, then this will slow you down by a semester.

Please contact the Graduate Program Director with any questions at

The next section, Two Basic Programming Prerequisites, lists more details of material you should know before taking graduate courses in our department.

Two Basic Programming Prerequisites

Knowledge of the content below is prerequisite for almost all of the graduate courses in the Computer Science Department.

The descriptions below are for the courses at Loyola, in a pretty standard introductory sequence. If you took these subjects elsewhere, you are not likely to have the exact same collection of topics, but if you are close, there should not be much problem filling holes as needed.

Expectations from Introduction to Computer Science, COMP 170

List of top ten concepts you should understand at the end of COMP 170: Introduction to Object-Oriented Programming, Introductory Object Oriented Programming (in Java, C#, C++ or a similar language):

  1. Be able to distinguish between class and instance
    • Class is abstract representation or model (class aka type, abstract type, factory for objects). Class has field definitions (or attribute definitions) and operations (or methods) to implement its behaviors.
    • Instance (aka class instance, variable) is an actual, specific, concrete thing and has specific field values (or attribute values).
    • All instances of a class share the same operations and attribute definitions.
  2. Know syntax rules and coding style
    • Learn the basic picky rules of syntax and use them correctly. Key items: placement of “;” use of case (“ClassSchedule” vs. “classSchedule”); distinguish declarations and executable statements.
    • Format code readably according to agreed upon style.
  3. Use conditional control structures fully and correctly
    • Construct programs with “if….then”, and “if….then…else”. Understand nesting of control statements and blocks ( “{“ and “}”).
    • Briefly, “Nesting, blocks, no dangles”.
  4. Construct loops with control structures
    • Use “while”, “do”, and “for” control structures to implement algorithms successfully.
    • Briefly, “avoid never ending loops, avoid off-by-one problems”
  5. Use the primitive types and operators appropriately
    • Understand the use and limitations of the primitive types.
    • Know the most useful arithmetic, relational, and logical operators and use them in expressions, with parentheses when necessary.
  6. Lean how to create good OO encapsulation
    • Achieve a deep understanding of the proper use of the access modifiers “private”, and “public”.
    • Be able to design well structured classes.
    • Know when and how to use “static”.
  7. Construct and understand methods fully
    • Define and use methods, including formal parameters and return values.
    • Distinguish between formal parameters (aka parameters) and arguments in the call to a method.
    • Comprehend scope and lifetime of objects. Understand visibility of objects and how to implement finding the right object at the necessary time.
    • Know how to ask a particular instance of a class to do something. Know how to construct associations between classes.
    • Understand what is happening is a nested stack of method calls.
  8. Be knowledgeable about important library container classes and arrays
    • Be able to declare and use container objects like for lists and arrays. Understand how to find things in containers and arrays. Use index variables effectively.
  9. Perform simple input/output processing
    • Lean how to do basic input and output statements with an interactive user and with files. Be able to work with Strings.
  10. Understand OO Interfaces
    • Know how to define and use simple interfaces (example - List in Java).

Expectations from Data Structures, COMP 271

  1. OOP
    • Be able to write interface/abstract classes and implementations of data structures.
    • Understand subclassing mechanisms.
    • Understand overloading, overriding, dynamic binding, boxing and unboxing in OOP languages.
  2. Mathematical context
    • Big-Oh notation, worst-case run time complexity and storage complexity of algorithms.
    • Be able to do performance analysis of code using big-Oh.
  3. Data structures
    • Know and be able to use and implement abstract data types such as stacks, arraylists, vectors, queues, linked lists, hash tables, and hash sets.
    • Understand the time complexities of operations such as insert, delete, add, retrieve, on the above data structures and be able to obtain time complexities of other operations on similar, simple data structures.
    • Knowledge of hash functions, trees, graphs, and two dimensional arrays.
    • Knowledge of algorithms for problems including searching, and sorting (Quicksort, Mergesort, Heapsort etc.), string manipulations.
  4. Core programming language concepts
    • Knowledge of programming language storage paradigms such as static, stack, and heap.
    • Be able to understand and use recursion in various problems.