We covered a lot of territory this semester, and it may seem like it was all about Scheme. But as you'll see if you continue with computing courses, most of what we talked about will be useful throughout your computing education. What we've been talking about are the fundamental concepts in computer science, and they exist independently of the language we used to explore them. Here's a summary of the topics we encountered, not necessarily in this order. Most were covered in class, but some showed up only in the course notes. 1. General computer science concepts: computer science - the study of computational processes process vs. program or procedure what's an algorithm? programming languages and paradigms (functional, procedural or imperative, object-oriented) the functional programming paradigm what's a function? parameters (formal parameters) arguments (actual parameters) compilers interpreters programming language details... defining functions/procedures (binding names to procedures) operators conditionals predicates recursion - the three parts substitution model of evaluation activation stack stack frames stack tracing costs of recursion vs. benefits of recursion shape of a process (linear recursive process vs. linear iterative process) tail recursion vs. augmenting recursion procedures vs. functions (in the class notes) data types abstract data types (ADTs) lists different degrees of equality box-pointer notation recursion templates tree recursion (also car-cdr or multiple recursion) costs of cons vs. append orders of complexity (time complexity, space complexity) Big-O notation abstraction, reference, and synthesis procedural abstraction data abstraction graphs association lists trees tree traversal (preorder, inorder, postorder) abstraction walls/abstraction barriers trees as association lists relational networks inheritance in networks search linear search binary search hierarchical search depth-first search state space search heuristic search minimax search alpha-beta pruning board evaluation move generation functions without names that can be passed as arguments (lambda) state and persistence of state the procedural or imperative programming paradigm variables scope of a variable lexical (or local or static) scoping global scoping (free variables) assignment costs of introducing assignment iteration (loops) iteration vs. recursion: when to do what vectors (arrays) parameter passing pass-by-value (in parameter) pass-by-reference (in-out parameter) vectors of vectors stacks as vectors queues as vectors the lexical closure (functions returning functions) macros dynamic languages vs. static languages (dynamic typing, dynamic memory allocation) templates (classes), instances (objects), and messages (method calls) the object-oriented programming paradigm five characteristics of object-oriented programming four underlying principles of OOP (abstraction, encapsulation, inheritance, polymorphism) classes (templates for objects) fields/attributes/variables methods/procedures how to learn a new language (baby Python) lists vs. tuples vs. vectors accessibility (public vs. private) creating classes Coke machines creating objects constructors class variables instance methods instance variables inheritance typically nothing happens until you make objects sorting insertion sort merge sort/divide and conquer/tree recursion again 2. Scheme-specific stuff: define parentheses math operators parameter list function body the list function cond if = > < >= <= (relational operators) rules of expression evaluation dotted pairs the list type car cdr cons quote pair? list? null? and or not equal? vs. eq? cons cells append assoc let vs. set! do vector operations lambda define-macro 3. Python-specific stuff: identifiers comments keywords data types expressions operators assignment indentation selection statements (the conditional: if) iteration statements (for, while) def ...... : class ....... : private vs. public in Python __init__ (constructor) self Copyright (c) 2003 by Kurt Eiselt. All rights reserved, with the exception of stuff that belongs to somebody else.
Last revised: December 8, 2003