classes

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.

Overview

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]
Fundamentals
  • Explain the concept of modeling and the use of abstraction that allows the use of a machine to solve a problem. [Familiarity]
Processing
  • 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]

CSC 312 - Programming Language Implementation

CSC 312 is a proposed new course in Grinnell's computer science curriculum. It will be a two-credit course that replaces our existing CSC 302, Programming Languages, and CSC 362, Compilers.

Because our multi-paradigm introductory sequence covers many of the core topics in a traditional programming languages course, the new CSC 312 will focus on the implementation of programming languages, primarily through interpretation. It will include some study of syntax (regular expressions and BNF-style grammars) and semantics. It will likely cover the first half of Friedman and Wand's Essentials of Programming Languages.

Current Offering

No current offering

Learning Outcomes

Forthcoming: Learning outcomes from Computer Science Curricula 2013

Previous Offerings

No previous offerings.

CSC 207 - Object-Oriented Problem Solving and Algorithms

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.

Overview

CSC 207 is the third course in Grinnell's introductory computer science sequence and serves as the core gateway course to the majors. Students develop and analyze core data types (lists, stacks, queues, heaps, trees) and algorithms (primarily sorting and searching). Students also develop facility with object-oriented design. We use the Java programming language.

Starting in Fall 2013, CSC 207 has an experimental theme of Computing for Social Good. Students will work with free and open source projects that relate to the primary content of the course. We will leverage the Android platform for some of this development.

Catalog Description

An introduction to the ideas and practices of computation: message passing, information hiding, classes and interfaces, inheritance, polymorphism, and reflection. The course also includes data structures and the associated algorithms, packages and libraries, exceptions, and the use of an integrated software-development environment. Includes formal laboratory work.

Syllabus Description

Coming Soon

Class Format and Pedagogy

Coming Soon

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 161, students should achieve the following learning outcomes with the specified level of mastery:

Knowledge UnitLearning Outcome with [Level of Mastery]
Basic Analysis
  • Explain what is meant by “best”, “average”, and “worst” case behavior of an algorithm. [Familiarity]
  • In the context of specific algorithms, identify the characteristics of data and/or other conditions or assumptions that lead to different behaviors. [Assessment]
  • Determine informally the time and space complexity of simple algorithms. [Usage]
  • Understand the formal definition of big O. [Familiarity]
  • List and contrast standard complexity classes. [Familiarity]
  • Perform empirical studies to validate hypotheses about runtime stemming from mathematical analysis. Run algorithms on input of various sizes and compare performance. [Assessment]
  • Give examples that illustrate time-space trade-offs of algorithms. [Familiarity]
  • Use big O notation formally to give asymptotic upper bounds on time and space complexity of algorithms. [Usage]
  • Use big O notation formally to give expected case bounds on time complexity of algorithms. [Usage]
  • Explain the use of big omega, big theta, and little o notation to describe the amount of work done by an algorithm. [Familiarity]
Algorithmic Strategies
  • For each of the above strategies (brute force, greedy, divide and conquer, backtracking, dynamic), identify a practical example to which it would apply. [Familiarity]
  • Have facility mapping pseudocode to implementation, implementing examples of algorithmic strategies from scratch, and applying them to specific problems. [Usage]
  • Use a divide-and-conquer algorithm to solve an appropriate problem. [Usage]
Fundamental Data Structures and Algorithms
  • Implement simple search algorithms and explain the differences in their time complexities. [Usage, Assessment]
  • Be able to implement common quadratic and O(N log N) sorting algorithms. [Usage]
  • Understand the implementation of hash tables, including collision avoidance and resolution. [Familiarity]
  • Discuss the runtime and memory efficiency of principal algorithms for sorting, searching, and hashing. [Familiarity]
  • Discuss factors other than computational efficiency that influence the choice of algorithms, such as programming time, maintainability, and the use of application-specific patterns in the input data. [Familiarity]
  • Demonstrate the ability to evaluate algorithms, to select from a range of possible options, to provide justification for that selection, and to implement the algorithm in a particular context. [Usage, Assessment]
  • Understand the heap property and the use of heaps as an implementation of priority queues. [Familiarity]
Advanced Data Structures Algorithms and Analysis
  • Understand the mapping of real-world problems to algorithmic solutions (e.g., as graph problems, linear programs, etc.) [Usage, Assessment]
  • Apply advanced analysis techniques (e.g., amortized, probabilistic, etc.) to algorithms. [Familiarity]
Fundamentals
  • Explain the concept of modeling and the use of abstraction that allows the use of a machine to solve a problem. [Familiarity]
  • Describe the relationship between modeling and simulation, i.e., thinking of simulation as dynamic modeling.[Familiarity]
  • Create a simple, formal mathematical model of a real-world situation and use that model in a simulation. [Familiarity]
  • Describe several approaches to validating models. [Familiarity]
Processing
  • 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]
Graphs and Trees
  • Demonstrate different traversal methods for trees and graphs, including pre, post, and in-order traversal of trees. [Trees]
  • Model a variety of real-world problems in computer science using appropriate forms of graphs and trees, such as representing a network topology or the organizaiton of a hierarchical file system. [Trees]
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]
  • Use static and dynamic tools to identify programming faults. [Usage]
Data Modeling
  • Describe the main concepts of the OO model such as object identity, type constructors, encapsulation, inheritance, polymorphism, and versioning. [Familiarity]
Object-Oriented 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]
  • Use subclassing to design simple class hierarchies that allow code to be reused for distinct subclasses. [Usage]
  • Correctly reason about control flow in a program using dynamic dispatch. [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]
  • Explain the relationship between object-oriented inheritance (code-sharing and overriding) and subtyping (the idea of a subtype being usable in a context that expects the supertype). [Familiarity]
Functional Programming
  • Use multiple encapsulation mechanisms, such as function closures, object-oriented interfaces, and support for abstract datatypes, in multiple programming languages. [Usage]
Basic Type Systems
  • For multiple programming languages, identify program properties checked statically and program properties checked dynamically. Use this knowledge when writing and debugging programs. [Usage]
  • Define and use program pieces (such as functions, classes, methods) that use generic types. [Usage]
  • Explain benefits and limitations of static typing. [Familiarity]
Advanced Programming Constructs
  • Use various advanced programming constructs and idioms correctly. [Usage]
  • Discuss how various advanced programming constructs aim to improve program structure, software quality, and programmer productivity. [Familiarity]
  • Discuss how various advanced programming constructs interact with the definition and implementation of other language features. [Familiarity]
Algorithms and Design
  • Determine whether a recursive or iterative solution is most appropriate for a problem. [Assessment]
  • Apply the techniques of decomposition to break a program into smaller pieces. [Usage]
  • Identify the data components and behaviors of multiple abstract data types. [Usage]
  • Implement a coherent abstract data type, with loose coupling between components and behaviors. [Usage]
  • Identify the relative strengths and weaknesses among multiple designs or implementations for a problem. [Assessment]
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]
  • Design, implement, test, and debug a program that uses each of the following fundamental programming constructs: basic computation, simple I/O, standard conditional and iterative structures, the definition of functions, and parameter passing. [Usage]
  • Choose appropriate conditional and iteration constructs for a given programming task. [Assessment]
  • 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]
  • Compare alternative implementations of data structures with respect to performance. [Assessment]
  • Compare and contrast the costs and benefits of dynamic and static data structure implementations. [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]
  • Identify common coding errors that lead to insecure programs (e.g., buffer overflows, memory leaks, malicious code) and apply strategies for avoiding such errors. [Usage]
  • Conduct a personal code review (focused on common coding errors) on a program component using a provided checklist. [Usage]
  • Contribute to a small-team code review focused on component correctness. [Usage]
  • Describe how a contract can be used to specify the behavior of a program component. [Familiarity]
  • Create a unit test plan for a medium-size code segment. [Usage]
  • 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, execute and debug programs using a modern IDE and associated tools such as unit testing tools and visual debuggers. [Usage]
  • Construct and debug programs using the standard libraries available with a chosen programming language. [Usage]
  • Analyze the extent to which another programmer’s code meets documentation and programming style standards. [Assessment]
  • Apply consistent documentation and program style standards that contribute to the readability and maintainability of software. [Usage]
Requirement Engineering
  • Interpret a given requirements model for a simple software system. [Familiarity]
  • Conduct a review of a set of software requirements to determine the quality of the requirements with respect to the characteristics of good requirements. [Usage]
Software Design
  • Articulate design principles including separation of concerns, information hiding, coupling and cohesion, and encapsulation. [Familiarity]
  • Use a design paradigm to design a simple software system, and explain how system design principles have been applied in this design. [Usage]
  • Construct models of the design of a simple software system that are appropriate for the paradigm used to design it. [Usasge]
  • Design a contract for a typical small software component for use in a given system. [Usage]
Software Construction
  • Build robust code using exception handling mechanisms. [Usage]
Software Verification Validation
  • Describe the role that tools can play in the validation of software. [Familiarity]
  • Discuss the issues involving the testing of object-oriented software. [Usage]
Cross-Layer Communications
  • Find bugs in a layered program by using tools for program tracing, single stepping, and debugging. [Assessment]
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]
Professional Ethics
  • Identify ethical issues that arise in software development and determine how to address them technically and ethically. [Familiarity]
  • Recognize the ethical responsibility of ensuring software correctness, reliability and safety. [Familiarity]
  • Describe the strengths and weaknesses of relevant professional codes as expressions of professionalism and guides to decision-making. [??]
Professional Communication
  • Write clear, concise, and accurate technical documents following well-defined standards for format and for including appropriate tables, figures, and references. [Usage]
  • Evaluate written technical documentation to detect problems of various kinds. [Assessment]

Curriculum

Computer Science in the Academic Catalog

Vital Elements of Grinnell's Computer Science Curriculum

AI with Henry Walker

Grinnell's computer science curriculum has several special strengths, including:


Problem-Solving Perspectives

Computer science recognizes at least four problem-solving approaches as being fundamental to work in the discipline. Each approach involves a distinct way of thinking, and each is supported by a range of computer languages. These paradigms may be outlined as follows:

  • Functional Paradigm:
    Supported by such languages as Scheme, LISP, ML, Miranda
  • Imperative Paradigm:
    Supported by such languages as Pascal, C, FORTRAN
  • Object-Oriented Paradigm:
    Supported by such languages as Smalltalk, C++, Java
  • Logic Paradigm:
    Supported by such languages as Prolog, Gödel
Intro. CS with Janet Davis

Since different approaches have advantages for different problems, people involved with computing should be comfortable with several of these paradigms.

Grinnell's introductory courses provide students with considerable practice and insight for each of these approaches early in the curriculum, introducing the functional, object-oriented, and imperative paradigms.


Core courses in theory and systems

Grinnell's curriculum identifies both theory and systems as core areas, and the overall curriculum has achieved international recognition for four-year, undergraduate computer science programs.

  • Algorithms and theory: All majors take two foundational courses:
    • Analysis of algorithms
    • Automata, formal languages, and computational complexity
    Systems: All majors take at least one systems course; both of the following are strongly recommended
    • Computer organization and architecture
    • Operating systems and parallel algorithms
Intro. CS with John Stone

Software development project(s)

People use computers because they can provide services and help in the solving of problems. Thus, many courses and much research throughout the College utilize various aspects of computing. The computer science curriculum includes two upper-level courses with a strong software-development orientation.

  • Software development principles and practices examines methodologies for the effective development of large-scale software packages.
  • Team software development for community organizations provides students experience applying principles to actual projects that serve needs of clients within the community.

Electives provide options and flexibility

The computer science curriculum includes several electives, in addition to courses already mentioned. Students choose electives as well as foundational courses, as they work with their adviser about appropriate alternatives to support their interests and career goals. The following list of electives illustrates the range of topics offered regularly.

  • Artificial intelligence
  • Computer vision
  • Computer networks
  • Computer security
  • Human-computer interaction
  • Computational linguistics
  • Implementation of programming languages
  • Learning from alumni
  • Thinking in C and Unix

Syndicate content