Students develop communications skills for professional environments. Course includes preparation and delivery of presentations and practice in various forms of business writing as it relates to the computer industry. Limited to Computer Science majors.

The course requires students to build solutions to programming problems using the C programming language in a UNIX environment.  Students will learn the C programming language and how to use the UNIX operating system.  The course provides an introduction to computer science as a discipline with a bias toward algorithms and computer architecture issues.

1. C Basics
2. Functions
3. I/O
4. Flow of control
5. Arrays
6. Strings

1. State an object’s type by reading a declarator using the Right Left Walk Method.
2. State how many bytes of storage are reserved by a variable definition.
3. State exactly where storage is allocated.
4. Correctly fill out memory templates for a variety of small C programs thereby demonstrating knowledge of the execution environment.
5. Identify which of C’s 45 operators cause a side-effect and which do not.
6. Convert an integer decimal value into its equivalent unsigned binary representation.
7. Convert an integer decimal value into its equivalent signed magnitude representation.
8. Convert an integer decimal value into its equivalent one’s complement representation.
9. Convert an integer decimal value into its equivalent two’s complement representation.
10. Convert a real decimal value into its IEEE 754 Single Precision Floating Point equivalent.
11. Create 10-250 line C programs after reading a short problem description.
12. Create programs that rely upon simple recursion (factorial, Ackermann’s function, Fibonacci).
13. Create programs that rely upon a recursive divide and conquer strategy (quicksort, maximum sum subvector, tromino tiling).
14. Write at least one program that relies upon a recursive backtracking strategy (knight’s tour).
15. Write short, relatively simple makefiles.
16. Use the GDB debugger to debug small programs using the following commands: list, step, next, display, break, run, and backtrace.
17. Use the UNIX operating system to create, store, and print files, to build an executable image, and to navigate about the file system.
18. Sort a list of integers using any one of the following sorts: bubble sort, insertion sort, selection sort, shell sort, and quick sort.
19. Write C programs that rely upon dynamic memory allocation via the function malloc.
20. Read and understand a program that implements a linked list polymorphic data structure that relies upon pointers to functions and pointers to a void.
21. Build an executable image from a collection of header and C source files.
22. Demonstrate how C’s dereference operator is used to access data.
23. Demonstrate how C can achieve “call by reference” by passing the address of an operand.
24. Write C programs that include single and multi-dimensional arrays, including passing such arrays as parameters to a function call.
25. Write small C programs that rely upon structs and typdefs.

This course covers all eight chapters of Esakov and Weiss’s data structures book. Students will learn how polymorphic data structures are implemented. Ideally, all case studies of example C code found in Esakov’s book will be discussed. Students will obtain a much clearer view of pointers, pointers to functions, and recursion. Beyond this, students will be given ample opportunity to practice reading for detail and discovering within themselves that they can achieve much more academically than they have to date. One of our goals is to have all students emerge as very confident C programmers that have an appreciation of basic data structures and algorithms. The topics covered in this course will be: a review of C Programming, recursion, data abstraction, sorting, divide and conquer, big O notation, using pointers to functions and pointers to data to implement polymorphic data types, linked lists, hashing, circularly linked lists, doubly-linked lists, stacks, queues, trees, tree traversal, binary search trees, AVL trees, n-ary trees, heaps, graphs, and sets.

1. Big O Notation
2. C Programming
3. Sorting (bubble, selection, insertion, shell, radix, quicksort, heapsort, mergesort, topological)
4. Recursion (tail, divide and conquer, backtracking)
5. Data Abstraction
6. Linked Lists
7. Programming Tools (gcc, make, gdb, emacs)
8. Sets
9. Hashing
10. Circular and Doubly Linked Lists
11. Queues
12. Trees - Binary and N-Ary
13. Tree Traversal
14. Binary Search Trees
15. AVL Trees
16. Graphs

1. Fill out a memory template by manually executing C programs that include: recursion, malloc’ed up space, passing of arrays, and functions calls.
2. Write C programs that use pointers to functions and pointers to generic data to build polymorphic data structures.
3. Write C programs that use recursion.
4. Write C programs that implement the following sorting algorithms: bubblesort, selectionsort, insertionsort, shellsort, and radix sort.
5. Write C programs that implement the following sorting algorithms: quicksort, heapsort, and mergesort.
6. Explain data abstraction in writing.
7. Write small makefiles.
8. Use the GDB symbolic debugger to walk themselves through a program that spans multiple files by using the following GDB commands: bt, break, s, n, display, list, and print.
9. Write three C programs that use backtracking as a programming methodology. The three programs are: Eight Queens, Knight’s Tour, and Four in a Row.
10. Write five C programs that use a divide and conquer strategy. The programs are: quicksort, maximum sum subvector, mergesort, recursive Tiling, and Strassen’s Matrix Multiply.
11. Write a C program that creates and prints an AVL tree by using polymorphic tree primitives previously built.
12. Write a C program that relies upon a sequential, dynamic array, and polymorphic implementation of sets.
13. Write a C program that relies upon a sequential, linked list, and polymorphic implementation of sets.
14. Write a C program that implements Dijkstra’s shortest path algorithm.
15. Write a C program that creates polymorphic binary search trees and traverses them inorder, preorder, postorder, and breadth first order.
16. Given a binary search tree, produce the inorder, postorder, preorder, and breadth first order traversal of that tree.
17. Write a C program that relies upon polymorphic circularly linked list.
18. Write a C program that relies upon polymorphic queues.
19. Write a C program that relies upon polymorphic doubly linked lists.
20. Write a C program that relies upon polymorphic linked lists.
21. Identify the average case complexity, expressed in Big O notation, of sorting algorithms.
22. Write a C program that relies upon a hashing implementation of polymorphic sets.
23. Score at least 85% on the final exam.

This course builds upon the basic elements of programming as learned in Computing I and II, and provides an introduction to object-oriented software programming using C++.  Topics for the course include an introduction to object-oriented design and analysis, object decomposition, C++ language extensions such as class hierarchy and inheritance, and polymorphic object behavior that supports the object-oriented paradigm.  We also discuss software reuse and the use of C++ class libraries.  The main objectives of this course are to develop basic object-oriented software development skills and to learn the object-oriented features of C++.

1. Introduction to Object-Oriented Design and Analysis
2. The Object Model
3. Review of C and introduction to C++
4. Classes and data abstraction
5. Operator overloading
6. Inheritance
7. Virtual functions and polymorphism
8. C++ stream I/O
9. Templates
10. Exception handling

1. Use g++ to compile and link single or multiple C++ programs.
2. Understand basic C++ syntax.
3. Write C++ programs that use string and iostream classes to print to standard output and read from standard input.
4. Write C++ programs with object-oriented design using both structs and classes, separating header and implementation files.
5. Write C++ programs that use sequential containers, vector, list, and deque, and their iterators.
6. Write C++ programs that use pointers to iterate through arrays.
7. Write C++ programs that use functions with reference parameters.
8. Explain differences of three sequential containers and be able to decide which one to use for specific applications.
9. Write C++ programs that use type-independent generic algorithms.
10. Write C++ programs that use both function and class templates.
11. Explain data abstraction and encapsulation and how they are enforced in C++.
12. Explain differences of three access labels and their inheritance restrictions.
13. Write C++ programs that use three components of copy control.
14. Write C++ programs that use smart pointers.
15. Write C++ programs that use overloaded input/output, arithmetic, relational, assignment, subscript, member access, and increment/decrement operators.
16. Explain three fundamental concepts of Object-Oriented Programming (OOP).
17. Understand when dynamic binding is triggered.
18. Identify which (virtual) function is called in a base and derived class hierarchy.
19. Write C++ programs that use class inheritance and virtual functions.

In this course, students will learn how to program using the MIPS assembly language, the components of a computer and their organization, the hardware/software interface, and how to measure and compare performance. Students will study learn how to design the central components of a computer from combinational and sequential logic components. Students will also learn about current issues and tradeoffs in computer design.

1. The hardware/software interface
2. Instruction set architectures
3. RISC vs. CISC
4. Stored program concept
5. Execution time
6. Performance
7. Speedup
8. Benchmarks
9. Amdahl’s law
10. Representation of numbers and strings
11. Simple programming
12. The SPIM simulator
13. Input and Output and Syscalls
14. Complete assembler programs
15. Control structures
16. Procedures and stacks
17. Manual assembly
18. MIPS addressing styles
19. Memory layout: global data, dynamic data, OS, stack, and text
20. Representation and manipulation of integers
21. Mathematical and logical operations
22. Representation and manipulation of floating point numbers
23. Gates, truth tables, and logic equations
24. Combinational logic
25. Designing an ALU
26. Ripple-carry adders
27. Carry-lookahead adders
28. Multiplication algorithms
29. Sequential logic
30. Clocks and timing methodologies
31. Gates, latches, flip-flops
32. Introduction to memory organization
33. Single-cycle control
34. Finite state machines
35. Multi-cycle control
36. Microcode control

1. Write programs in the MIPS assembly language that include the following features: assignment statements, input and output, strings, conditional execution, procedures, arrays, records, and recursion.
2. Discuss and describe the basic components of a computer.
3. Discuss and describe how memory is organized.
4. Discuss and describe how peripherals operate and interface with a computer.
5. Demonstrate and discuss how combinational logic components may be used to build an Arithmetic Logic Unit.
6. Demonstrate and discuss how combinational and sequential logic components may be used to implement a simple single-cycle computer.
7. Demonstrate and discuss how combinational and sequential logic components may be used to implement a simple multi-cycle computer.
8. Evaluate a computer’s performance.
9. Compare the performance of two computers.
10. Demonstrate and discuss tradeoffs in computer design and how they affect performance.
11. Discuss current issues in computer organization.

This is the fourth course in our core CS sequence.  It is typically taken by second semester sophomore computer science majors after they have had a solid two semesters of exposure to basic computing concepts using the C programming language in Computing I and II, including study of all the basic C language data structures.  Students are then required to take Computing III, which is an introduction to object-oriented programming (OOP) using the C++ language.

Computing IV builds on the prior three courses by:

• deepening students’ knowledge of OOP and C++ through additional examples, constructs, and techniques
• exposing students to professional tools and professional practices, particularly integrated development environments, and documentation standards
• as time permits, looking at additional professional techniques and tools such as using C++ patterns and storing code in repositories with version control
• introducing students to OOP in at least one other language, showing alternative object models, and providing additional experience with APIs

1. Object-oriented software development
2. Object-oriented design
3. Object relationships
4. Exceptions
5. Class and Inheritance
6. Documentation
7. Regular expressions
8. Parsing
9. Integrated Development Environments
10. Streams
11. XML and JSON
12. Use and Design of Large APIs

1. Set up, configure, and use a professional IDE, including its debugging capabilities.
2. Document code in a professional manner using industrial quality documentation tools.
3. Manage code and share it with others using a repository with version control.
4. Describe the differences between writing small programs and ones that are part of a large software project that involves multiple people.
5. Use and create industrial quality application programmer interfaces (APIs).
6. Develop programs that implement general algorithms driven by data stored in files rather than hard-coded.
7. Understand basic features of scanning and parsing.
8. Appreciate the advantages of industry standards in coding and data file formats.
9. Not only recognize a truly elegant computer program when they see one, but also be able to produce such programs themselves.

We will study programming languages using Scheme. You’ll learn about features of various programming language paradigms including the imperative, functional, logical, and object-oriented approaches. Key concepts include: building abstractions, computational processes, higher-order procedures, compound data, data abstractions, controlling interactions, generic operations, self-describing data, inheritance and message passing, streams and infinite data structures, meta-linguistic abstraction, interpretation of programming languages, machine model, compilation, and embedded languages.

1. Introduction to Scheme
2. Substitution model
3. Orders of growth
4. Recursion and iteration
5. Higher-order procedures
6. Compound data
7. Aggregate data
8. Symbolic data
9. Henderson picture language
10. Data structures
11. Multiple representations of data
12. Generic operators
13. State
14. Environment model
15. Object-oriented programming
16. Mutable data
17. More mutation
18. Streams
19. Metacircular evaluator
20. MC eval: lazy evaluation
21. Logic programming and pattern matching
22. Memory management and garbage collection

1. Evaluate Scheme expressions.
2. Create pair structures in Scheme and diagram them on paper using box and pointer diagrams.
3. Perform manipulations of lists and trees.
4. Differentiate between normal and applicative order evaluations.
5. State the order of growth of a procedure in terms of time and space.
6. Write procedures that generate both iterative and recursive processes.
7. Manipulate higher-order procedures by passing procedures as arguments and returning procedures as values of other procedures.
8. Differentiate between the Scheme comparison operators eq?, eqv?, and equal?.
9. Write a procedure given its specifications and sample results.
10. Write procedures to maintain state in local environments for later applications.
11. Describe the meaning of mutation and be able to implement it in procedures.
12. Create environment diagrams describing the evaluation of Scheme code and understand existing environment diagrams.
13. Write object-oriented code in Scheme.
14. Describe the characteristics of various garbage collection algorithms.
15. Define procedures that create and manipulate infinite streams.
16. Demonstrate understanding of the metacircular evaluator by adding new statements and modifying the behavior of existing statements.
17. Use the metacircular evaluator to understand different methods for evaluating arguments: applicative order, normal order, the analyze evaluator, and the lazy evaluator.
18. Demonstrate creative application of ideas in the course to other domains.

Foundations of Computer Science provides a survey of the mathematical foundations of Computer Science.  It has two basic goals:

1. To give you an understanding of fundamental concepts in computing, including common models for computation such as finite automata and Turing machines. There will be some effort to convince you that this technology is important for implementing a variety of the latest types of systems and software.
2. To give you a sense of how to reason formally about computing, how to prove theorems about computation, and how to tell a rigorous proof from wishful thinking.

1. Mathematical preliminaries
2. DFAs and NFAs
3. DFA/NFA equivalence and regular expressions
4. Non-regular languages and pumping lemma
5. Context-free grammars and languages
6. Pushdown Automata
7. Non-context free languages and pumping lemma
8. Turing machines and variants
9. Algorithms and the Church-Turing thesis
10. Decidability, undecidability, and diagonalization
11. Reducibility
12. A natural undecidable problem
13. P and NPNP completeness

1. Understand finite state automata, push-down automata, and Turing machines in terms of memory resources.
2. Describe basic properties of languages accepted by these models.
3. Understand basic construction (programming) techniques of these models.
4. Read and write regular expressions and context-free grammars.
5. Write a convincing formal proof about basic properties of regular languages, context-free languages, and recursively enumerable languages.
6. Recognize a bogus proof.
7. Put algorithmic problems in relation to computational models.
8. Explain the concept of undecidability and understand reducibility.
9. Understand time complexity measurement and its relationship to models.

This three credit course provides an examination of the basic functional components of a computer system including the CPU, memory systems, and I/O systems. Each of these three areas will be developed in detail with a focus on the system design and component integration. Topics will include CPU control and ALU operation, computer timing, data address and I/O bus activity, addressing model, programmed and DMA I/O, and instruction sets and microcode.

1. Digital I/O
2. Analog-to-Digital Conversion
3. Interfacing with Digital Logic
4. Instruction Set Design
5. CPU Registers
6. Memory Mapping and Address Decoding
7. Timing and Cycle Counting
8. Serial Interfaces
9. Design of Algorithms that Account for Cache Memory Configurations
10. How C Compilers Translate into Machine Code
11. Optimizing Code for Performance

1. Explain the architecture of a simple 8-bit microprocessor.
2. Write assembly language programs that access digital I/O and external digital logic.
3. Write assembly language programs that interface to analog signals using analog-to-digital converters.
4. Design hardware that performs address decoding and memory mapping for I/O peripherals and write assembly language programs that access these I/O peripherals.
5. Analyze assembly language programs to determine execution time and evaluate efficiency.
6. Explain how instruction sets are designed to simplify hardware decoding and maximize processor performance.
7. Explain the architecture of a simplified Pentium processor.
8. Write assembly language programs that map to sequential and pipelined implementations of a simplified Pentium processor.
9. Identify and eliminate control and data hazards from assembly language programs targeted to a pipelined implementation of a simplified Pentium processor.
10. Write assembly language programs that maximize the effectiveness of the branch prediction used in a pipelined implementation of a simplified Pentium processor.
11. Explain the performance degradation inherent in the use of memory.
12. Write assembly language programs that minimize code execution time through the use of registers instead of memory for storage of program variables.
13. Identify hardware elements would enhance software performance if added to the architecture of a simplified Pentium processor.
14. Perform a size-cost-speed tradeoff analysis to determine the viability of adding hardware elements to the simplified Pentium processor.
15. Design direct-mapped and set-associative caches that maximize code performance while balancing the additional cost incurred by fast memory elements.
16. Select appropriate cache and memory update policies.
17. Perform a size-cost-speed tradeoff analysis of different cache architectures.
18. Understand how C compilers translate C code into assembly language code.
19. Write C code to maximize the performance of the translated assembly language code for the Pentium III architecture.
20. Identify and eliminate C code blockers that prevent C compilers from fully optimizing the targeted C code for the Pentium III architecture.
21. Identify alternative C coding methods and styles that facilitates the generation of fast and efficient assembly language code for the Pentium III architecture.
22. Write C code that eliminates resource allocation conflicts when targeting the Pentium II architecture.
23. Identify hardware elements would enhance software performance if added to the architecture of the Pentium III.
24. Perform a size-cost-speed tradeoff analysis to determine the viability of adding hardware elements to the Pentium III.
25. Identify suites of benchmarks that may be used to test the efficiency of C code targeting the Pentium III.

This course introduces and develops the major components of operating systems, including the process and thread abstractions, concurrency and synchronization mechanisms, deadlock management strategies, processor allocation, memory management, I/O device and file management, and distributed processing. The course also presents techniques for operating system design, implementation, and evaluation.

1. What is an operating system?
2. The evolution of operating systems
3. What is an operating system
4. The evolution of operating systems
5. The process model
6. Systems and system states and transitions
7. Processes and address space layouts
8. Computational progress and process/thread organization
9. Process and operating system interfaces
10. System call and exception based kernel access
11. The need for process/thread synchronization
12. Synchronization techniques and mechanisms
13. Process scheduling and dispatching
14. General address space issues and memory management introduction
15. Process/thread sharing of physical memory
16. Virtual memory paradigm
17. Fetch, placement and replacement requirements
18. Page replacement algorithms
19. Page fault performance issues and modeling techniques
20. General design issues for paging systems
21. UMA, NUMA, and NORMA system architectures
22. Introduction to file systems
23. Name space issues
24. File system security and protection mechanisms
25. General device level IO control
26. Device driver models
27. Synchronous vs. asynchronous driver interfaces
28. Resource management and deadlock
29. Requirements for deadlock
30. Prevention, avoidance, and detection and recovery deadlock strategies
31. Introduction to distributed systems
32. General distributed system design issues
33. Communication in distributed systems
34. The general client-server model
35. The remote procedure call paradigm
36. The need for data consistency between heterogeneous systems

1. Explain the general function of an operating system.
2. Explain the organization and attributes of traditional processes and threads.
3. Write a Linux based application to create processes and exchange information among processes using inter-process communication mechanisms and signals.
4. Identify single and multiple processor requirements for execution path synchronization.
5. Write a Linux based application that demonstrates two way data exchange with a standard Unix/Linux command using pipes.
6. Explain the use of synchronization primitives, including semaphores, event counters and sequencers and monitors.
7. Write a Linux based application to manage a set of singly threaded producer and consumer processes that exchange information through shared memory using semaphore synchronization.
8. Describe the synchronization primitives of the pthread API.
9. Write a Linux based application to manage a multiply threaded process consisting of producer and consumer threads that synchronize with mutex and condition variable constructs.
10. Describe the differences between real and virtual memory management.
11. Explain the organization of a process address space and its various memory objects.
12. Write an application to simulate flat memory management by first fit and best fit linked list methods and by Knuth’s buddy system method.
13. Explain the use of page tables, page mappings and table walks in virtual memory systems.
14. Describe the organization of a translation lookaside buffer.
15. Explain the need for TLB shootdown on heavy weight context switching.
16. Describe the watermark processing used with free list management.
17. Differentiate between stack based and non-stack based page replacement algorithms.
18. Explain the need for and typical content of a system page frame table.
19. List the necessary conditions for deadlock.
20. Demonstrate the ability to reduce a general resource allocation graph, and reach a conclusion about any deadlock in the graph.
21. Explain the difference between safe and unsafe states in a deadlock avoidance scheme.
22. Differentiate among contiguous, linked and indexed file systems.
23. Describe the architecture of the basic Ext2 type Unix/Linux file system.
24. Explain the organization of an inode, and the use and need for indirect pointers.
25. Explain the process/object protection model used in Unix/Linux systems.
26. Write a Linux based application to report information on any Linux file object in a fashion similar to the standard Unix/Linux ls command.
27. Describe client-server computing and the deployment of a distributed service.
28. Explain the organization of a remote procedure call.
29. Explain the need for synchronization in a distributed environment.

In this course, we distinguish between an abstract data type (such as a list, stack, queue, tree, or hash table) and a data structure that represents how the abstract data type is represented and stored in the computer’s memory. We learn about algorithms for manipulating information in a variety of fundamental abstract data types and data structures. Information tasks such as searching, retrieving, inserting, updating, sorting and deleting arise frequently in Computer Science problems that are central to many computer applications. We focus on algorithms to correctly and efficiently accomplish these types of core tasks. Algorithms are described using high-level pseudocode. Running time and storage requirements are quantified using asymptotic analysis.

1. Use big O, omega and theta notation to give asymptotic upper, lower, and tight bounds on time and space complexity of algorithms.
2. Determine the time complexity of simple algorithms.
3. Express simple algorithms using pseudocode conventions.
4. Justify the correctness of an algorithm.
   1. “Mechanical,” e.g., no infinite loops or recursion, remaining within array bounds
   2. “As advertised,” e.g. optimal answer is actually found by an optimization algorithm; sorting algorithm results in correct ordering of elements.
5. Given a computational problem begin to learn how to:
   1. Recognize its underlying structure
   2. Identify aspects of the problem relevant to time & space complexity (e.g., problem size, distribution of inputs)
   3. Develop intuition about it using worst-case, best-case and average-case inputs
   4. Determine if a known solution exists
   5. Adapt a solution to a closely related problem
   6. Design an algorithm from scratch by appropriately selecting an algorithmic paradigm and making of abstract data type and implementation choices.
6. Given a list of functions of a single variable, order them according to asymptotic growth.
7. Perform worst-case, best-case and average case asymptotic analysis.
8. Deduce the recurrence relations that describe the time complexity of recursive algorithms, and solve simple recurrence relations using Master Theorem, recursion trees and induction/ substitution.
9. Design algorithms using the following paradigms, and recognize when each is appropriate:
   1. Greedy
   2. Divide-and-conquer
   3. Dynamic programming
10. Design and analyze simple randomized algorithms.
11. Solve problems using sorting algorithms:
    1. Comparison-based sorting algorithms
       1. Insertion Sort
       2. Merge Sort
       3. Heap Sort: Execute operations that preserve the heap property
       4. Quick Sort
    2. Non-comparison and hybrid sorting algorithms.
       1. Counting Sort
       2. Radix Sort
       3. Bucket Sort
12. Assess the impact of choices of abstract data type and implementation on running time and storage requirements.
    1. Stacks
    2. Queues
    3. Linked Lists
    4. Trees: Binary search trees and balanced binary search trees
       1. Apply left and right rotations that preserve the binary search tree property
    5. Hash Tables, including collision avoidance strategies
    6. Graphs, including both adjacency matrix and adjacency list representations
13. Understand the operation of the following graph algorithms.
    1. Depth-First Search
    2. Breadth-First Search
    3. Topological Sort
    4. Minimum Spanning Tree: Prim and Kruskal
    5. Single-Source Shortest Paths: Dijkstra

Number systems and computer codes. Switching algebra. Canonical and fundamental forms of switching functions. Minimization of switching functions. Two-level and multi-level digital circuits. Decoder, encoders, multiplexers, and demultiplexers. Design of combinational circuits using SSI, MSI and programmable logic devices. Latches and flip-flops. Registers and counters. Analysis and synthesis of synchronous sequential circuits. Design of more complex circuits: datapath and control.

1. Number Systems and Computer Codes
2. Boolean Algebra
3. Computer Arithmetics
4. Switching Functions
5. Analysis of Combination Circuits
6. Karnaugh Maps
7. Programmable Logic Devices (ROM, PLA, PAL)
8. Decoders, Encoders, Multiplexers, Demultiplexers
9. Synthesis of Cominational Circuits
10. Memory Elements, Latches and Flip-flops
11. Registers and Counters
12. Analysis of Synchronous Sequential Circuits
13. Synthesis of Synchronous Sequential Circuits
14. Control Circuit and Data Path
15. Design of Arithmetic Processor

A first calculus course. Functions, limits, continuity, derivatives, rules for differentiating algebraic and transcendental function; chain rule, implicit differentiation, related rate problems, max/minproblems, curve sketching; integrals and areas.

1. Function Representations
2. Exponential Functions
3. Inverse Functions and Logarithms
4. The Tangent and Velocity Problems
5. Limits
6. Continuity
7. Tangents, Velocities, Rates of Change
8. Derivatives
9. The Derivative as a Function
10. Derivatives of Poly. and Exp. Functions
11. Product and Quotient Rules
12. Derivatives of Trig. Functions
13. Chain Rule
14. Implicit Differentiation
15. Derivatives of Logarithmic Functions
16. Differentials
17. Related Rates
18. Maximum and Minimum Values
19. Derivatives and Shapes of Curves
20. L'Hospital's Rule
21. Newton's Method
22. Antiderivatives

A continuation of Calculus I. Volume, arc length, surface area, pressure and force. Differentiation and integration of trigonometric, inverse trigonometric, exponential, logarithmic, and hyperbolic functions. Improper integration, infinite series, Taylor and MacLauren series.

1. Antiderivatives
2. Areas and Distances
3. The Definite Integral
4. Evaluating Definite Integrals
5. Defining Inverse Trig. Functions
6. Derivatives of Inverse Trig. Functions
7. The Fundamental Theorem of Calculus
8. The Substitution Rule
9. Integration by Parts
10. Additional Techniques of Integration
11. Using Integration Tables
12. Approximate Integration
13. L'Hospital's Rule
14. Improper Integrals
15. More about Areas
16. Volumes
17. Average Value of a Function
18. Applications to Physics and Engineering
19. Sequences
20. Series
21. The Integral and Comparison Tests
22. Other Convergence Tests
23. Power Series
24. Representing Functions as Power Series
25. Taylor and Maclaurin Series
26. Applications of Taylor Polynomials

The primary goal of the course is to improve your ability to think mathematically and learn some of the mathematics that you are likely to need in your career as a computer scientist. As you proceed through the CS curriculum you will find that the line between mathematics and computer science is blurred and nobody ever learns ALL of the mathematics that they ultimately may need. The real objective of this course is to help prepare you to be capable of learning new areas of mathematics when you need them. The only specific request that we, the mathematics department, have received from the CS department is that you be exposed to a much theory, including mathematical proofs, as possible.

1. Similarities between "algebras."
2. Logic
3. Propositional Equivalence
4. Counting
5. Predicates & Quantifiers
6. Nested Quantifiers
7. Methods of Proof
8. Sets
9. Set Operations
10. Functions
11. Matrices
12. Gauss Jordan Eliminations, Network
13. Analysis
14. Directed Graphs
15. Sequences & Summations
16. Mathematical Induction
17. Recursive Definitions
18. Basics of Counting
19. Pigeonhole Principle
20. Permutations & Combinations
21. Binomial Coefficients
22. Relations and their Properties
23. Representing Relations
24. Closures of Relations/Connectivity
25. Equivalence Relations
26. Partial Orderings

Graph theory, trees, algebraic systems. Boolean algebra, groups, monoids, automata, finite-state machines, rings, fields. Applications to coding theory, sorting, logic design.

A one semester course in probability and statistics with applications in the engineering sciences. Probability of events, discrete and continuous random variables, density functions, distributions. Estimation, hypothesis testing, regression and correlation.