Held: Tuesday, 1 September 2015

Back to Outline 02 - An Introduction to Linux. On to Outline 04 - Computing with Symbols and Numbers.

Summary

Today we begin your exploration of the Scheme programming language and the environment in which you will be devleoping algorithms in Scheme.

Related Pages

• Reading: The DrRacket Program Development Environment
• Reading: Beginning Scheme
• Reading: How Scheme Evaluates Expressions (Take 1)
• Lab: Starting Scheme
• EBoard 3 (Source 3)

Overview

• Why use programming languages?
• Scheme history.
• Scheme basics.

Administrivia

• Please grab a card to identify what computer you are on today (through Friday).
  
  • Maps are scattered around the room.
  • Put the card in the jar once you've read the name of the computer.
• My normal office hours are MWF 11:00-11:50. You sign up for those at https://rebelsky.youcanbook.me. My paperwork times are M-F, 8-9 am. Those are probably the best times to try to schedule alternate appointment times. Check my schedule for more. (I'll give up the occasional class prep time if necessary, but I prefer advance notice.)
• You now know how to get online, so I won't be providing printed copies of the lab manuals.

Upcoming Work

• Two readings for Wednesday: Numeric Values and Symbolic Values

Extra Credit Opportunities

Academic

• TODAY, noon, CS Table, JRC 224C. How Google Can Manipulate Elections. Readings available in the back of the classroom. If you are not on a meal plan, we'll pay for your meal.

Peer Support

• Pals of PALS, pals@grinnell.edu, normally Saturday at 1:30 and Mondays at 4:45. Requires sign up in advance.
• Pun Club, Saturdays, 4pm, Way over Younker

Leftover Questions on Algorithms

Thanks very much to the students who provided these questions!

Can you give an example of a subroutine from the nut butter and preserve algorithm?

Sure. There was an "open a jar" algorithm that I could have applied to both the nut butter jar and the preserve jar. Given that the preserve jar is glass, I don't think it would have been a good idea to use the "hit the top of the jar on the counter" algorithm. Here's an alternative. (Yes, you can probably find flaws.)

To open a jar

1. grasp the body of the jar with your non-dominant hand holding the top of the jar upward.

2. grasp the lid of the jar with your dominant hand

3. if the jar appears to be a screw-top jar, rotate the lid of the jar counter-clockwise while continuing to hold the bottom steady. Keep rotating the lid counter-clockwise until it separates from the jar.

4. if the jar appears to be a pop-top jar, pull the lid upward, applying force at the edge of the lid while holding the body of the jar steady

5. if the jar appears to be neither a screw-top jar nor a pop-top jar, report an inability to open the jar and stop.

Can you give examples of the where parts of an algorithm appear in the nut butter and preserve algorithm?

• "Untwist" and "grab" are basic operations. (Many of you assumed that "open" is a basic operation. But it didn't seem to be.)
• The jars, utensils, bread, plates, and napkins are the parameters to the algorithm.
• Similarly, the jar is the parameter to the "open a jar" algorithm.
• Within the broader algorithm, "the slices of bread" (meaning the ones that I removed from the bag) are variables.
• Similarly, the "dominant hand" is a variable within the "open a jar" algorithm.
• Opening the bag of bread before removing the bread is an example of sequencing
• Questions about the type of jar are examples of conditionals
• "Keep rotating the lid counter-clockwise until it separates from the jar" is an example of repetition.
• And as we just saw, the "open a jar" steps are a subroutine.

Lab

• You will learn Scheme better by trying than by listening, so I'm just going to have you work on the lab.
• I hope to spend a few minutes at the end of class giving you a chance to reflect on your first real experiences with Scheme.

The Need for Formality

• Computer scientists often express their algorithms in programming languages, languages designed by other computer scientists to express algorithms.
  • Most programming languages can also be "understood" by computers.
  • More precisely, we can use a program to automatically translate programs written in these languages into instructions the computer can follows.
• In this class, you will express your algorithms in the programming language Scheme.
• In Scheme, as in most languages, you will explore the syntax (the structure of the things we write) and the semantics (what meaning we assign to the things we write).
• Some people wonder why we need artificial languages like Scheme, Pascal, C, Java, Python, and the ilk, given that we should be able to write algorithms in English.
  • In part, it's probably because the computer elite want to maintain their sense of superiority over the masses.
  • In greater part, it's because English and other "natural" languages can be ambiguous. At the very least, they have many similar structures that are interpreted very differently. Consider the classic pair of phrases.
    • Time flies like an arrow.
    • Fruit flies like a banana.
• Remember: Computers are sentient and malicious.
  • From the programmer's perspective, it often seems that they'll do their best to misinterpret whatever it is you write.

A Short History of Scheme

• Scheme is a variant of Lisp (the List processing language).
• Lisp is one of the oldest high-level programming languages in active use
  • It's from the late 1950's.
  • That is, it's from about the time of the invention of Cobol and only a few years after the invention of Fortran.
  • It predates C, C++, C#, Basic, and almost every other language used.
• John McCarthy (of MIT and then Stanford) designed Lisp to provide a language for programming in artificial intelligence.
  • At the time, many people believed that intelligence was grounded in symbolic processing.
• Lisp added many things to languages of the day:
  • Symbolic values
  • Dynamic lists as built-in data structures
  • Automatic memory management for those built-in data structures
  • Functions as values (we'll return to this in a few weeks)
• In later reflection, McCarthy indicated that some of these things were just luck. For example, the lambda that you'll learn about soon was just a "hmmm ... that sounds interesting, I'll put it in" fluke.
• Scheme was designed in the 1970's as a variant of Lisp more appropriate for teaching computer science (and doing many other things; it's more elegant).
  • Scheme has a slightly clearer semantics than Lisp (and a formal semantics, which is important).
  • Scheme adds some nifty features for advanced programmers.
  • But, at least for 151, you're doing Lisp-like programming.
• A variant of Scheme called Script-Fu was added to the Gimp in its early development, so it is tightly integrated with the Gimp.
• We've built a friendlier version of Script-Fu.

Scheme Basics

• Scheme is generally used in an interactive environment: You type syntactically valid expressions and Scheme returns their values.
  • Later this semester, we may explore how to use Scheme in different environments.
• Scheme's syntax is fairly simple: Since almost everything in Scheme involves the application of a function (a.k.a. operation, a.k.a. procedure) to some arguments (a.k.a. parameters), you write:
  • an open parenthesis;
  • the name of the function;
  • a space;
  • the arguments to the function (separated by spaces); and
  • a close parenthesis.
• For example, (+ 2 3 4) (sqrt 4) (expt 2 3)
• If you remember this basic syntactic structure, you'll rarely get syntactic errors from Scheme.
• And if you believe that claim, I have a bridge to sell you.

Some Procedures You Should Know

• +: Sum its parameters.
• *: Compute the product of its parameters.
• -: Subtract the second parameter from the first.
• (sqrt *val*): Compute the square root of val.
• (expt *v* *p*): Compute v^p.
• (abs *v*): Compute the absolute value of v.
• (max *v1* *v2* ... *vn*): Determine the largest of the given values.
• (min *v1* *v2* ... *vn*): Determine the smallest of the given values.