The final exam will be held on Tuesday, 5/11. It is open-book, open-notes, but no electronic devices will be permitted. It will cover both theory and basics of programming. There will be three parts: a true/false section, a short-answer, and a long-answer problem. While I will avoid complex syntax, you should have a general familiarity with C or Java programming and should be comfortable with writing short snippets on the exam.

In general, I'll cover the the materials listed below in addition to what was covered on the midterm exam -- I will emphasize the second-half material much more, however. Note that material covered in class is generally fair game, in addition to the reading. Finally, I don't always include examples in the below reading, but you may find some of them interesting or helpful as review, so feel free to extend the readings as you see fit (for example, if you like the case studies in the Java and C books).

Theory

• Ch. 7.1-7.7: Data structures
  • Abstraction, static/dynamic structures, pointers
  • Arrays, contiguous vs. linked lists
  • Stacks and queues: concept only, no implementation detail
  • Trees: concepts and basic diagramming, no implementation detail, i.e., know how to manipulate a tree but don't worry about the code
  • Customized data types: only in the context of your own language (i.e., structs for C and classes for Java)
  • No pointers in machine language topics
• Ch. 2.1-2.3, 2.5: Computer architecture
  • Overview (2.1)
  • Instruction repertoire (no reference to Illustrative Machine Language/appendix C, although you might find it useful as a reinforcement)
  • Program execution (Fetch-decode-execute cycle basic concept, but not specific example)
  • Communicating with other devices, data communication rates
• Ch. 3.1-3.3, 3.5-3.7: OS and Networks
  • Single, multiprocessor systems
  • Software survey, components (no bootstrapping)
  • Process, process administration (no client/server model)
  • Network fundamentals, The Internet
  • No transmission privileges
  • Layered approach to Internet software, TCP/IP suite
  • Security -- viruses, worms, firewalls as discussed at end (no public-key encryption)
• Ch. 10.1, 10.3-10.4: Artifical Intelligence
  • Performance vs. simulation, turing test, 8-puzzle
  • Production systems, search trees
  • Basic neural nets, specific example, not associative memory
• Ch. 11.1-11.2, 11.4-11.5: Computation theory
  • Functions and their computation, Turing machines, Church-Turing thesis
  • Halting problem (basic; understand its noncomputability, but formal knowledge of the proof is not required)
  • Measuring a problem's complexity (basic; no mergesort), Polynomial vs. Nonpolynomial problems, NP problems

C

• Ch. 10: C Preprocessor
  • #define
  • No const or conditional compilation
  • Include files
  • Parameterized macros
• Ch. 11: Bit operations
  • AND, OR, XOR, Complement (NOT), Shifts
  • No setting, clearing, testing bits
  • No bitmapped graphics
• Ch. 12: Advanced types
  • Structures, (not unions), typedef, enum, casting
  • No packed structures
  • Arrays of structures
• Ch. 13: Pointers
  • All, except const pointers
• Ch. 14: File I/O
  • Intro, Conversion Routines
  • No binary/ASCII files, nor end-of-line puzzle
  • No buffering problems (although a useful read!)
  • No unbuffered I/O, nor designing file formats
• Ch. 17: Advanced pointers
  • Pointers and structures, free, linked list
  • Structure pointer operator
  • No ordered linked lists, nor double, nor trees, nor chess program
• Ch. 18: Modular programming
  • Modules, public and private, extern, headers
  • No infinite arrays, but try to understand concept (good review!)
  • Makefile (and nothing after it)

Java

• Ch. 7.1-7.2: Formatting, advanced I/O
  • Strings and string handling
  • Tokenizers and envelopes
• Ch. 8.1-8.3: Objects at work
  • Designing an OO program
  • Properties of objects
  • Lists and iterators
• Ch. 9.1-9.3: Abstraction and inheritance
  • Class power
  • Inheritance
  • Abstraction through interfaces (not writing interfaces, just implementing them)
• Ch. 10: Graphics and user interfaces
  • Introduction to AWT and Swing
  • Putting graphics in a window
  • Laying out a GUI
• Ch. 11.1-11.2: Event-based programming
  • Interaction with text fields
  • Events, listeners and handlers