Computer Science | Grinnell College

Thursday, February 8, 2018
4:15 p.m. in Science 3821
Refreshments at 4:00 p.m. in the Computer Science Commons (Science 3817)

A Functional Approach to Data Science in CS1, presented by Professor Samuel A. Rebelsky, discusses the new "data science" version of CSC 151 he has been doing with Titus Klinge and Sarah Dahlby Albright.

As part of the development of a new interdisciplinary initiative in data science that draws from statistics, mathematics, computer science, and the social sciences, we have developed a new introductory CS course that emphasizes data science and that we refer to as DataCSCi. Unlike other introductory data science courses, such as Berkeley's Data 8, our course retains the broad array of concepts necessary not only to introduce programming principles related to data science, but also to prepare students for the second course in our standard introductory computer science sequence. In particular, the course includes coverage of recursion (numeric and structural), unit testing, linked data structures, and other concepts we rely upon in subsequent courses in computer science.

At the same time, we introduce students to a wide variety of techniques and approaches that support them in their subsequent work in data science, including techniques for wrangling, cleaning, and visualizing data. We achieve this combination of breadth and depth through two core approaches: We focus on a spiral "use then implement" approach and we focus on a functional model of programming using Scheme/Racket. While Python and R are the most commonly used languages for data science, we find that Scheme works particularly well to introduce students to concepts both complex, like map-reduce, and simple, like list filtering.

The page is currently in very rough form.

Although the philosophical community is not agreed on Putnam's claim that the natural language you speak affects your thoughts, it's clear that the programming language you use affects how you solve problems. (The traditional aphorism for this view is If the only tool you have is a hammer, everything looks like a nail.) Strong computer science students therefore regularly look to learn new languages. This page provides a quick list of programming languages that SamR thinks you should learn.

Essentials

Scheme (or other dialect of Lisp). The functional paradigm is an incredibly powerful approach to expressing algorithms. The abilities to design your own control structures and to use higher-order techniques empowers programmers in many ways. The functional paradigm is also increasingly relevant. For example, Amazon and Google use map-reduce as a core technique in much of their work with large data sets, and most modern languages now seem to include a functional component. As importantly, Scheme has a syntax that easily lets you treat the same expression as either data or code. Being able to switch between models is a transformative way to think about programs.

C. Being able to program in C means that you can start to approach your code at a level close to the machine - you can't program well in C unless you understand memory arrangement. There have been some arguments that students no longer need to handle things at this level, and you can clearly write programs more quickly if you use a higher-level language. Nonetheless, understanding pointers, data representation, and more is useful. C's syntax also influences a large number of languages.

Java.

Postscript. Postscript is a stack-based language (think of reverse Polish notation on steroids) with a focus on making images. You don't need deep understanding of Postscript. But working in a language with this model (and with a fairly simple syntax) can really transform your thinking. Plus, you get to make cool images.

Python or Ruby. Some modern scripting language.

HTML and CSS. These are not programming languages; they are markup languages. But you should know at least one markup language. Knowing HTML also lets you do quick Web consulting jobs. (Yeah, that's a practical issue.)

Additional

TeX or LaTeX. Like HTML, TeX and LaTex are markup languages, not programming languages.

Perl

The Glimmer Labs pages are currently under development.

Mediascripting is a project of Grinnell College's Glimmer Labs. In this project, we are building resources to support interactive scripting of media applications.

The student researchers currently working on CSG-CS2 include Alexandra Greenberg, Mark Lewis, Evan Manuella, Jennelle Nystrom, Kimberly Spasaro, and Christine Tran.

Further information is forthcoming.

[ Glimmer | People | github | CSG-CS2@github ]

• 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:

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.

On Thursday, January 24, Hart Russell 2014 and Prashanna Tiwaree 2014 will present the results of their summer 2012 research project:

This project sought to replace the MediaScheme console used in CSC 151 with a more versatile system that consists of DrRacket, a Scheme development environment, communicating with the GIMP through D-Bus, an inter-process communication tool that is found in modern Linux systems.

Refreshments will be served at 4:15 p.m. in the Computer Science Commons (Noyce 3817). The talk, Re-architecturing MediaScheme, will follow at 4:30 p.m. in Noyce 3821. Everyone is welcome to attend!

On Thursday, November 15, Sarah Henney 2013 and Martha Fletcher 2015 will describe their summer internship work on the MediaScheme project:

Self-Disclosing GIMP(SDGimp) is an ongoing project with the goal of adding self-disclosure functionality tailored to the MediaScheme library into the GIMP. In short, SDGimp will allow a user to perform an action in the GIMP and then view the Scheme expression which can be used to duplicate that action.

In this Extra, we will discuss and demonstrate our work from this summer on SDGimp, including our expansion of the MediaScheme library to include more actions from the GIMP.

Refreshments will be served at 4:15 p.m. in the Computer Science Commons (Noyce 3817). The talk, Self-disclosing GIMP with MediaScript, will follow at 4:30 p.m. in Noyce 3821. Everyone is welcome to attend!

On Thursday, February 9, Kate Ingersoll 2013 and Kimberly Spasaro 2014 will present results from their summer 2011 research:

Our goal was to create a scripting console for the open-source vector-graphics program Inkscape. We'll explain the technical process of creating the console, specifically the method of using dbus to create intra-process communication between internal Inkscape commands and Scheme functions. The presentation will also cover the applications of scriptable media programs, both as a tool for graphic design and as an environment for teaching computer science. The talk will conclude with a thrilling demonstration of the working Inkscape console, as we walk though examples of how simple Scheme commands in the InkScript console can create complex and interesting images.

Refreshments will be served at 4:15 p.m. in the Computer Science Commons (Noyce 3817). The talk, "Media scripting with Inkscape," will follow at 4:30 p.m. in Noyce 3821. Everyone is welcome to attend!

On Thursday, February 2, John Stone will discuss the development of software in modern Scheme:

The Revised⁶ report on the algorithmic language Scheme introduces several new constructions into the language that enable programmers to impose a modular structure on their code, simplifying large-scale program development and promoting even greater flexibility in adapting the language to particular applications. This talk illustrates some of the possibilities, drawing on two examples: (0) a reimplementation in R⁶RS of the Smark programmable filter, and (1) an extensive algorithm library, created for the textbook Algorithms for functional programming.

Refreshments will be served at 4:15 p.m. in the Computer Science Commons (Noyce 3817). The talk, "Software development using R6RS libraries," will follow at 4:30 p.m. in Noyce 3821. Everyone is welcome to attend!

Multi-paradigm Approach for Introductory Courses

Computing has become widespread in today's society, largely because it helps people solve problems. However, different types of problems require fundamentally different approaches for problem solving. 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.

Grinnell's computer science curriculum explores several of these paradigms in the beginning courses, each of which has been named a "course exemplar" by the international professional computing societies.

• CSC 151, Functional Problem Solving
  • emphasizes functional problem solving
  • supported by the Scheme programming language (a dialect of LISP, a language widely used for artificial intelligence, graphical manipulations, and other applications)
  • current application areas: data science, digital humanities
  • past application area: image processing / media scripting

CSC 151 image by James Kent and Chris Re-Scherer, Fall 2012	CSC 151 image by Amy Tsui and Solomon Miller, Spring 2010	CSC 161 image by Mai Ha Vu, Fall 2012	CSC 151 image by Grace Philipp, Elizabeth Reischmann, and Lauren Cantley, Fall 2009

• CSC 161, Imperative Problem Solving and Data Structures
  • studies concepts tied to the architecture of computers, compilers, and operating systems within the context of the imperative problem-solving paradigm
  • supported by the C (a programming language widely used in scientific applications and engineering)
  • application area: control of robots

Scribbler 2 robot (front view)

Scribbler 2 robot (rear view)

• CSC 207, Algorithms and Object-Oriented Design
  • explores object-oriented problem solving
  • supported by the Java programming language (a language widely use for large-scale applications and systems)
  • application area: software development for the common good

Students with considerable background should consult the computer science faculty regarding placement.

• Students with strong scores on the AP CS A examination or the IB CS examination receive credit for their prior work, but placement requires discussion of their specific background.
• Most incoming students find functional problem solving to be quite new and different, so they begin with CSC 151 (where no computing background is assumed).
• Students with substantial experience in imperative problem solving or object-oriented problem solving (e.g., students with AP CS A or IB CS background) may be able to skip CSC 161 or CSC 207, depending upon the extent of their background.

Later courses build on this foundation to provide depth in each of these problem-solving paradigms and programming languages.