Common Terms and Phrases Used in Computer Science Writing

  • abstraction: Hiding some details of how something is accomplished to make it easier to think about or use.  Sometimes means a specific choice of what details to hide.
  • algorithm: A sequence of steps that can be followed to solve of a large number of similar problems.
  • architecture: The way that different parts of a computer system are organized and work together. Sometimes means the parts of the computer themselves.
  • array: A sequence of simple (or simpler) things that can be accessed by position, e.g., by an index.
  • automaton: Programs for simplified models of computers that have limited memory and limited input processing. "Automata" is the plural form of "automaton."
  • character and text string: Characters are the letters or symbols that text is made out of. A string is a sequence of characters.
  • compiling: The process of turning a program that is written by a programmer into a sequence of machine instructions that can be run by a computer.
  • data structures: A method of organizing data so it can be more efficiently accessed and updated. Different data structures can provide different ways of accessing data.
  • debug: To find and fix mistakes in a program.
  • functional programming: A way of writing programs that usually uses recursion, does not update the values of variables, and can use functions as data types like integers or strings.
  • induction: A method of proving that a statement is true for every element of an infinite set. An induction proof consists of (i) a “base case”: that the statement is true for the simplest element(s) of the set (like 0 or an empty string); (ii) an inductive step: that if the result is true for some element of the set, then it is true for the next largest element (by adding 1 to an integer, or adding a character to a string).
  • iteration: Repeating, or looping through, a list of steps multiple times in a program. Sometimes means one particular run through these repeated steps.
  • modularity: Writing a program in smaller pieces (called modules) that don’t directly access the data used by the other pieces. This way, it is easier to modify or reuse the individual pieces.
  • object-oriented programming: Breaking programs into pieces called objects that store data along with programs (called methods or member functions) to access and modify the data.  This also involves the idea of inheritance where one kind of object—a class—may have several sub-classes that have different data or methods.
  • operating system: The program that organizes a computer’s processor, memory, files, network, display, and other devices so that other programs don’t need to directly access these devices.  Linux, Android, iOS, MacOS, and Windows are examples.
  • queue: A data structure that has first-in, first-out behavior, like waiting in line (queueing) at a service counter. It supports adding elements (enqueue), removing elements (dequeue) and checking the next element (peek).
  • recursion: Solving a problem by repeatedly turning it into one or more similar and simpler sub-problems, until we reach a “base case” that is easy to solve, then combining the results to get the solution.
  • rigorous proof: A step-by-step argument that a conclusion follows from a set of assumptions and axioms. Each step should be justified by a definition, axiom, or logical rule.
  • sequence: A list of items where the order and number of times that the items appear is important; e.g., the sequence "red, green, blue, green" is different from the sequence "green, blue, red, red."
  • set: A collection or list of items where the order and number of times the items appear is not important (e.g., so the sets {red, green, blue, green} and {green, blue, red, red} are equal).
    Items in the set are called elements.
    If x is an element of set S, we write "x ∈ S."  
    If all of the elements of set A are also elements of set B, we say that A is a subset of B and write "A ⊆ B."
  • stacks: A data structure that has "last in, first out" behavior—the last item added to the "top" of the stack is the first item to be removed, like a stack of trays or books. A stack supports adding elements (push), removing elements (pop), and sometimes checking the next element (top or peek).