courses

A Possible Revision of Grinnell's CS Curriculum and Major

Grinnell's CS faculty regularly reviews and updates the CS curriculum in response to curricular recommendations, feedback from alumni, and discussions with colleagues around the country. For example, over several semesters, the faculty has drawn upon feedback in discussing alternative approaches for team-based, project courses.

Also since 2010, the major professional computing societies, ACM and IEEE-CS, have been working toward new curricular recommendations for undergraduate CS. The forthcoming recommendations propose adjustments in some areas (e.g., programming languages) and substantial expansion in others (e.g., security).

Recently, synergy between these two efforts has led to a proposal for substantial changes in Grinnell's CS program, including some course revisions, new courses in emerging areas, and increased flexibility in the major.

The CS faculty will present current ideas for a revised CS curriculum and major on Monday, November 11, 2013, at 4:30 in Science 3821, with refreshments served at 4:15 pm in the CS Commons. Everyone interested in computing is encouraged to attend.

Feedback on the draft curriculum and major will be encouraged!

CSC 161 – Imperative Problem Solving and Data Structures

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 161 utilizes robotics as an application domain in studying imperative problem solving, data representation, and memory management. Additional topics include assertions and invariants, data abstraction, linked data structures, an introduction to the GNU/Linux operating system, and programming the low-­level, imperative language C.   The review of CS 2013 identified some refinements of coverage for CSC 161, but substantial changes are not anticipated. The course follows a lab-based format that emphasizes both collaborative learning and individual problem solving.

Catalog Description

A continuation of CSC 151, bringing in some concepts more closely tied to the architecture of computers, compilers, and operating systems, such as macro processing, compilation and linking, pointers and memory management, data representation, and software development tools. Additional topics include assertions and invariants, data abstraction, linked data structures, an introduction to the use of the GNU/Linux operating system, and programming in a low-level, imperative language. Variable topic course. Includes formal laboratory work.

Syllabus Description

This course explores elements of computing that have reasonably close ties to the architecture of computers, compilers, and operating systems. The course takes an imperative view of problem-solving, supported by programming in the C programming language. Some topics include:

  • imperative problem solving: top-down design, common algorithms, assertions, invariants
  • C programming: syntax and semantics, control structures, functions, parameters, macro processing, compiling, linking, program organization
  • concepts with data: data abstraction, integer and floating-point representation, string representation, arrays, unions, structures, linked list data structures, stacks, and queues
  • machine-level issues: data representation, pointers, memory management
  • GNU/Linux operating system: commands, bash scripts, software development tools

Class Format and Pedagogy

Topics in this course are organized into eight modules and a few supplementary labs. A typical modules includes:

  • An opening session to introduce fundamental material,
  • 3-5 laboratory sessions to allow students to engage the material, and
  • a concluding integrative project.

In-class laboratory sessions encourage collaborative work — usually working in pairs. In addition, supplementary homework assignments and tests will involve individual 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 161, students should achieve the following learning outcomes with the specified level of mastery:

Knowledge UnitLearning Outcome with [Level of Mastery]
Basic Analysis
  • In the context of specific algorithms, identify the characteristics of data and/or other conditions or assumptions that lead to different behaviors. [Familiarity]
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]
Fundamental Data Structures and Algorithms
  • Implement basic numerical algorithms. [Usage]
  • Implement simple search algorithms and explain the differences in their time complexities. [Usage, Assessment]
  • 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]
Machine-level representation of data
  • Explain the reasons for using alternative formats to represent numerical data. [Familiarity]
  • Describe how negative integers are stored in sign-magnitude and twos-complement representations. [Familiarity]
  • Explain how fixed-length number representations affect accuracy and precision. [Familiarity]
  • Describe the internal representation of non-numeric data, such as characters, strings, records, and arrays. [Familiarity]
  • Convert numerical data from one format to another. [Usage]
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]
Processing
  • Analyze simple problem statements to identify relevant information and select appropriate processing to solve the problem. [Assessment]
  • Explain how data is represented in a machine. Compare representations of integers to floating point numbers. Describe underflow, overflow, round off, and truncation errors in data representations. [Familiarity]
  • Identify the issues impacting correctness and efficiency of a computation. [Familiarity]
Basics of Counting
  • Perform computations involving modular arithmetic. [Usage]
Defensive Programming
  • Demonstrate the identification and graceful handling of error conditions. [Usage]
Robotics
  • Integrate sensors, actuators, and software into a robot designed to undertake some task. [Usage]
  • Program a robot to accomplish simple tasks using deliberative, reactive, and/or hybrid control architectures. [Usage]
  • Characterize the uncertainties associated with common robot sensors and actuators; articulate strategies for mitigating these uncertainties. [Familiarity]
Basic Type Systems
  • Explain how programming language implementations typically organize memory into global data, text, heap, and stack sections and how features such as recursion and memory management map to this memory model. [Familiarity]
Language Translation and Execution
  • Explain how programming language implementations typically organize memory into global data, text, heap, and stack sections and how features such as recursion and memory management map to this memory model. [Familiarity]
  • Reason about memory leaks, dangling-pointer dereferences, and the benefits and limitations of garbage collection. [Usage]
Advanced Programming Constructs
  • Use various advanced programming constructs and idioms correctly. [Usage]
Algorithms and Design
  • Determine whether a recursive or iterative solution is most appropriate for a problem. [Assessment]
  • Implement a divide-and-conquer algorithm for solving a problem. [Usage]
  • Apply the techniques of decomposition to break a program into smaller pieces. [Usage]
  • Implement a coherent abstract data type, with loose coupling between components and behaviors. [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]
  • 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]
  • Write a program that uses file I/O to provide persistence across multiple executions. [Usage]
  • Choose appropriate conditional and iteration constructs for a given programming task. [Assessment]
  • 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]
  • 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. [Usage]
Software Design
  • Construct models of the design of a simple software system that are appropriate for the paradigm used to design it. [Usage]
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. [Familiarity]
  • Evaluate the professional codes of ethics from the ACM, the IEEE Computer Society, and other organizations. [Assessment]
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]

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]

Course archive: links to courses past and present

In the current catalog

CSC 105: The digital age

Weinman
Wolz
  • spring 2017
Davis
Coahran
  • spring 2010
  • spring 2008

CSC 151: Functional problem solving

Curtsinger
Klinge
Rebelsky
Weinman
Davis
Price Jones

CSC 161: Imperative problem solving and data structures

Klinge
Osera
Stone
  • spring 2016
Walker
Rebelsky
Coahran
  • spring 2009
  • fall 2008

CSC 205: Computational linguistics

Stone
  • fall 2016
  • fall 2010
  • fall 2008
  • fall 2006
  • fall 2004
  • fall 2002
Price Jones

CSC 207: Algorithms and object-oriented design

Osera
Rebelsky
Walker
Weinman

CSC 208: Discrete structures

Stone
  • spring 2016
  • spring 2014
  • spring 2013

CSC 211: Computer organization and architecture

Curtsinger
  • fall 2016
  • spring 2016
Davis
Coahran
  • fall 2009
  • fall 2007
Gum
  • fall 2005
Bishop
  • fall 2003
Walker

CSC 213: Operating systems and parallel algorithms

Curtsinger
  • spring 2017
Weinman
Davis
Walker
Bishop
  • fall 2002 (two sections)

CSC 214: Computer and Network Security

Stone
  • spring 2017

CSC 232: Human-computer interaction

Davis

CSC 261: Artificial intelligence

Weinman
Walker
Stone
  • fall 2003

CSC 282: Thinking in C and Linux

Rebelsky
  • spring 2017

CSC 301: Analysis of algorithms

Wolz
  • spring 2017
  • spring 2016
Walker
Stone
  • fall 2016
  • fall 2012
  • fall 2010

CSC 321: Software development principles and practices

Rebelsky

CSC 322: Team software development for community organizations

Rebelsky

CSC 341, Automata, formal languages, and computational complexity

Osera
Klinge
Walker
Price Jones
Stone
  • spring 2011
  • spring 2007
  • spring 2006
  • spring 2005
  • spring 2004
  • spring 2001
  • spring 1997
  • spring 1995
Gum
  • spring 2003
  • spring 2002
Jones
  • spring 1993
Moore
  • spring 1991

CSC 364: Computer networks

Davis
Stone
  • spring 2002
Rebelsky

CSC 195: Introductory special topics

Rebelsky
Walker

CSC 295: Special topics

Rebelsky
Davis
Weinman
Praitis
Coahran
  • Computer graphics, spring 2009
Cunningham
  • Computer graphics for science, spring 2006
Silkin
  • Introduction to bioinformatics algorithms, spring 2005
Borenstein
  • Human-computer interface design, spring 1999
Walker

CSC 297: Guided reading

Davis
  • Computing and health care, spring 2011
Rebelsky
  • Women in computing, fall 2007 (with Davis)
  • Programming Actionscript, spring 2007
  • The TAO of Java, fall 2003
  • Web technologies, spring 2004
  • Web technologies, fall 2003
Walker
  • Women and computing, fall 2005
  • Neural networks, fall 2000
  • System administration theory, spring 1998
  • Language analysis, spring 1994
  • Artificial intelligence and predicate calculus theorem-proving, spring 1993
  • Artificial intelligence and Scheme, fall 1992
  • Database principles, spring 1992
Stone
  • Copyright alternatives, spring 2005
  • Linux kernel programming, spring 2003
  • Artificial intelligence, fall 1997
  • Artificial intelligence, fall 1996
  • Scheme and computer science theory, spring 1995
  • C++, fall 1990

CSC 299: Directed research

Weinman
  • Word image normalization, fall 2013
  • Word image normalization, summer 2013
Rebelsky
  • Computing for social good: media computation, summer 2013
  • Techniques for mediascripting, spring 2013
  • Media scripting, summer 2012
  • InterArts: image, sound, and gesture, summer 2012
  • Media scripting, summer 2011
  • Higher-order media computation, summer 2007
  • Functional multimedia, summer 2006
  • Automated group scheduler, summer 2004
  • Mediating the Web, summer 2003
  • Visualizing Web usage,, summer 2003
  • Three-dimensional Web visualizations, summer 2002
  • Web mediation tools, summer 2002
  • Data mining use logs, summer 2002
Walker
  • Refining a C with robots course, fall 2011
  • Introducing C with robots, summer 2011
  • Automating athletic recruiting, summer 2005
Davis
  • Usable functional media computation, summer 2007
Stone
  • Restoring Greek, spring 2007
  • Syndication software development, summer 2005

CSC 395: Advanced special topics

Curtsinger
  • Data Visualization spring 2017
Osera
  • Modern programming principles, fall 2016
Gum
  • Algorithms for practical problems, spring 2003
Bishop
  • Cryptology, fall 2001

CSC 397: Independent project

Davis
  • Design technology and wellness behaviors, fall 2013
  • Advanced Web application development: the Local Foods Web site, fall 2013
  • Web application design and usability, spring 2013
  • Advanced Web application development: the Local Foods Web site, spring 2013
  • Usable Web application development: Grinnell Textbook Lending Library, spring 2013
  • The design and implementation of FreeBSD, spring 2008
Stone
  • Programming for the common good, spring 2011
  • Computer learning and problem solving, spring 2006
  • Extended study in software design, spring 2000
  • Logic and languages, fall 1995
  • Computer graphics, spring 1995
  • The Grinnell Scheme interpreter, spring 1994
  • Software design and implementation, spring 1994
  • Functional languages, spring 1993
  • Computational linguistics, spring 1993
  • Artificial intelligence and pattern recognition, spring 1993
  • Computer science and artificial intelligence, spring 1992
Silkin
  • Introduction to biocomputing, spring 2007
  • Advanced Windows programming, spring 2006
Rebelsky
Walker
  • Topics in computer networking, spring 2005
  • Topics in computer networking, spring 2004
  • Palm program applications, fall 2000
  • Computer graphics algorithms, fall 2000
  • Database design, fall 2000
  • Study of the TCP/IP protocol, spring 2000
  • Software engineering, spring 1998
  • Paradigms and lab development, spring 1998
  • Software optimization, spring 1994
  • Expert systems, spring 1993
  • Interprocess communication, spring 1992
  • Advanced parsing techniques, spring 1991
  • Expert system design, spring 1991
Gum
  • Heuristics for tutorial placement, spring 2003
  • NP-hard problem heuristics, spring 2002
Moore
  • Programming in C, fall 1996
Sinnett
  • Computers in psychology, spring 1991

CSC 399: Directed research

Rebelsky
  • Interactive media scripting, summer 2009
  • Web mediation tools, summer 2002
  • Annotating the World Wide Web, summer 2001
  • Clio: exploring Web usage, summer 2001
  • Hypertext transformations, summer 2001
  • Hypermedia research, summer 2000
  • A Web history analyzer, summer 2000
  • Annotating the World Wide Web, summer 1999
  • Siteweaver research, summer 1999
  • Hypermedia, summer 1998
Walker
Coahran
  • Sketch-based Bargello, summer 2008
Moore
  • Visual graph theory, summer 1995

CSC 499: Mentored advanced project

Davis
  • Design technology and wellness behaviors, fall 2013
  • Design technology and wellness behaviors, summer 2013
  • Technology and incentives, fall 2012
  • Just-in-time vulnerability prevention in Linux, spring 2012
  • Improving the user interface of the Local Foods Co-op Web site, summer 2011
  • Persuasive Web community, summer 2010
  • PD of ambient personal technology, summer 2008
  • Usable functional media computation, summer 2007
Walker
Rebelsky
  • Computing for social good: media computation, summer 2013
  • Generative art, spring 2013
  • Media scripting, fall 2012
  • Media scripting, summer 2012
  • InterArts: code, sound, and image, summer 2012
  • Media scripting, summer 2011
  • Designing multifactor experiments, summer 2009
  • Interactive media scripting, summer 2009
  • Higher-order media computation, summer 2007
  • Functional approaches to multimedia, summer 2006
  • Experiments in programming languages, fall 2005
  • Compiling functional languages, spring 2005
  • Freedweb: a peer-to-peer Web server, summer 2004
  • A stand-alone spam filter, summer 2004
  • Robotic art, fall 2003
  • Web mediation, summer 2003
  • Visualizing Web data, summer 2003
  • Educational Web technology, summer 2003
  • Computerizing room draw, spring 2003
  • Automatic glossary linking, spring 2003
  • Data mining use logs, summer 2002
  • Three-dimensional Web visualization, summer 2002
Weinman
  • Word image normalization, summer 2013
  • Word image normalization (two sections), summer 2011
  • Map character recognition, fall 2010
  • Multiple GPU machine learning, fall 2010
  • Map character recognition, summer 2010
  • GPU learning and character recognition, summer 2009
  • Visual category recognition, summer 2009
Stone
  • Compression algorithms and techniques, spring 2009
Kuiper
  • Simulation of ungulate grazing, spring 2005
Bishop
  • Ray tracing II, spring 2004
  • Ray tracing, fall 2003
  • Online FB computing in real time, spring 2003
  • A multiprotocol mail client, fall 2002
Gum
  • Heuristics for tutorial placement, spring 2003
  • Massive data computation, summer 2002

No longer offered

CSC 103: Problem solving and computing

Moore
  • spring 2001
  • spring 1997
  • spring 1995
  • spring 1993
  • spring 1992
Rebelsky

CSC 105: An algorithmic and social overview of computer science

Coahran spring 2007
Walker
Bishop
  • fall 2001
Rebelsky

CSC 151: Fundamentals of computer science I

Davis
Rebelsky
Matocha
  • spring 2006
Walker
Gum
  • fall 2005
  • fall 2003
  • spring 2003
  • fall 2002
  • spring 2002 (two sections)
  • fall 2011
Silkin
  • spring 2005
  • fall 2004
Stone
  • spring 2005
  • spring 2004
  • fall 2001
  • spring 2000
  • spring 1998
  • spring 1997
Flynt
  • spring 1999
Moore
  • fall 1996

CSC 151: Computer programming with Pascal

Jones
  • spring 1996
  • fall 1995
Moore
  • spring 1996
  • fall 1994
  • spring 1994
  • fall 1990
Walker
  • spring 1995 (two sections)
  • spring 1994
  • spring 1993
  • spring 1992 (two sections)
  • spring 1991 (two sections)
Stone
  • fall 1993
  • spring 1993
  • fall 1991

CSC 152: Fundamentals of computer science II

Stone
  • spring 2008
  • fall 2007
Coahran
  • spring 2007
  • fall 2006
Rebelsky
Bishop
  • spring 2004
  • fall 2003
  • spring 2003
  • fall 2002
  • spring 2002
  • fall 2001
Walker
Flynt
  • spring 1999

CSC 153: Computer science fundamentals

Walker
Rebelsky

CSC 201: Memory management, data representation, and formal methods

Coahran
  • spring 2008
  • spring 2007
Matocha
  • spring 2006
Walker
Bishop
  • spring 2004

CSC 206: Fundamentals of computer science II

Moore
  • spring 1997
Stone
  • fall 1996
  • spring 1996

CSC 206: Fundamentals of computer science

Stone
  • spring 1995
  • spring 1994 (two sections)
  • fall 1992
  • fall 1990
Moore
  • fall 1994
Walker
  • spring 1993
  • spring 1992
Jones
  • spring 1991

CSC 207: Computer architecture and operating systems

Walker
  • fall 1996
  • fall 1994
  • fall 1992
  • fall 1990

CSC 223: Software design

Davis
Walker
Rebelsky
Bishop
  • spring 2003
  • spring 2002
Stone
  • fall 1999

CSC 223: Algorithms and software design

Rebelsky
Stone
  • fall 1995
  • fall 1993
  • fall 1991

CSC 301: Algorithms

Coahran
  • fall 2007
  • fall 2006
Gum
  • fall 2005
  • fall 2003
  • fall 2002
  • fall 2001
Silkin
  • fall 2004
Stone
  • fall 2000
  • fall 1999
Walker

CSC 301: Algorithms and data structures

Stone
  • fall 1997
Moore
  • fall 1995
  • fall 1991
Walker
  • fall 1993

CSC 302: Programming language concepts

Price Jones
Rebelsky
Stone
  • spring 2009
  • spring 2008
  • spring 2003
  • spring 2002
  • spring 1996
  • spring 1992
Walker

CSC 323: Software design

Stone
  • spring 2014
  • spring 2012
Rebelsky

CSC 325: Databases and Web application design

Davis
Rebelsky
Walker

CSC 362: Compilers

Stone
Rebelsky

Placement of incoming students in computer science, mathematics, and statistics

The faculty in computer science, mathematics, and statistics at Grinnell College devote considerable attention to advising incoming students about where they might best begin their coursework. As part of this effort, both faculty and students participate in an on-going research project which uses techniques of artifical intelligence in decision making. While final placement decisions are always the result of discussion between students and faculty, an expert system may be helpful in suggesting possible placements.

In order to utilize this expert system, you may enter appropriate scores into the following table. Leave any box blank, if that information is unavailable.


Scores on National Tests:

Standardized Tests: Math SAT Math ACT
Advanced Placement(AP): Calculus AB Calculus BC
Computer Science A Computer Science AB
Statistics
International Baccalaureate (IB): Math Computer Science
Subjects:
Total Math Semesters Math Grade
Calculus Semesters Calculus Grade
Pre-Calculus Semesters Pre-Calculus Grade
Computer Science Semesters Computer Science Grade
Statistics Semesters Statistics Grade


Notes:

  • The placement expert system analyzes only high school transcript information and various standardized tests; courses taken at colleges are considered in a later phase rather than by the expert system.
  • All placements given are unofficial and should be considered tentative. As already noted, students consult with faculty whenever questions arise concerning placement.
  • While Grinnell College will not record your inquiry in any way, neither your data nor the response will be transmitted in encrypted form. Thus, as with passing of data over the Internet, there may be some risk that another party will be able to capture all or part of the data transmitted.

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