《SimplyScheme：计算机科学入门》详尽英文版

需积分: 9 3 浏览量更新于2024-07-21 收藏 2.54MB PDF 举报

"《SimplyScheme：计算机科学导论第二版》是一本专门针对Scheme语言初学者编写的英文入门书籍。该书由Brian Harvey和Matthew Wright共同编写，并由Harold Abelson撰写了序言。作者们以简洁易懂的方式介绍了计算机科学的基础概念，让读者能够快速上手 Scheme 语言，这是Lisp家族的一种编程语言，以其简洁的语法和强大的表达力而著称。这本书不仅包含详细的理论讲解，还有配套的实践项目，使学习者能够通过编写和运行程序来深入理解计算机科学原理。它强调了自由软件的理念，所有提供的程序都是按照GNU通用公共许可证（GPL）进行分发，允许用户自由地复制、修改和分享这些代码，体现了开源精神。版权方面，1999年麻省理工学院享有本书的版权，而书中所含的程序则在1993年由Harvey和Wright原创，且遵循GPL条款。作者明确指出，这些程序提供是希望它们能对读者有益，但并不提供任何形式的商业保证或特定用途的适配性，具体使用时需参考GNU通用公共许可证的详细内容。《SimplyScheme》的排版采用了Baskerville字体，借助JOVE文本编辑器和TEX文档格式系统完成，体现了专业且严谨的出版标准。此外，它还被美国国会图书馆列为公开目录，进一步证明了其在教育领域的权威地位。《SimplyScheme》是一本适合自学编程，特别是对Scheme语言感兴趣的读者使用的优质资源，它通过实践与理论相结合的方式，帮助读者建立起坚实的计算机科学基础。"

Page xiv

Appendices

Running Scheme

507

The Program Development Cycle 507

Integrated Editing

509

Getting Our Programs

510

Tuning Our Programs for Your System

511

Loading Our Programs

513

Versions of Scheme

514

Scheme Standards

514

Common Lisp

515

Why Common Lisp Exists 515

Defining Procedures and Variables

516

The Naming Convention for Predicates

516

No Words or Sentences

517

True and False

517

Files

518

Arrays

519

Equivalents to Scheme Primitives

519

A Separate Name Space for Procedures

520

Lambda

521

More about Function 522

Writing Higher-Order Procedures

523

Scheme Initialization File

525

GNU General Public License

547

Credits

551

Alphabetical Table of Scheme Primitives

553

Glossary

557

Index of Defined Procedures

567

General Index

573

Page xv

FOREWORD

One of the best ways to stifle the growth of an idea is to enshrine it in an educational curriculum. The textbook

publishers, certification panels, professional organizations, the folks who write the college entrance exams—once

they've settled on an approach, they become frozen in a straitjacket of interlocking constraints that thwarts the ability

to evolve. So it is common that students learn the ''modern" geography of countries that no longer exist and practice

using logarithm tables when calculators have made tables obsolete. And in computer science, beginning courses are

trapped in an approach that was already ten years out of date by the time it was canonized in the mid-1980s, when the

College Entrance Examination Board adopted an advanced placement exam based on Pascal.

This book points the way out of the trap. It emphasizes programming as a way to express ideas, rather than just a way

to get computers to perform tasks.

Julie and Gerry Sussman and I are flattered that Harvey and Wright characterize their revolutionary introduction to

computer science as a "prequel" to our text Structure and Interpretation of Computer Programs. When we were

writing SICP, we often drew upon the words of the great American computer scientist Alan Perlis (1922–1990). Perlis

was one of the designers of the Algol programming language, which, beginning in 1958, established the tradition of

formalism and precision that Pascal embodies. Here's what Perlis had to say about this tradition in 1975, nine years

before the start of the AP exam:

Algol is a blight. You can't have fun with Algol. Algol is a code that now belongs in a plumber's union. It helps you

design correct structures that

Since Hal wrote this Foreword, they've switched the AP exam to use C++, but the principle is the same.

Page xvi

don't collapse, but it doesn't have any fun in it. There are no pleasures in writing Algol programs. It's a labor of

necessity, a preoccupation with the details of tedium.

Harvey and Wright's introduction to computing emerges from a different intellectual heritage, one rooted in research in

artificial intelligence and the programming language Lisp. In approaching computing through this book, you'll focus

on two essential techniques.

First is the notion of symbolic programming. This means that you deal not only with numbers and letters, but with

structured collections of data—a word is a list of characters, a sentence is a list of words, a paragraph is a list of

sentences, a story is a list of paragraphs, and so on. You assemble things in terms of natural parts, rather than always

viewing data in terms of its tiniest pieces. It's the difference between saying "find the fifth character of the third word

in the sentence" and "scan the sentence until you pass two spaces, then scan past four more characters, and return the

next character."

The second technique is to work with higher-order functions. That means that you don't only write programs, but

rather you write programs that write programs, so you can bootstrap your methods into more powerful methods.

These two techniques belong at center stage in any beginning programming course, which is exactly where Harvey and

Wright put them. The underlying principle in both cases is that you work with general parts that you extend and

combine in flexible ways, rather than tiny fragments that you fit together into rigid structures.

You should come to this introduction to computing ready to think about ideas rather than details of syntax, ready to

design your own languages rather than to memorize the rules of languages other people have designed. This kind of

activity changes your outlook not only on programming, but on any area where design plays an important role, because

you learn to appreciate the relations among parts rather than always fixating on the individual pieces. To quote Alan

Perlis again,

You begin to think in terms of patterns and idioms and phrases, and no longer pick up a trowel and some cement and

lay things down brick by brick. The Great Wall, standing for centuries, is a monument. But building it must have been a

bore.

HAL ABELSON

CAMBRIDGE, MA

Page xvii

PREFACE

There are two schools of thought about teaching computer science. We might caricature the two views this way:

• The conservative view: Computer programs have become too large and complex to encompass in a human mind.

Therefore, the job of computer science education is to teach people how to discipline their work in such a way that 500

mediocre programmers can join together and produce a program that correctly meets its specification.

• The radical view: Computer programs have become too large and complex to encompass in a human mind.

Therefore, the job of computer science education is to teach people how to expand their minds so that the programs

can fit, by learning to think in a vocabulary of larger, more powerful, more flexible ideas than the obvious ones. Each

unit of programming thought must have a big payoff in the capabilities of the program.

Of course nobody would admit to endorsing the first approach as we've described it. Yet many introductory

programming courses seem to spend half their time on obscure rules of the programming language (semicolons go

between the instructions in Pascal, but after each instruction in C) and the other half on stylistic commandments (thou

shalt comment each procedure with its preconditions and postconditions; thou shalt not use goto). In an article that

was not intended as a caricature, the noted computer scientist Edsger Dijkstra argues that beginning computer science

students should not be allowed to use computers, lest they learn to debug their programs interactively instead of writing

Page xviii

programs that can be proven correct by formal methods before testing.

If you are about to be a student in an introductory computer science course, you may already be an experienced

programmer of your home computer, or instead you may have only a vague idea of what you're getting into. Perhaps

you suspect that programming a computer is like programming a VCR: entering endless obscure numeric codes. Even

if you're already a computer programmer, you may not yet have a clear idea of what computer science means. In either

case, what we want to do in this book is put our best foot forward—introduce you to some new ideas, get you excited,

rather than mold you into a disciplined soldier of the programming army.

In order to understand the big ideas, though, we'll also have to expend some effort on technical details; studying

computer science without writing computer programs is like trying to study German grammar without learning any of

the words in the language. But we'll try to keep the ideas in view while struggling with the details, and we hope you'll

remember them too.

One Big Idea:

Symbolic Programming

We said that our approach to teaching computer science emphasizes big ideas. Our explanation of symbolic

programming in the following paragraphs is in part just an illustration of that approach. But we chose this particular

example for another reason also. Scheme, the programming language used in this book, is an unusual choice for an

introductory computer science course. You may wonder why we didn't use a more traditional language, such as Pascal,

Modula-2, or C. Our discussion of symbolic programming is the beginning of an answer to that question.

Originally computers were about numbers. Scientists used them to solve equations; businesses used them to compute

the payroll and the inventory. We were rescued from this boring state of affairs mainly by researchers in artificial

intelligence—people who wanted to get computers to think more nearly the way people do, about ideas in general

rather than just numbers.

What does it mean to represent ideas in a computer? Here's a simple example: We want to teach the computer to

answer the question, "Was so-and-so a Beatle?" We can't quite ask the question in English; in this book we interact

with the computer using Scheme. Our interactions will look like this:

"On the Cruelty of Really Teaching Computer Science," Communications of the ACM, vol. 32, no. 12, December,

1989.

Page xix

You type: (beatle? 'paul)

Computer replies: #t (computerese for "true")

You type: (beatle? 'elvis)

Computer replies: #f ("false")

Here's the program that does the job:

(define (beatle? person)

(member? person '(john paul george ringo)))

If you examine this program with a (metaphoric) magnifying glass, you'll find that it's really still full of numbers. In

fact, each letter or punctuation character is represented in the computer by its own unique number.

But the point of the

example is that you don't have to know that! When you see

(john paul george ringo)

you don't have to worry about the numbers that represent the letters inside the computer; all you have to know is that

you're seeing a sentence made up of four words. Our programming language hides the underlying mechanism and lets

us think in terms more appropriate to the problem we're trying to solve. That hiding of details is called abstraction, one

of the big ideas in this book.

Programming with words and sentences is an example of symbolic programming. In 1960 John McCarthy invented the

Lisp programming language to handle symbolic computations like this one. Our programming language, Scheme, is a

modern dialect of Lisp.

Lisp and Radical Computer Science

Symbolic programming is one aspect of the reason why we like to teach computer science using Scheme instead of a

more traditional language. More generally, Lisp (and therefore Scheme) was designed to support what we've called the

radical view of computer science. In this view, computer science is about tools for expressing ideas. Symbolic

programming allows the computer to express ideas; other aspects of Lisp's design help the programmer

The left parenthesis is 40, for example, and the letter d is 100. If it were a capital D it would be 68.

Page xx

express ideas conveniently. Sometimes that goal comes in conflict with the conservative computer scientist's goal of

protection against errors.

Here's an example. We want to tell our computer, "To square a number, multiply it by itself." In Scheme we can say

(define (square num)

(* num num))

The asterisk represents multiplication, and is followed by the two operands—in this case, both the same number. This

short program works for any number, of course, as we can see in the following dialogue. (The lines with > in front are

the ones you type.)

> (square 4)

> (square 3.14)

9.8596

> (square –0.3)

0.09

剩余459页未读，继续阅读

baidu_16395359

粉丝: 1
资源: 10

《SimplyScheme：计算机科学入门》详尽英文版

mit-scheme源代码

学习简单方案：这是一个存放具有简单方案编程概念的.scm文件的存储库

proxy_set_header x-forwarded-scheme $scheme;

domain system authentication login hwtacacs-scheme hwtac local authorization login hwtacacs-scheme hwtac local accounting login hwtacacs-scheme hwtac local authorization command hwtacacs-scheme hwtac local accounting command hwtacacs-scheme hwtac

domain nlradius.com authentication lan-access radius-scheme nlradius none authorization lan-access radius-scheme nlradius none什么意思

@media (prefers-color-scheme: dark)

authorization-scheme ftp

ensp中aaa协议 authentication-scheme default语句的做哟红

华为aaa认证配置命令

最新资源