Computer Science | Grinnell College

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!

• Overview
• Catalog Description
• Syllabus Description
• Class Format and Pedagogy
• Current and Past Offerings
• Student Learning Outcomes

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.

• Full listing of current and past computer science courses
• Listing of current and past offerings of CSC 161

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 Unit	Learning 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]

• Overview
• Catalog Description
• Syllabus Description
• Class Format and Pedagogy
• Current and Past Offerings
• Student Learning Outcomes

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.

• Full listing of current and past computer science courses
• Listing of current and past offerings of CSC 151

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 Unit	Learning 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 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.

• Overview
• Catalog Description
• Syllabus Description
• Class Format and Pedagogy
• Current and Past Offerings
• Student Learning Outcomes

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.

• Full listing of current and past computer science courses
• Listing of current and past offerings of CSC 207

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 Unit	Learning 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 organization 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]

In the current catalog

CSC 105: The digital age

Weinman	spring 2014 spring 2011 spring 2009
Wolz	spring 2017
Davis	spring 2013 spring 2012
Coahran	spring 2010 spring 2008

CSC 151: Functional problem solving

Curtsinger	fall 2016 spring 2016
Klinge	spring 2018 fall 2017 spring 2017 fall 2016
Rebelsky	spring 2018 fall 2017 spring 2017 spring 2016 spring 2014 fall 2013 spring 2010 fall 2009
Weinman	spring 2014 fall 2012 fall 2011 spring 2011 fall 2010 spring 2010 fall 2009 spring 2009 fall 2008
Davis	fall 2013 spring 2012 fall 2011 spring 2011 fall 2010 fall 2008
Price Jones	spring 2013 fall 2012

CSC 161: Imperative problem solving and data structures

Klinge	spring 2017
Osera	spring 2017 spring 2016
Rebelsky	spring 2011 fall 2010
Stone	spring 2016
Walker	spring 2018 fall 2016 spring 2014 fall 2013 spring 2013 fall 2012 spring 2012 fall 2011 spring 2010 spring 2009
Weinman	fall 2017
Coahran	spring 2009 fall 2008

CSC 205: Computational linguistics

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

CSC 207: Algorithms and object-oriented design

Osera	fall 2017 spring 2017 fall 2016 spring 2016
Rebelsky	spring 2014 fall 2013
Vostinar	spring 2018 fall 2017
Walker	spring 2013 spring 2012
Weinman	spring 2011 spring 2010

CSC 208: Discrete structures

Osera	spring 2018 fall 2017
Stone	spring 2016 spring 2014 spring 2013

CSC 211: Computer organization and architecture

Curtsinger	fall 2017 fall 2016 spring 2016
Davis	fall 2013 fall 2011
Coahran	fall 2009 fall 2007
Gum	fall 2005
Bishop	fall 2003
Walker	fall 2001 fall 1999 fall 1997

CSC 213: Operating systems and parallel algorithms

Curtsinger	spring 2018 spring 2017
Weinman	fall 2012 fall 2008
Davis	fall 2010 fall 2006
Walker	fall 2004 fall 2000 fall 1998
Bishop	fall 2002 (two sections)

CSC 214: Computer and network security

Stone	spring 2017

CSC 216: Computer networks

Osera	spring 2018

CSC 232: Human-computer interaction

Davis	spring 2011

CSC 261: Artificial intelligence

Weinman	spring 2018 fall 2013 fall 2011 fall 2009
Walker	fall 2007 spring 1998
Stone	fall 2003

CSC 282: Thinking in C and Linux

Rebelsky	spring 2017

CSC 301: Analysis of algorithms

Rebelsky	fall 2017 fall 2015
Stone	fall 2016 fall 2012 fall 2010
Vostinar	spring 2018 fall 2017
Walker	fall 2013 fall 2011
Wolz	spring 2017 spring 2016

CSC 312: Programming language implementation

Osera	spring 2018

CSC 321: Software development principles and practices

Rebelsky	spring 2018 fall 2017 spring 2017 fall 2016 spring 2016

CSC 322: Team software development for community organizations

Rebelsky	spring 2018 fall 2017 spring 2017 fall 2016 spring 2016

CSC 341, Automata, formal languages, and computational complexity

Klinge	spring 2018 fall 2017 spring 2017 fall 2016
Osera	spring 2016
Walker	spring 2014 spring 2012 spring 2010 spring 2009 spring 2008 spring 1999
Price Jones	spring 2013
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	spring 2012 spring 2012 spring 2009 spring 2007
Stone	spring 2002
Rebelsky	spring 2000

CSC 195: Introductory special topics

Rebelsky	Mediascripting for the Web, spring 2014 Technologies for media scripting, spring 2013 Data representation, storage management, and C programming, fall 2003 Data representation, storage management, and C programming, spring 2003
Walker	Data representation, storage management, and C programming,, fall 2001

CSC 295: Special topics

Rebelsky	Thinking in C and *nix, spring 2014 Learning from alumni, fall 2013 Learning from alumni, spring 2013 Professional practice: a philosophy of Unix, spring 2013 Women and computing, spring 2013 Algorithmic arts, fall 2012
Davis	Value sensitive design, spring 2013 Computing and health care, fall 2011 Socio-technical issues in computer networks, fall 2010 Human-computer interaction, spring 2008
Weinman	Computer vision, fall 2012 Computer vision, spring 2010
Praitis	Bioinformatics, fall 2011 (with Mr. Rebelsky) Bioinformatics, fall 2009 (with Mr. Rebelsky)
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	Parallel algorithms, spring 1997 Parallel algorithms, spring 1994

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	Human-computer interaction, spring 2005 Web Raveler: transforming the Web, fall 2001 Web software design, spring 2001 Software engineering for Web applications, fall 2000 Computer game design, spring 2000 Trails on the World Wide Web, fall 1999 Hypermedia, fall 1999 Developing algorithmic multimedia exercises, spring 1998 Advanced user interfaces, fall 1997
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	User-centered software development, fall 2009
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	Bluetooth communication with C, fall 2013 Using robots in CSC 161: an exploration, summer 2011 Placement of incoming students in computer science, statistics, and mathematics, summer 2010 An interactive campus map, spring 2010 User-centered software development, fall 2009 Scripting, databases and the Web, summer 2006 Automating athletic recruiting, fall 2004 (with Mr. Hollibaugh) Automating athletic recruiting, summer 2004
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	spring 1998

CSC 105: An algorithmic and social overview of computer science

Coahran	spring 2007
Walker	spring 2006 spring 2005 spring 2004
Bishop	fall 2001
Rebelsky	spring 2000

CSC 151: Fundamentals of computer science I

Davis	spring 2008 fall 2007 spring 2007 fall 2006
Rebelsky	spring 2008 fall 2007 spring 2007 fall 2006 fall 2003 spring 2003 fall 2002 spring 2001 fall 2000
Matocha	spring 2006
Walker	fall 2005 spring 2004 fall 2000 fall 1999 (two sections) spring 1999 fall 1998 spring 1997
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	spring 2006 fall 2005 spring 2005 fall 2004 fall 2000 spring 2000 fall 1999 spring 1999 spring 1998 fall 1997
Bishop	spring 2004 fall 2003 spring 2003 fall 2002 spring 2002 fall 2001
Walker	spring 2001
Flynt	spring 1999

CSC 153: Computer science fundamentals

Walker	spring 2009 fall 2007 spring 2007 spring 2006 spring 2005 spring 2002 spring 2001 spring 2000 spring 1998
Rebelsky	spring 2004 spring 2003

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

Coahran	spring 2008 spring 2007
Matocha	spring 2006
Walker	spring 2005
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	fall 2007
Walker	fall 2006 fall 2005 spring 2002
Rebelsky	fall 2004 spring 1997
Bishop	spring 2003 spring 2002
Stone	fall 1999

CSC 223: Algorithms and software design

Rebelsky	fall 1997
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	fall 1998

CSC 301: Algorithms and data structures

Stone	fall 1997
Moore	fall 1995 fall 1991
Walker	fall 1993

CSC 302: Programming language concepts

Price Jones	spring 2013
Rebelsky	spring 2011 spring 2007 spring 2006 spring 2005 spring 1999 spring 1998
Stone	spring 2009 spring 2008 spring 2003 spring 2002 spring 1996 spring 1992
Walker	spring 2004 spring 2001 spring 2000 spring 1994

CSC 323: Software design

Stone	spring 2014 spring 2012
Rebelsky	spring 2010

CSC 325: Databases and Web application design

Davis	fall 2012
Rebelsky	fall 2010
Walker	fall 2008

CSC 362: Compilers

Stone	fall 2013 spring 2010
Rebelsky	fall 2011 spring 2004 fall 2002 spring 2001 fall 1998

Spring 2019

CSC 105.01: The Digital Age (Rodrigues)

CSC 151.01: Functional problem solving (Rebelsky)

CSC 151.02: Functional problem solving (Hamid)

CSC 161.01: Imperative problem solving and data structures (Weinman)

CSC 161.02: Imperative problem solving and data structures (Johnson)

CSC 207.01: Object-oriented problem solving, data structures, and algorithms (Rebelsky)

CSC 207.02: Object-oriented problem solving, data structures, and algorithms (Rebelsky)

CSC 208.01 and CSC 208.02: Discrete Structures (Stone)

CSC 213.01: Operating systems and parallel algorithms (Curtsinger)

CSC 262.01: Computer vision (Weinman)

CSC 301.01: Analysis of Algorithms (Vostinar)

CSC 324.01: Software design and development (Johnson)

CSC 324.02: Software design and development (Vostinar)

CSC 341: Automata, formal languages, and computational complexity (Hamid)

CSC 395.01: Advanced operating systems (Curtsinger)

Fall 2018

CSC 151.01: Functional problem solving (Curtsinger)

CSC 151.02: Functional problem solving (Hamid)

CSC 161.01: Imperative problem solving and data structures (Walker)

CSC 161.02: Imperative problem solving and data structures (Johnson)

CSC 205.01: Computational linguistics (Stone)

CSC 207.01: Algorithms and object-oriented design (Stone)

CSC 207.02: Algorithms and object-oriented design (Walker)

CSC 208.01: Discrete Structures (Stone)

CSC 211.01: Computer organization and architecture (Curtsinger)

CSC 211.02: Computer organization and architecture (Weinman)

CSC 295.01: Special topic, "Evolutionary algorithms and artificial life" (Vostinar)

CSC 301.01 and .02: Analysis of Algorithms (Vostinar)

CSC 324.01: Software design and development (Johnson)

CSC 326.01: Software development leadership (Johnson) (Leadership roles within CSC 324.01: Software design and development (Johnson))

CSC 341: Automata, formal languages, and computational complexity (Hamid)

Links to previously offered courses

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.

Computer Science in the Academic Catalog

Vital Elements of Grinnell's Computer Science Curriculum

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

• Innovative introductory courses that emphasize multiple views of problem solving and several programming languages,
• Curricular options cover the core of undergraduate computing and also provide flexibility to address student interests and career options.
  • Core courses explore fundamental ideas, principles, algorithms, structures, and problem solving techniques with care, rigor, and thoroughness.
  • One or more software development projects connect principles and practices with experience developing software to meet client needs and serve the community
  • Electives that build upon core topics and provide breadth.
• Balance of theory and application,
• Varied and innovative pedagogy,
• Extensive opportunities for student-faculty research.

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

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

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 Design and Development examines methodologies for the effective development of large-scale software packages and uses a team approach to apply principles to actual projects that serve the needs of clients within the local community.
• Software Development Leadership offers experience working with clients and mentoring and supervising peers in teams developing software for community organizations.

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