Scheme

Programming (and other) Languages CS Majors Should Learn

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

Glimmer Labs: Mediascripting

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 ]

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.

Thursday Extra: "Re-architecturing MediaScheme"

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!

Thursday Extra: "Self-Disclosing GIMP with MediaScript"

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!

Thursday Extra: "Media scripting with Inkscape"

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!

Thursday Extra: "Software development using R6RS libraries"

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

The Revised6 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 R6RS 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!

Introductory courses

Introductory Course CSC 151

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)
    • application area: image processing / media scripting
151 image, Kent, Re-Scherer 151 image, Tsui, Miller 161 image, Mai Ha Vu 151 image, Philipp, Reischmann, Cantley
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 Front Scribbler 2 Back 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

Introductory Course CSC 151

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.


Syndicate content