Loyola University Chicago

Department of Computer Science

Programming Prerequisites

The descriptions below are for the courses at Loyola. 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/ISOM 370, Introductory Object Oriented Programming (in Java, C#, or a similar):


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. Java/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.