Animated Problem Solving. An Introduction to Program Design Using Video Game Development

Preface
	1 The Languages and the Parts of the Book
	2 Acknowledgments
Part I The Basics of Problem Solving with a Computer
	1 The Science of Problem Solving
		3 Getting Started
		4 Computing New Values
		5 Definitions and Interactions Areas Differences
		6 Saving Your Work
		7 Error Messages
			7.1 Grammatical Errors
			7.2 Type Errors
			7.3 Runtime Errors
		8 What Have We Learned in This Chapter?
	2 Expressions and Data Types
		9 Definitions
		10 Numbers
		11 Strings and Characters
		12 Symbols
		13 Booleans
			13.1 Basic Boolean Operators in BSL
			13.2 Predicates
		14 Images
			14.1 Basic Image Constructors
			14.2 Property Selectors
			14.3 Image Composers
			14.4 Empty Scenes and Placing Images
		15 What Have We Learned in This Chapter?
	3 The Nature of Functions
		16 The Rise of Functions
		17 General Design Recipe for Functions
			17.1 The Design Recipe in Action
		18 Auxiliary Functions
			18.1 Bottom-Up Design
		19 Top-Down Design
		20 What Have We Learned in This Chapter?
	4 Aliens Attack Version 0
		21 The Scene for Aliens Attack
		22 Creating Aliens Attack Images
		23 Shot Image
		24 Alien Image
		25 Rocket Image
			25.1 Rocket Window Image Constructor
			25.2 Rocket Fuselage Image Constructor
			25.3 Rocket Single Booster Image Constructor
			25.4 Rocket Booster Image Constructor
			25.5 Rocket Main Body Image Constructor
			25.6 Rocket Nacelle Image Constructor
			25.7 Rocket ci Constructor
		26 Drawing Functions
		27 What Have We Learned in This Chapter?
	5 Making Decisions
		28 Conditional Expressions in BSL
		29 Designing Functions to Process Data with Variety
		30 Enumeration Types
		31 Interval Types
		32 Itemization Types
		33 What Have We Learned in This Chapter?
	6 Aliens Attack Version 1
		34 The Universe Teachpack
		35 A Video Game Design Recipe
		36 Adding the Rocket to Aliens Attack
		37 What Have We Learned in This Chapter?
Part II Compound Data of Finite Size
	7 Structures
		38 The posn Structure
		39 Going Beyond the Design Recipe
		40 Revisiting in-Q1?
		41 What Have We Learned in This Chapter?
	8 Defining Structures
		42 Defining Structures
		43 Computing Structures
		44 Structures for the Masses
		45 What Have We Learned in This Chapter?
	9 Aliens Attack Version 2
		46 Data Definitions
		47 Function Templates and Sample Instances
		48 The run Function
		49 Drawing the World
			49.1 The draw-world Refinement
			49.2 Drawing Aliens
		50 The process-key Refinement
		51 Processing Ticks
			51.1 The process-tick Handler
			51.2 The Design of new-dir-after-tick
			51.3 The Design of Auxiliary Functions for new-dir-after-tick
				51.3.1 Design of new-dir-after-down
				51.3.2 Design of new-dir-after-left
				51.3.3 Design of new-dir-after-right
				51.3.4 Design of alien-at-left-edge?
				51.3.5 Design of alien-at-right-edge?
			51.4 The Design of move-alien
		52 Subtyping
			52.1 Checking Errors
		53 The game-over? Handler
		54 Computing the Last Scene
		55 What Have We Learned in This Chapter?
	10 Structures and Variety
		56 A Bottom-Up Design
		57 Code Refactoring
		58 What Have We Learned in This Chapter?
	11 Aliens Attack Version 3
		59 Data Definitions
		60 The draw-world Refinement
		61 The process-key Refinement
		62 The process-tick Refinement
			62.1 The Refinement
			62.2 The move-shot Design
		63 The game-over? Refinement
			63.1 The hit? Design
			63.2 The draw-last-world Refinement
		64 What Have We Learned in This Chapter?
Part III Compound Data of Arbitrary Size
	12 Lists
		65 Creating and Accessing Lists in ISL+
		66 Shorthand for Building Lists
		67 Recursive Data Definitions
		68 Generic Data Definitions
		69 Function Templates for Lists
		70 Designing List-Processing Functions
		71 What Have We Learned in This Chapter?
	13 List Processing
		72 List Summarizing
		73 List Searching
		74 List ORing
			74.1 Determining If an Alien Is at the Left Edge
			74.2 Determining If an Alien Is at the Right Edge
			74.3 Determining If an Alien Has Reached Earth
		75 List ANDing
			75.1 All Even in a lon
			75.2 Determining if a lon Is Sorted
		76 List Mapping
			76.1 Moving a List of Aliens
			76.2 Moving a List of Shots
			76.3 Returning a Different List Type
		77 List Filtering
			77.1 Extracting Even numbers
			77.2 Removing Hit Aliens
			77.3 Removing Shots
		78 List Sorting
		79 What Have We Learned in This Chapter?
	14 Natural Numbers
		80 Data Definition for a Natural Number
		81 Computing Factorial
		82 Computing Tetrahedral Numbers
		83 Making Copies
		84 What Have We Learned in This Chapter?
	15 Interval Processing
		85 Interval Data Definition
		86 Revisiting Factorial
		87 Creating an Army of Aliens
		88 Largest Prime in an Interval
		89 What Have We Learned in This Chapter?
	16 Aliens Attack Version 4
		90 New world Data Definition and Function Template
		91 The draw-world Refinement
		92 The process-key Refinement
		93 The process-tick Refinement
			93.1 The new-dir-after-tick Design
				93.1.1 The new-dir-after-down Design
				93.1.2 The new-dir-after-left Design
				93.1.3 The new-dir-after-right Design
		94 The game-over? Refinement
			94.1 The draw-last-world Refinement
		95 A Bug Despite Hundreds of Tests Passing
		96 What Have We Learned in This Chapter?
	17 Binary Trees
		97 Binary Tree Data Definition
		98 Traversing a Binary Tree
		99 The Maximum of a (btof int)
		100 Binary Search Trees
			100.1 A (listof cr) Representation
			100.2 A (btof cr) Representation
			100.3 A (bstof cr) Representation
		101 Abstract Running Time
		102 The Complexity of Searching the Criminal Database
		103 Balanced (bstof cr)
			103.1 Creating a Balanced Binary Search Tree
			103.2 Analysis
		104 What Have We Learned in This Chapter?
	18 Mutually Recursive Data
		105 Designing with Mutually Recursive Data
			105.1 Revisiting the Maximum of a (btof int)
		106 Evaluating Arithmetic Expressions
		107 Trees
			107.1 Creating a Search Tree for Tic Tac Toe
			107.2 Can Win Tic Tac Toe?
		108 Project: Tic Tac Toe
			108.1 Data Analysis
			108.2 Design draw-world
			108.3 Design process-mouse
			108.4 Design process-tick
			108.5 Design game-over?
		109 What Have We Learned in This Chapter?
	19 Processing Multiple Inputs of ArbitrarySize
		110 One Input Has a Dominant Role
		111 Inputs Must Be Processed Simultaneously
		112 No Clear Relationship Between the Inputs
		113 What Have We Learned in This Chapter?
Part IV Abstraction
	20 Functional Abstraction
		114 A Design Recipe for Abstraction
		115 Functions as Values
		116 Abstraction Over List-Processing Functions
			116.1 List Summarizing
			116.2 List Searching
			116.3 List ORing
			116.4 List ANDing
			116.5 List Mapping
			116.6 List Filtering
			116.7 List Sorting
		117 Abstraction over Interval-Processing Functions
		118 What Have We Learned in This Chapter?
	21 Encapsulation
		119 Local-Expressions
		120 Lexical Scoping
		121 Using Local-Expressions
			121.1 Encapsulation
			121.2 Readability
			121.3 Furthering Functional Abstraction
			121.4 One-Time Expression Evaluation
		122 What Have We Learned in This Chapter?
	22 Lambda Expressions
		123 Anonymous Functions
		124 Revisiting Function Composition
		125 Curried Functions
		126 Designing Using Existing Abstractions
			126.1 Computing the Value of a Series
			126.2 Approximating π
		127 What Have We Learned in This Chapter?
	23 Aliens Attack Version 5
		128 Constants
		129 Structure Definitions
		130 Encapsulating and Refactoring Handlers
			130.1 The draw-world Handler
			130.2 The process-key Handler
			130.3 The process-tick Handler
			130.4 The game-over? Handler
			130.5 The draw-last-world Handler
		131 Refactoring run
		132 What Have We Learned in This Chapter?
	24 For-Loops and Pattern Matching
		133 For-Loops
			133.1 for-loops
			133.2 for*-loops
		134 Pattern Matching
			134.1 Illustrative Example
			134.2 Refactoring Using Pattern Matching
			134.3 Designing Using Pattern Matching
		135 What Have We Learned in This Chapter?
	25 Interfaces and Objects
		136 Interfaces
			136.1 Improving the Human Interface
			136.2 Services that Require More Input
		137 A Design Recipe for Interfaces
		138 Interfaces and Union Types
		139 An Abbreviated (listof X) Interface
			139.1 Step 1: Values and Services
			139.2 Step 2: Interface and Message Definitions
			139.3 Step 3: Class Function Template
		140 The Empty (listof X) Class
			140.1 Step 4: Signature, Purpose, Class Header, and Message-Passing Function
			140.2 Step 5: Auxiliary Functions
		141 The Non-Empty (listof X) Class
			141.1 Step 4: Signature, Purpose, Class Header, and Message-Passing Function
			141.2 Step 5: Auxiliary Functions
		142 Step 6: Wrapper Functions and Tests
		143 What Have We Learned in This Chapter?
	26 Introduction to Distributed Programming
		144 A Design Recipe for Distributed Programming
		145 More on the Universe API
		146 A Chat Application
			146.1 The Components
			146.2 Data Definitions
			146.3 Communication Protocol
			146.4 Marshalling and Unmarshalling
			146.5 Component Implementation
				146.5.1 Client
				146.5.2 Server
			146.6 Running the Chat Tool
		147 What Have We Learned in This Chapter?
	27 Aliens Attack Version 6
		148 Refining the world Data Definition
		149 The draw-world Refinement
		150 The process-key Refinement
		151 The process-tick Refinement
		152 The game-over? Refinement
		153 What Have We Learned in This Chapter?
	28 Aliens Attack Version 7
		154 Components
		155 Data Definitions
		156 Communication Protocol
			156.1 Player-Sparked Communication Chains
			156.2 Server-Sparked Communication Chains
			156.3 Message Data Definitions
				156.3.1 Marshaled Data Definition
				156.3.2 To-Player Message Data Definition
				156.3.3 To-Server Message Data Definition
		157 Marshalling and Unmarshalling
		158 Component Implementation
			158.1 Player Component
				158.1.1 The process-key Refinement
				158.1.2 The process-message Design
			158.2 Server Component
				158.2.1 The add-player Handler
				158.2.2 The rm-player Handler
				158.2.3 The process-message Handler
		159 A Subtle Bug
		160 What Have We Learned in This Chapter?
	29 Aliens Attack Version 8
		161 The Components
		162 Data Definitions
		163 Communication Protocol
			163.1 Player-Sparked Communication Chains
			163.2 Server-Sparked Communication Chains
			163.3 Message Data Definitions
		164 Marshalling and Unmarshalling
		165 Component Implementation
			165.1 Player Component
				165.1.1 The draw-world and game-over? Handlers
				165.1.2 The process-key Handler
				165.1.3 The process-message Handler
			165.2 Server Component
				165.2.1 The process-tick Handler
				165.2.2 The process-message Handler
				165.2.3 The add-player Handler
				165.2.4 The rm-player Handler
		166 A Subtle Problem
		167 What Have We Learned in This Chapter?
Part V Distributed Programming
Part VI Epilogue
	30 Advice for Future Steps
		168 Advice for Computer Science Students
		169 Advice for Non-Computer Science Students