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 likely COMP 363: Design and Analysis of Computer Algorithms to the two courses already listed.

Software Engineering students are in the middle. The background for the Computer Science student is helpful, but adept transitioning students may manage with the courses 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).
    • Or you can do prep courses while taking a graduate course that does not require the prerequisites. (faster full-time finish!)

In fall or spring you have the opportunity to take a compressed intensive sequence of prerequisites in one semester: two 7-8 weeks courses in succession. COMP 388: Foundations of Computer Science 1 and COMP 388: Foundations of Computer Science 2. These cover at least the content of COMP 170: Introduction to Object-Oriented Programming and COMP 271: Data Structures. You can be a full-time graduate student at the same time by adding the required COMP 417: Social, Legal, and Ethical Issues in Computing, which has no prerequisite.

The free online text used for COMP 388: Foundations of Computer Science 1, by Dr. Harrington and Dr. Thiruvathukal, assumes no background in programming. It has the full contact hours of a regular 15 week course, but in 7-8 weeks. You are welcomed to look at or independently use the materials on the course web site http://anh.cs.luc.edu/388Intro, including the text and videos linked there. Starting to look early is advised, since 6 1/4 hours of class a week and all the work that goes with it does require some dedication! Some of the transitioning students with full-time jobs have found this to be too much to take on even as their only course.

For students with a fairly pure humanities background, and very little sequential symbolic experience, you may want to take a slower approach through traditional undergraduate courses, but this will slow you down by at least an extra semester.

Please contact the Graduate Program Director with any questions at gpd@cs.luc.edu.

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 COMP 170/ISOM 370

List of top ten concepts you should understand at the end of COMP 170: Introduction to Object-Oriented Programming / ISOM 370, 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 Java 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 Java 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 containers like ArrayList 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 like List.

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.