CSC 151 - Functional Problem Solving

CSC 151, CSC 161, and CSC 207 — the three courses in Grinnell's multi-paradigm, introductory computer science sequence — have been recognized as "exemplar courses" by the ACM/IEEE-CS Task Force on Computing Curricula 2013.


CSC 151 is the first course in our multi-paradigm introductory sequence. Students develop basic facility with designing, implementing, and analyzing algorithms using a functional programming language (typically a variant of Scheme). For the past two decades we have been teaching our first class using a form of the flipped classroom - students read materials in advance of class and then spend class time working with a partner on a set of problems, with the instructor and class mentor providing advice and asking questions.

Starting in 2007, CSC 151 has focused on image computation as its domain for problem solving. That is, students write programs that make images using one of a variety of image-making paradigms, some imperative, some pure functional, some object-oriented.

Catalog Description

A lab-based introduction to basic ideas of computer science, including recursion, abstraction, scope and binding, modularity, the design and analysis of algorithms, and the fundamentals of programming in a high-level, functional language. Variable topic course. Includes formal laboratory work.

Current and Past Course Offerings

The department maintains a page of current and past course offerings.

Student Learning Outcomes

Computer Science Curricula 2013 (CS2013), national curricular recommendations from the ACM/IEEE-CS professional societies, identify an extensive list of learning outcomes for undergraduate computer science programs. Upon completing CSC 151, students should achieve the following learning outcomes with the specified level of mastery:

Knowledge UnitLearning Outcome with [Level of Mastery]
Algorithmic Strategies
  • Have facility mapping pseudocode to implementation, implementing examples of algorithmic strategies from scratch, and applying them to specific problems. [Familiarity]
  • Use a divide-and-conquer algorithm to solve an appropriate problem. [Usage]
  • Use recursive backtracking to solve a problem such as navigating a maze [Usage]
  • Explain the concept of modeling and the use of abstraction that allows the use of a machine to solve a problem. [Familiarity]
  • Analyze simple problem statements to identify relevant information and select appropriate processing to solve the problem. [Assessment]
  • Identify the issues impacting correctness and efficiency of a computation. [Familiarity]
Basics of Counting
  • Perform computations involving modular arithmetic. [Usage]
Fundamental Concepts
  • Identify common uses of computer graphics. [Familiarity]
  • Explain in general terms how analog signals can be reasonably represented by discrete samples, for example, how images can be represented by pixels. [Familiarity]
  • Describe color models and their use in graphics display devices. [Familiarity]
  • Describe the tradeoffs between storing information vs storing enough information to reproduce the information, as in the difference between vector and raster rendering. [Usage]
Basics Rendering
  • Model simple graphics images. [Usage]
  • Implement simple procedures that perform transformation and clipping operations on simple 2-dimensional images. [Usage]
Defensive Programming
  • Explain why you might choose to develop a program in a type-safe language like Java, in contrast to an unsafe programming language like C/C++ [Some Familiarity]
  • Demonstrate the identification and graceful handling of error conditions. [Usage]
Functional Programming
  • Compare and contrast (1) the procedural/functional approach—defining a function for each operation with the function body providing a case for each data variant, and (2) the object-oriented approach—defining a class for each data variant with the class definition providing a method for each operation. Understand both as defining a matrix of operations and variants. [Assessment]
  • Write basic algorithms that avoid assigning to mutable state or considering reference equality. [Usage]
  • Write useful functions that take and return other functions. [Usage]
  • Use multiple encapsulation mechanisms, such as function closures, object-oriented interfaces, and support for abstract datatypes, in multiple programming languages. [Usage]
  • Define and use iterators and other operations on aggregates using idioms most natural in multiple programming languages, including taking functions as arguments. [Usage]
Algorithms and Design
  • Discuss the importance of algorithms in the problem-solving process. [Familiarity]
  • Discuss how a problem may be solved by multiple algorithms, each with different properties.[Familiarity]
  • Create algorithms for solving simple problems. [Usage]
  • Use a programming language to implement, test, and debug algorithms for solving simple problems. [Usage]
  • Implement, test, and debug simple recursive functions and procedures.[Usage]
  • Apply the techniques of decomposition to break a program into smaller pieces. [Usage]
Fundamental Programming Concepts
  • Analyze and explain the behavior of simple programs involving the fundamental programming constructs covered by this unit. [Assessment]
  • Identify and describe uses of primitive data types. [Familiarity]
  • Write programs that use primitive data types. [Usage]
  • Modify and expand short programs that use standard conditional and iterative control structures and functions. [Usage]
  • Describe the concept of recursion and give examples of its use. [Familiarity]
  • Identify the base case and the general case of a recursively-defined problem. [Assessment]
Fundamental Data Structures
  • Discuss the appropriate use of built-in data structures. [Familiarity]
  • Describe common applications for each data structure in the topic list. [Familiarity]
  • Write programs that use each of the following data structures: arrays, strings, linked lists, stacks, queues, sets, and maps. [Usage - Maps]
  • Compare alternative implementations of data structures with respect to performance. [Assessment]
  • Choose the appropriate data structure for modeling a given problem. [Assessment]
Development Methods
  • Trace the execution of a variety of code segments and write summaries of their computations. [Assessment]
  • Explain why the creation of correct program components is important in the production of high-quality software. [Familiarity]
  • Refactor a program by identifying opportunities to apply procedural abstraction. [Usage]
  • Apply a variety of strategies to the testing and debugging of simple programs. [Usage]
  • Construct and debug programs using the standard libraries available with a chosen programming language. [Usage]
  • Apply consistent documentation and program style standards that contribute to the readability and maintainability of software. [Familiarity]
Social Context
  • Describe positive and negative ways in which computer technology (networks, mobile computing, cloud computing) alters modes of social interaction at the personal level. [Familiarity]
Syndicate content