University Computer Science
The IMACS University Computer Science sequence emphasizes computational thinking with two fully interactive, self-paced, online programming courses. Both courses are entirely Web-based and self-contained with instant feedback, supportive instructors, and automatic grading of all work. Each course covers the equivalent of three university semester hours.
University Computer Science I
University Computer Science I, the introductory course in the sequence, is suitable for individuals from talented middle and high school students with no programming experience to working adults who would benefit professionally from a deeper understanding of computing. UCS1 teaches the fundamental principles of computer science using Scheme, a programming language that has been used at many of the finest universities around the world. Scheme's expressive yet simple syntax enables students to focus on effectively learning advanced concepts that can be implemented easily in any programming language, from Python to Java to future languages not yet invented. UCS1 includes an online Scheme interpreter, interactive exercises, and Web-based exams.
Data and Functions
Introduction
Welcome
Characters and Atoms
A Visit from Outer Space
Characters and Atoms
Introducing Lists
Lists
Matching Parentheses
Atomic Elements and Data Expressions
Counting Parentheses
Decomposition Trees
Primitive Functions
Black Boxes
The First Machine
Machine Hook-Ups
A New Machine
Functions
List Construction
Predicate Functions
Review for Test 1
Test 1
Generators and If-Switches
Data Expression Generators
If-Switches
Problem Set 1
Functional Expressions
Variables
Functional Expressions
Evaluation
Expressions for Generators and Conditionals
Quote-Expressions
Cond-Expressions
Simplifying Cond-Expressions
Evaluating Cond-Expressions
Review for Test 2
Test 2
Derived Functions
Constructing New Functions
Making New Functions
Names for Derived Functions
Using Derived Functions
The Scheme Evaluator
Problem Set 2
Boolean Functions
Problem Set 3
Programming
Top-Down Programming
Review for Test 3
Test 3
Recursion
Lats
Trace Tables
Recursive Functions
Problem Set 4
Recursive Functions that Output Lists
Problem Set 5
Problem Set 6
Review for Test 4
Test 4
A New Kind of Definition
Global Variables
Numbers
The Scheme Library
Preserving your Definitions
Working with Numbers
Introducing Numbers
Problem Set 7
Exponentiation
Problem Set 8
Review for Test 5
Test 5
Data Structures
Introduction
Introduction to Data Structures
Arrays
Pairing Lists
Arrays
Problem Set 9
Trees
Taxonomic Trees
Binary Trees
Ordered Binary Trees
Tree Sort
Problem Set 10
Review for Test 6
Test 6
Object-Oriented Programming
Introduction
Introducing Object-Oriented Programming
Sequencing Evaluations
Local Variables
Function-Valued Functions
Functions That Output Functions
Mixed Lambda-Expressions
Classes and Objects
Objects
Classes
Handling the Unexpected
Derivation and Inheritance
Making Objects That Can Change
Changing Bindings
Review for Test 7
Test 7
University Computer Science II
University Computer Science II is suitable for students who have successfully completed UCS1. UCS2 utilizes the Scheme and Haskell programming languages to teach more challenging topics including advanced recursion concepts, ordering/sorting algorithms, infinite lists, list comprehension, function abstraction, and higher order functions. Coursework includes a small-scale database project that deals with bus routes and a significant object-oriented programming project that involves artificial intelligence in a game-playing context. In addition to the online Scheme interpreter, students also have access to an online Haskell evaluator.
Students who successfully complete UCS2 have a better understanding of computer science than most college freshmen who have taken their university's introductory CS course. Because of this, IMACS UCS2 graduates are better prepared to succeed in upper-level university courses.
Recursion
List Processing Beyond Iteration
Introduction
Problem Set 1
Project: Bus Routes
Introduction
Creating Itineraries
Finding Itineraries
Types of Recursion
Accumulators
Tail Recursion
Full Recursion
From Full Recursion to Tail Recursion
Mutual Recursion
Problem Set 2
Review and Test
Review for Test 1
Test 1
Evaluation and Abstration
Introduction
Introduction to Evaluation
The Process of Evaluation
Evaluation
Evaluating Numerals, Booleans, and Variables
Evaluating Special Forms
The Special Forms and and or
Evaluating Applications
Abstration
Functions as Inputs
Function Abstraction
Problem Set 3
Higher-Order Functions
Working with Functions
Introduction
Anonymous Functions
Curried Functions
Problem Set 4
Nested Lambda-Expressions
Review for Test 2
Test 2
Anonymous Functions in Action
Data Abstraction
The Special Form let
The Special Form let*
The Special Form letrec
Problem Set 5
Some Useful Classes
Collections
A Container Class
Problem Set 6
Ordering and Sorting
Ordering Atoms
Introduction
Unicode
Lexicographical Order
Sorting
Introduction
Selection Sort
Insertion Sort
Merge Sort
Quick Sort
Tree Sort
Numbers
Working With Numbers Using Scheme
Mini-project: A Two-pan Balance
Introducing Rational Numbers
The Rational Numbers Data Type
Problem Set 7
Other Implementations of the Rational Numbers
Arithmetic Expressions
Introduction
Describing Arithmetic Expressions
Evaluating Arithmetic Expressions
Problem Set 8
Numbers and Evaluators
Review for Test 3
Test 3
Division and the Rational Numbers
The Rational Numbers in Scheme
Division
Haskell
Introduction to Haskell
A New Programming Language
Expressions, Lists and Tuples
Haskell Expressions
Infinite Lists
List Comprehensions
Tuples
Derived Functions
Haskell Derived Functions
Problem Set 9
What Next?
Artificial Intelligence
Introduction
Can Computers Learn?
The Game
The Game
Game Positions
Simple-minded Computer Players
Winning Moves
Problem Set 10
Smarter Computer Players
Quicker Computer Players
Expert Computer Players
Problem Set 11
Can You Beat the Computer?
