Talk:Scheme (programming language): Difference between revisions

Revision as of 12:14, 31 May 2006

Latest revision as of 03:36, 3 January 2025

(149 intermediate revisions by 52 users not shown)

Line 1:

{{peerreviewTalk header}}

{{ArticleHistory|action1=PR

|action1date=10:48, 20 June 2006

|action1link=Wikipedia:Peer review/Scheme programming language/archive1

|action1result=reviewed

|action1oldid=59406708

|action2=GAN

== Hygienic macros ==

|action2date=03:39, 24 June 2006

Hi. The following text was found in [[Hygienic macro]], but I don't know enough about Scheme to integrate properly. Please could someone else handle this:

|action2result=listed

|action2oldid=60283019

|action3=GAR

Scheme macros:

|action3date=03:16, 2 December 2008

*Transforms derived expression types into primitive expression types.

|action3link=Talk:Scheme (programming language)/GA1

*During expansion, no evaluation ? rewrites one pattern of code into another.

|action3result=delisted

*May use macros if we want to ommit Scheme?s call by value evaluation

|action3oldid=254278791

--[[User:DJ Clayworth|DJ Clayworth]] 15:28, 21 Nov 2003 (UTC)

|action4=GAN

:It is unfortunate that [[hygienic macro]] redirects to [[Scheme programming language]] where there's only little information on the subject. --[[User:MH|MH]] 15:29, 16 Mar 2004 (UTC)

|action4date=20:16, 11 May 2010 (UTC)

|action4link=Talk:Scheme (programming language)/GA2

|action4result=failed

|action4oldid=361456475

|topic=Engtech

|currentstatus=failedGA

}}

{{WikiProject banner shell|class=B|

{{WikiProject Computing|importance=low

|science=yes

|science-importance=mid

}}

}}

{{archives

| search=yes

| list=<center>[[/Archive 1|2003–2007]]</center>

}}

== Tail-recursion example is not tail-recursive ==

== Scheme advantages ==

I think the example shown under ‘proper tail recursion’ does not actually use tail recursion because the call to the loop function is not directly returned from the function. The return value is instead passed to a call to ‘cons’ which would mean it has to maintain the call stack and can't optimise away the call. I think it would have to be something like this to use tail-call recursion:

Most of the advantages listed stem from more general design decisions than that of Scheme in particular:

*Concerning syntax it's a feature of all [[Lisp_programming_language|Lisps]] (well, except for the very first design of [[Lisp_programming_language|Lisp]] which did not use S-exprs)

*Concerning the functional aspect, it is as the name suggests common to all functional languages.

I've therefore added in the section what these advantages stem from. --[[User:Zsam|Sam]] 00:15, 11 Aug 2004 (UTC)

<syntaxhighlight lang="scheme">

(define (list-of-squares n)

(let loop ((i n) (res '()))

(if (< i 0)

res

(loop (- i 1) (cons (* i i) res)))))

</syntaxhighlight>

[[User:Bpeel|Bpeel]] ([[User talk:Bpeel|talk]]) 16:04, 27 November 2012 (UTC)

As there was no response to my message I've just gone ahead and replaced the sample with the one above.

== Evolution of scheme ==

[[User:Bpeel|Bpeel]] ([[User talk:Bpeel|talk]]) 17:46, 20 December 2012 (UTC)

== Comments ==

Two sections, Disadvantages of Scheme and Standards, talk about official and community standards, but in a rather unenlightening way. A brief history of scheme should be written, covering the nature of the RnRS process, the status of the IEEE standard, the reasons for doubting there will ever be an R6RS, and why the SRFI process was created and what has been going on with it.

"Each comment is preceded by a semicolon (;) and extends for the rest of the line. Some implementations allow comments to span multiple lines by wrapping them with a #|...|# (possibly nested). Other implementations allow an entire s-expression to be commented out by prepending it with #;.[7] These two comment forms are included in the R6RS."

Three kinds of comments are described, but the last sentence mention only two forms. I don't know which form are referenced. Could anybody make it clearer please ? [[User:Halladba|Halladba]] ([[User talk:Halladba|talk]]) 22:22, 1 December 2008 (UTC)

I propose a rewrite of these two sections, with a new section "Evolution of Scheme" as the first numbered section that covers the above. Any objections to me diving in and doing that? --[[User:Chalst|Charles Stewart]] 09:01, 12 Aug 2004 (UTC)

:the last two must be the new ones from R6RS because R5RS only has the (;) whole-line comments. --[[User:MarSch|MarSch]] ([[User talk:MarSch|talk]]) 16:30, 20 July 2009 (UTC)

:That's fine with me. Make sure that you do describe the percieved advantages and drawbacks of Scheme, especially compared to other dialects of Lisp (since its advantages and drawbacks as a whole are largely those of Lisp). It may also be interesting to explain how the drawbacks are addressed. --[[User:Zsam|Sam]] 20:42, 13 Aug 2004 (UTC)

[[Rscheme]] should be mentioned or linked to as a child/variant/descendent or whatever. --[[User:Clf99|Clf99]] ([[User talk:Clf99|talk]]) 22:20, 24 September 2010 (UTC)

== Toki Pona?==

:Rscheme is a really notable scheme system. It has a well implemented garb. I'll see if I can add it in a proper place. [[User:Rursus|Rursus]] dixit. ([[User talk:Rursus|<span style="color: red; background: #FFFF80">^m<u>bork³</u></span>]]!) 21:00, 23 May 2011 (UTC)

I am not the one who originally deleted the link to [[Toki Pona]], but after checking it, there is no Scheme code on that page contrary to what the section title claims. In fact it does not have anything to do with Scheme. Therefore I have removed the link. Is there any good reason to link to that article that I have missed? --[[User:Zsam|Sam]] 04:47, 27 Aug 2004 (UTC)

== Used on Mars rover ==

I believe I heard at MIT that Scheme was used on one of the Mars rovers. Ten points to anyone who can find a reliable reference. 8) -- [[User:Beland|Beland]] ([[User talk:Beland|talk]]) 00:43, 18 July 2009 (UTC)

== Disjointness of types ==

== Expansion needed ==

A point: while the current scheme standards assert that the types are disjoint, and in particular that #f and '() are distinct, this has only been the case since the IEEE standard and R4RS. R3RS permitted these two to be the same, and MIT scheme had this equality. This comment is provoked by [http://en.wikipedia.org/w/wiki.phtml?title=Scheme_programming_language&diff=0&oldid=6597449 this edit]. --[[User:Chalst|Charles Stewart]] 14:54, 15 Oct 2004 (UTC)

This article has been a mess for some time, and I'm planning an expansion, with possibly a rewrite of much of the article.

Some recent developments in Scheme standardization should be covered (see [http://scheme-reports.org/ http://scheme-reports.org/]). R6RS has divided Schemers more than any other event in the history of the language, and the Scheme Steering Committee has proposed that two Scheme versions should be specified: a small language more akin to R5RS, and a larger language closer to R6RS.

Meanwhile the coverage of key concepts is poorly handled. The following key language features need to be covered correctly:

== Outdated? ==

* Continuations

* Hygienic macros

* Multiple values

* Numeric tower

* Proper tail calls

The article should integrate with [[lisp (programming language)]] so that basic lisp concepts covered adequately in that article (lists, consing, etc) are not dwelt on here.

:''"The Scheme community is highly fragmented, with dozens and dozens of implementations, and without a dominant implementation it has proven difficult to focus developer support on providing adequate libraries for practical work. (For example, Python has over 100 extension libraries written in C, and many more in pure Python.)"''

The SRFI process should be covered in more depth.

:''"For this reason, Scheme is often considered to be a "toy" language, unsuited for production use since too much time is needed to re-invent the wheels, though one very well suited for educational purposes. A dominant, open source implementation is badly needed to remove this stigma."''

The Steering Committee recently remarked that "Scheme has the unhappy distinction of being the world's most unportable programming language" [http://scheme-reports.org/2009/position-statement.html], and this undeniable fact isn't really covered here at all. Their point is that if you want to write in Scheme, you have to choose a particular implementation, and having done that you will find that most of the software you write for that implementation will not run unaltered on other implementations. --[[User talk:Tony Sidaway|TS]] 03:42, 13 October 2009 (UTC)

Really? There's PLT and Chicken, among others very high quality free implementations. I'd pick Chicken over Python any day of the week.

==Language elements==

"filesystem access, a socket interface, HTML processing," all these are readily available these days.

It's hard to avoid the temptation to turn an encyclopedia article on a programming language into a miniature tutorial for the language. The "Language elements" section is messy and some parts of it need to be rewritten and other parts need to be incorporated elsewhere--as I have already done with some sections. --[[User talk:Tony Sidaway|TS]] 16:09, 14 October 2009 (UTC)

==Disney World==

I've removed the following for now:

: [[Chez Scheme]] has been used at Disney World in Florida for controlling virtual rides.

I can agree that there needs to be some disadvantages listed but all of the listed things are things that are currently false, since:

*The SRFI's have been successful

*There are adequate libraries for practical work

*Scheme isn't just a toy language (even though it's often viewed as one)

The namespace thing.. yes, some people do see that as a disadvantage; others see it as a huge advantage. A short note should be made that these two sides exist, with discussion moved to another page.

The citation given for this was "Kent Dybvig, invited to talk at the International Conference on Functional Programming, 2006." We need better sourcing than that. --[[User talk:Tony Sidaway|TS]] 19:06, 20 October 2009 (UTC)

Real disadvantages:

*has a '''reputation''' as a toy language - even if it's not one, that's the reputation

*is very different from mainstream algol-like languages (it's imho easier, but opinions differ on that)

*is popular with academia and cs and other hopeless geeks

Maybe CL-folks could list some disadvantages that scheme has? otoh I've never seen any CL folks with a good understanding of scheme.

== Stuff removed from Boolean data type article ==

:I dropped the latter offending paragraph, since it was accusatory, POV, and not in encyclopedic style. (It is not Wikipedia's business to tell other people what is "badly needed".) Please feel free to contribute accurate information directly to the article -- [[Wikipedia:Be bold|be bold]] in editing. :) --[[User:Fubar Obfusco|FOo]] 01:33, 7 Mar 2005 (UTC)

The following section was removed from the article [[Boolean data type]]:<br/>'''begin removed text'''

::This article should mention SIOD.

----

----

[[Scheme (programming language)|Scheme]] has two special symbols <code>#t</code> and <code>#f</code> which represent the logical values of true and false respectively. However, any non-<code>#f</code> value is interpreted as true. Note that unlike Lisp, <code>nil</code> or <code>'()</code>, the empty list, is separate from <code>#f</code> in Scheme, and therefore is considered true.

----

----

'''end removed text'''<br/>Is there a place for this text in the Scheme-related articles? Perhaps in the Wikibook? Thanks, and all the best, --[[User:Jorge Stolfi|Jorge Stolfi]] ([[User talk:Jorge Stolfi|talk]]) 00:08, 31 December 2009 (UTC)

: Thanks for this. I think we already cover it all in the present article, but it might be useful for the book (which was rather moribund last time I checked). --[[User talk:Tony Sidaway|TS]] 00:10, 31 December 2009 (UTC)

==Forth==

I've reverted [http://en.wikipedia.org/w/index.php?title=Scheme_(programming_language)&diff=353339065&oldid=349190686 this edit] which was based on an opinion stated in the edit summary: "Forth is even easier to implement, and has as much power from further readily available extensions."

This isn't because I want to engage in a debate on the relative power of [[Forth (programming language)|Forth]] and Scheme (that isn't what we do here at Wikipedia) but because I think it's bad form to insert personal opinion into articles. For more on what is meant by "power" in the context of Scheme and other Lisps, read the "Fundamental design features" section. Any language may be augmented to contain these features, but every standard-conforming implementation of Scheme provides them without the need for augmentation. --[[User talk:Tony Sidaway|TS]] 17:57, 1 April 2010 (UTC)

: I've changed the word "power" to the wikilinked phrase [[expressive power]], This refers to the readiness with which complex data and control structures can be expressed in Scheme. --[[User talk:Tony Sidaway|TS]] 18:07, 1 April 2010 (UTC)

== "Review of language syntax" is not about syntax ==

== Cryptic tail-recursive factorial example ==

"Review of language syntax" section lists standard forms and procedures, not the lexical or syntactic structure of the textual form. So it seems to be a misnomer. Can anyone think of a better title, so it would match the content of that section? [[User:MagV|MagV]] ([[User talk:MagV|talk]]) 12:08, 9 April 2010 (UTC)

Hi, I was just reading the article out of curiosity. I really liked most of the article and actually became interested in learning the language.

: Yes, there frankly isn't a lot of "syntax" in Lisp! Perhaps "Review of standard forms and procedures" would be better. I might also become convinced that the entire section could be removed or rewritten--I think I need to spend some time examining the structure of articles on similar subjects such as [[Common Lisp]].

I don't know how to program in scheme or any lisp dialect for that mater. I am not a CS major, but am not computer illiterate either. I program in other languages like C, Objective-C, perl, and php just for fun. I was trying to follow the tail-recursive example and was completely unable to do it and I don't feel is my fault. I believe that a few comments on the code and perhaps explaining what do the "let loop" expression and the "do statement" do instead of vaguely mentioning that they are "syntactic sugar" could help. I would write them myself but as I said, unfortunately I don't know how to program in scheme.

: There is also the problem that this article is heavily slanted towards the still-dominant R5RS standard, and this may well change over time. For now I'm happy to continue describing R5RS and noting R6RS differences (which we don't really do a very good job of yet). If R6RS implementations, and uses of R6RS, become more popular, that will have to change. In some ways R6RS defines such a different kind of language that it may merit an entire separate article, which may or may not in time become the default article for "Scheme (programming language)". R6RS aims to be far more than the "minimalist" language described here. --[[User talk:Tony Sidaway|TS]] 13:44, 10 April 2010 (UTC)

I don't know the specifics of the rest of the discussion, but I really liked the article aside from these rough edges, Good Job!!

:: I'm down with "Review of standard forms and procedures". A rewrite is also good, since a list of standard bindings is not that useful by itself.

:The "named <CODE>let</CODE>" form sets up a local subroutine, here called <CODE>loop</CODE>. This routine has two local variables, called <CODE>fact</CODE> and <CODE>n</CODE>. (I'd call them <CODE>total</CODE> and <CODE>iter</CODE> or some such, but whatever.) Inside this subroutine, you can think of a tail-call to <CODE>loop</CODE> as just a GOTO back up to the top of the named <CODE>let</CODE>, only with these variables modified.

:: For the actual syntax, a pointer to [[s-expression]] with a description of differences (e.g. vectors) would be good.

:: For R5RS-ness, "Distinguishing features" should list features common among all standards/implementations, and then note differences. R5RS is the base for many common features, so it's OK to describe them from R5RS point of view. But then there are common features which R5RS does not have (e.g. a module system): those should be described as well, but not from R5RS point of view (obviously).

:: Finally, I don't think we need a separate R6RS article (too many common themes), but a section devoted to each standard would be good. Such section can say something about how and when it was accepted, and then list everything that does not fit "Distinguishing features". As a bonus, we'll be able to wikify all the "[[R5RS]]" across the Wikipedia to point to the relevant section, not the generic Scheme article.

:: -- [[User:MagV|MagV]] ([[User talk:MagV|talk]]) 15:17, 10 April 2010 (UTC)

== Easiest to implement ==

:One of the lessons to learn from Scheme is that if you can assume tail-call optimization, then a tail-recursive call is just a GOTO with arguments, and is just as efficient (while still being a lot more readable). --[[User:Fubar Obfusco|FOo]] 05:23, 21 Jun 2005 (UTC)

Theres a statement in the wording that SCHEME is the easiest language of comparable power to implement. Is this REALLY true? I've seen some DAMN slim versions of Forth, and although it was never as fashionable for its stack-y ways, it was always a pretty expressive language and surprisingly capable for the kind of metaprogramming the lisps where known for. [[Special:Contributions/121.45.251.215|121.45.251.215]] ([[User talk:121.45.251.215|talk]]) 12:07, 9 October 2011 (UTC)

::I just cleaned up (IMHO!) the examples a little. What do you think now? --[[User:Fubar Obfusco|FOo]] 05:41, 21 Jun 2005 (UTC)

== "Popular with programmers, implementors and hobbyists" ==

This sentence in the first paragraph seems completely meaningless: "Its compactness and elegance have made it popular with educators, language designers, programmers, implementors, and hobbyists."

== Historical revisionism ==

Wouldn't it make sense to either simply state that "It is popular for its compactness", or to remove the overly broad and ambiguous "programmers, implementors, and hobbyists"? [[Special:Contributions/174.1.213.234|174.1.213.234]] ([[User talk:174.1.213.234|talk]]) 17:02, 20 May 2013 (UTC)

Isn't the following claim in the 1st paragraph of the article (boldface mine) revisionist?

:Changing that. [[User:Qwertyus|Q<small>VVERTYVS</small>]] <small>([[User talk:Qwertyus|hm?]])</small> 07:19, 19 July 2013 (UTC)

:''"Scheme is a functional programming language and a dialect of Lisp. It was developed by Guy L. Steele and Gerald Jay Sussman in the 1970s '''initially as an attempt to understand the Actor model''' and introduced to the academic world via a series of papers now referred to as Sussman and Steele's Lambda Papers."''

== The Hofstaedter example ==

From Structure and Interpretation of Computer Programs, available online [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-7.html] the most complete historical account that I was able to find on a moment's notice follows:

IMHO the Hofstaedter example looks a bit ugly and seems not to be very scheme-like (besides <code>letrec</code> of course). It evaluates to #f and depends mostly on the side effects of <code>display</code>. Wouldn’t it be more appropiate if it evaluated e. g. to a list of pairs <code>(female male)</code> like this:

:''"Scheme, the dialect of Lisp that we use, is an attempt to bring together the power and elegance of Lisp and Algol. From Lisp we take the metalinguistic power that derives from the simple syntax, the uniform representation of programs as data objects, and the garbage-collected heap-allocated data. From Algol we take lexical scoping and block structure, which are gifts from the pioneers of programming-language design who were on the Algol committee. We wish to cite John Reynolds and Peter Landin for their insights into the relationship of Church's lambda calculus to the structure of programming languages. We also recognize our debt to the mathematicians who scouted out this territory decades before computers appeared on the scene. These pioneers include Alonzo Church, Barkley Rosser, Stephen Kleene, and Haskell Curry."''

<syntaxhighlight lang="Scheme">

I have been unable to document the claim that [[Scheme]] is in some way indebted to the [[Actor model]] (I have two refereneces Kent Dybvig's book and Abelson and Sussman. I find the claim strange, since I have used scheme and T and recognize its heritage, but the actor model I didn't think was one of the predecessors, particularly of such prominence. I will believe the claim, however, if someone provides a reference. --[[User:CSTAR|CSTAR]] 21:19, 10 July 2005 (UTC)

(define (hofstaedter-male-female n)

(letrec ((female (lambda (n)

(if (= n 0)

1

(- n (male (female (- n 1)))))))

(male (lambda (n)

(if (= n 0)

0

(- n (female (male (- n 1))))))))

(let loop ((i 0))

(if (> i n)

'()

(cons (cons (female i)

(male i))

(loop (+ i 1)))))))

(hofstaedter-male-female 8)

:The review paper [http://www.dreamsongs.com/NewFiles/HOPL2-Uncut.pdf The Evolution of Lisp] by [[Guy L. Steele, Jr.]] himself and [[Richard P. Gabriel]] claims

==> ((1 0) (1 0) (2 1) (2 2) (3 2) (3 3) (4 4) (5 4) (5 5))

::''"The dialect of Lisp known as Scheme was originally an attempt by Gerald Jay Sussman and Steele during Autumn 1975 to explicate for themselves some aspects of Carl Hewitt's theory of actors as a model of computation."''

</syntaxhighlight>

:(From section 2.8 Scheme 1975&ndash;1985.) -- [[User:Tobias Bergemann|Tobias Bergemann]] 13:17, July 11, 2005 (UTC)

It is of course a matter of taste and style, but functional parts of a program should be separated from imperative parts (cf. e. g. Conrad Barski, Land of Lisp, San Francisco 2011, p. 302). Displaying the results could be done with <code>for-each</code>, which according to R5RS is explicitly to be called because of its side-effects:

:::This statement is indeed correct, but nevertheless, I still think it is misleading (and revisionist) to mention the actor model in the second sentence. It's fine to mention it, but in a more nuanced history section further down, where other relevant ancestors are also mentioned. Particularly, since no mention is made in the intro on continuations, which is really the essential point of why scheme was developed to understand actors, as is evident a few lines down from the quote you provided:

<syntaxhighlight lang="Scheme">

::::''"Functional interactions were modeled with the use of continuations; one might send the actor named “factorial” the number 5 and another actor to which to send the eventually computed value (presumably 120)."''

(for-each (lambda (item)

(begin

(display (car item))

(display " ")

(display (cdr item))

(display "\n")))

(hofstaedter-male-female 8))

===> #<unspecified>

:::Continuations as first-class objects is one of the distinguishing characteristics of scheme. --[[User:CSTAR|CSTAR]] 15:01, 21 July 2005 (UTC)

1 0

::::Hm, "misleading" and "revisionist" are strong words, but I agree that the goals driving the original conception of Scheme (understanding the actors model) are far removed from the goals driving the later development of Scheme, and the very first paragraph of an entry on Scheme in an encyclopedia should probably describe the status quo of Scheme rather than the reasons for its creation. That being said I think that the first five paragraphs of this entry taken together already provide a quite balanced overview of the features and roots of Scheme.

1 0

::::(I also agree that continuations as first-class objects is an important characteristic of Scheme, but its inclusion in Standard Scheme was and remains a topic that is controversially discussed amongst the editors of RnRS. First-class continuations are mentioned in the third paragraph right after the lexical scoping that was adopted from [[Algol]]. [[Algol]] was probably as strong an influence in the early development of Scheme as the actor model.) --[[User:Tobias Bergemann|Tobias Bergemann]] 09:53, 22 July 2005 (UTC)

2 1

2 2

3 2

3 3

4 4

5 4

5 5

</syntaxhighlight>

[[User:Sokleidas|Sokleidas]] ([[User talk:Sokleidas|talk]]) 22:30, 7 November 2012 (UTC)

== R7RS ==

:::::(I finally found the reference I was originally looking for w/r/t Scheme's original conception and its relation to the actor model. In his 2002 essay ''[http://www.dreamsongs.com/ObjectsHaveNotFailedNarr.html Objects have not failed]'', Guy L. Steele, Jr. writes:

What's up with that? The article seems out-of-date on that. Far as I can tell it's been delayed quite a bit, but then I don't follow Scheme news at all. --[[Special:Contributions/82.128.250.221|82.128.250.221]] ([[User talk:82.128.250.221|talk]]) 10:19, 31 March 2014 (UTC)

::::::''"The Scheme programming language was born from an attempt in 1975 to explicate object-oriented programming in terms that Gerry Sussman and I could understand. In particular, we wanted to restate Carl Hewitt's theory of actors in words of one syllable, so to speak. One of the conclusions that we reached was that "object" need not be a primitive notion in a programming language; one can build objects and their behavior from little more than assignable value cells and good old lambda expressions. Moreover, most of the objects in Hewitt's theory were stateless and unchanging once created; for those, lambda expressions alone were sufficient."''

:I've updated the panel on the right, as R7RS has been officially ratified. But we should also state that in the introduction, where R6RS is mentioned as the new standard. [[User:Csl77|cslarsen]] ([[User talk:Csl77|talk]]) 11:30, 29 December 2014 (UTC)

:::::This was the reference I had originally wanted to provide, but could not find at the time, so I quoted the Evolution paper above. Another reference more relevant to the later development of Scheme is the [http://www.swiss.ai.mit.edu/projects/scheme/rrrs-archive.html archives of the RnRS authors' mailing list] from 1984 onwards.) --[[User:Tobias Bergemann|Tobias Bergemann]] 12:39, 22 July 2005 (UTC)

== The first paragraph should not mention Common Lisp ==

The header needs to focus more on Scheme exclusively. [[Special:Contributions/137.124.161.12|137.124.161.12]] ([[User talk:137.124.161.12|talk]]) 02:30, 29 January 2016 (UTC)

== Introduction ==

:I think it's quite natural that the first paragraph does mention Common Lisp, if only to emphasize the minimalist philosophy behind Scheme's design and contrast it with the "everything and the kitchen sink" philosophy underlying the design of Common Lisp (which explicity tried to merge the features of the various dialects of (Mac)Lisp). However, I agree that the concrete wording of the first paragraph seems uneven.

The intro currently reads:

:The first paragraph {{oldid|Scheme (programming language)|701085086|currently has this to say}}:

::'''Scheme''' and [[Common Lisp]] are the two principal [[Programming language dialect|dialect]]s of the [[Programming language|computer programming language]] [[Lisp (programming language)|Lisp]]. Unlike Common Lisp, Scheme follows a [[Minimalism (computing)|minimalist]] design philosophy that specifies a small standard core accompanied by powerful tools for language extension.

:It used to read {{oldid|Scheme (programming language)|637554029|like this}}:

::'''Scheme''' is a [[functional programming]] language and one of the two main [[programming language dialect|dialects]] of the programming language [[Lisp programming language|Lisp]]. Unlike [[Common Lisp]], the other main dialect, Scheme follows a [[Minimalism (computing)|minimalist]] design philosophy specifying a small standard core with powerful tools for language extension.

:Even though both versions offer the same content, I think I prefer the older version. —[[User:Tobias Bergemann|Tobias Bergemann]] ([[User talk:Tobias Bergemann|talk]]) 08:40, 29 January 2016 (UTC)

::I have restored the first paragraph to the version of 2014-12-11. —[[User:Tobias Bergemann|Tobias Bergemann]] ([[User talk:Tobias Bergemann|talk]]) 07:39, 5 February 2016 (UTC)

:''"'''''Scheme''' is a [[functional programming language|functional]] [[programming language]] and a [[programming language dialect|dialect]] of [[Lisp programming language|Lisp]]. It was developed by [[Guy L. Steele]] and [[Gerald Jay Sussman]] in the [[1970s]] initially as an attempt to understand the [[Actor model]] and introduced to the academic world via a series of papers now referred to as Sussman and Steele's [[Lambda Papers]]."''

:''"Scheme's philosophy is unashamedly [[Computing_minimalism|minimalist]]. Its goal is not to pile feature upon feature, but to remove weaknesses and restrictions that make new features appear necessary. Therefore, Scheme provides as few primitive notions as possible, and lets everything else be provided by libraries that are built on top of them (or using extra functionality in various implementations). For example, the main mechanism for governing control flow is [[tail recursion]]. (Some people refer to Scheme as a family of related languages, each defined by some implementation.)"''

I'd like to rewrite this to remove the necessity for the two parenthetical statements. Here's my first draft for a rewrite:

:''"'''''Scheme''' is a [[functional programming language|functional]] [[programming language]] and a [[programming language dialect|dialect]] of [[Lisp programming language|Lisp]]. It was developed by [[Guy L. Steele]] and [[Gerald Jay Sussman]] in the [[1970s]] initially as an attempt to understand the [[Actor model]] and introduced to the academic world via a series of papers now referred to as Sussman and Steele's [[Lambda Papers]]. Minor implementation details tend to differ slightly, so sometimes Scheme is referred to as a family of closely related programming languages."''

:''"Scheme's philosophy is unashamedly [[Computing_minimalism|minimalist]]. Its goal is not to pile feature upon feature, but to remove weaknesses and restrictions that make new features appear necessary. Therefore, Scheme provides as few primitive notions as possible, and where this is practical in an implementation, tends to let everything else be provided by libraries that are built on top of them. For example, the main mechanism for governing control flow is [[tail recursion]]."'' --[[User:Tony Sidaway|Tony Sidaway]][[User talk:Tony Sidaway|<small>^Talk</small>]] 12:21, 29 August 2005 (UTC)

:Please add *some* text instead that makes it clear that Scheme programmers do not start every project by writing the things that you get for free elsewhere. This is exactly how the paragraph sounds, and a very common (and very stale) anti-CL propaganda line.

::Goodness, no they don't! I'm writing my current project using seven scheme modules. What *is* true is that implementations differ somewhat. For instance, I would have to (and probably will) do a considerable amount of work to make my code work on most widely used implementations of scheme. --[[User:Tony Sidaway|Tony Sidaway]][[User talk:Tony Sidaway|<small>^Talk</small>]] 19:33, 30 August 2005 (UTC)

== Explanation of [[User:Tony Sidaway|Tony Sidaway]]'s revert of an edit by [[User:24.128.49.163|24.128.49.163]] ==

In [http://en.wikipedia.org/w/index.php?title=Scheme_programming_language&diff=24588876&oldid=24372409 an edit at 20:34, 2 October 2005], {{user|24.128.49.163}} made the following changes:

1. "Some people are at first put off by all the parentheses used in Scheme notation." -> "Many people are put off by all the parentheses used in Scheme notation.''

2. "after a short period of accommodation the parentheses become unobtrusive" -> "after a period of accommodation the parentheses supposedly become unobtrusive"

3. Addition of two paragraphs describing the syntax of Scheme as "cryptic and unintuitive...therefore relatively hard to learn" Claiming that Scheme program execution speed is limited to "a fraction of the speed of programs written in a modern compiler language." by the mode of implementation. Claiming that the use of Scheme as a good introductory language for computer science is "a myth [that] has been debunked."

Point 1 seems incorrect and ignores the learning curve.

Point 2 is weaseling, "supposedly".

The syntax of Scheme is as a matter of fact on of the simplest of any programming language. The assumption that Scheme cannot be compiled is simply incorrect. No support is given for the claim that the utility of Scheme for introductory computer science has been "debunked."

I have therefore reverted. --[[User:Tony Sidaway|Tony Sidaway]][[User talk:Tony Sidaway|<small>^Talk</small>]] 21:21, 2 October 2005 (UTC)

:Yeah, the anon user's edit is an obvious troll. --[[User:Neilc|Neilc]] 22:30, 2 October 2005 (UTC)

== Advantages/Disadvantages ==

These sections are POV, not to mention unsourced and very subjective. It reads like point->counter-point, where the last counter-point ends up being pro-scheme and in some cases anti-lisp. The disadvantage section itself is more like a "debunking disadvantages" section and it's funny that it's tiny in comparison to the advantages section anyway. I'm not even sure how things like curly/square brackets are an "advantage" over anything. Plus I question adding an "advantages" section in general to any programming language article. Most don't have a "advantages" section and for good reason, because you're not actually comparing it to anything except "every other programming language in existence," which isn't helpful. [[User:Njyoder|Nathan J. Yoder]] 05:42, 19 October 2005 (UTC)

== "Always built on" ==

''The hygienic macro system is always built on some low-level facility which provides the full power of non-hygienic macros, including arbitrary syntax-time computations.''

What does this mean? That every single Scheme implementation provides unhygienic macros in some way?

: good catch, I'll change it to "usually". [[User:Sunnan|Sunnan]] 07:28, 18 December 2005 (UTC)

==Scheme tools on Wikipedia==

* [http://tools.wikimedia.de/~tony_sidaway/ My tools homepage]

As I enjoy programming in Scheme I'm employing that language in writing tools for Wikipedia. The first tool is one that measures the degree of vandalism on popular articles on various Wikipedias by examining edit summaries to recognise probable reverts of vandalism. At the time of writing it recognises vandalism reverts on the English, German, French and Spanish Wikipedias. --[[User:Tony Sidaway|Tony Sidaway]]|[[User talk:Tony Sidaway|Talk]] 02:49, 27 December 2005 (UTC)

==Implementations links==

A lot of the links in the Implementations section seem more like ads than encyclopedia citations. That section looks a bit like a [[:WP:SPAMHOLE]]; cleanup would be good. &mdash;<tt>[[User:donhalcon|donhalcon]]</tt>^{[[User talk:donhalcon|╤]]} 04:01, 3 March 2006 (UTC)

:Perhaps it would be a good idea to clean up [[:Category:Scheme compilers]] and just link to that rather than having a huge list of ad-like links. &mdash;<tt>[[User:donhalcon|donhalcon]]</tt>^{[[User talk:donhalcon|╤]]} 04:07, 3 March 2006 (UTC)

::There are interpreters, compilers, bytecode compilers, image-based bytecode compilers and probably stranger things... It might be better to make a [[Comparison of Scheme Implementations]] with a very small set of criteria (OSs, type (compiled &&|| interpreted &&|| bytecode), standard) [[User:Quamaretto|Quamaretto]] 18:16, 20 March 2006 (UTC)

== pronounciation of car and cdr ==

It would be really cool to upload sound files for the pronounciation of car and cdr. Anyone know how to do this? [[User:Ideogram|Ideogram]] 10:39, 28 May 2006 (UTC)

== box and pointer diagram ==

It would be nice to add a box-and-pointer diagram to the explanation for how lists are composed of cons cells. [[User:Ideogram|Ideogram]] 10:40, 28 May 2006 (UTC)

== ports ==

Can more be said about ports? I am not familiar with them. [[User:Ideogram|Ideogram]] 23:14, 29 May 2006 (UTC)

There is not much to be said about ports that is not already said in [[Scheme programming language#Input/output|the article]]. Quoting [http://www.schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-9.html#%_sec_6.6.1 R5RS]: ''"Ports represent input and output devices. To Scheme, an input port is a Scheme object that can deliver characters upon command, while an output port is a Scheme object that can accept characters."'' <code>read</code> and <code>write</code> and the other I/O operations of Scheme operate on ports. They more or less correspond to istream and ostream of [[C++]]. &mdash; [[User:Tobias Bergemann|Tobias Bergemann]] 12:14, 31 May 2006 (UTC)

== strongly typed? ==

how is scheme strongly typed (infobox)? [[User:Ideogram|Ideogram]] 17:43, 30 May 2006 (UTC)

: The terminology wrt. strongly/weakly typed and statically/dynamically typed is somewhat confusing and not used consistently among different authors. As far as I can see, most contemporary authors that care about terminology at all would call Scheme strongly, dynamically typed. [[Haskell programming language|Haskell]] would be an example of a programming language that is strongly, statically typed, and [[C programming language|C]] would be an example of a programming language that is weakly, statically typed. (See [[type system]].) &mdash; [[User:Tobias Bergemann|Tobias Bergemann]] 21:34, 30 May 2006 (UTC)

::The articles for Lisp and Common Lisp don't describe them as strongly typed, only dynamically typed. [[User:Ideogram|Ideogram]] 22:30, 30 May 2006 (UTC)

::From [[strongly-typed programming language]]: Common Lisp has a complex, fine-grained system of data types, but is almost entirely dynamically typed.

::Schme has a number tower (terminology?) by which most arithmetic operations between numbers of different machine representations are inferred. [[User:Ideogram|Ideogram]] 22:35, 30 May 2006 (UTC)

:::As I understand contemporary terminology, a programming is called strongly typed if type errors cannot go unnoticed. A programming language is called dynamically typed if type errors are (mostly) detected at run time, and statically typed if type errors are (mostly) detected at compile time. Using these definitions Scheme (and [[Common Lisp]], and [[Smalltalk]], and [[Python]] etc.) are certainly strongly typed.

:::However, as I said, the terminology is not used consistently within the literature. Even the Scheme standard document [http://www.schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-4.html R5RS] says: ''"Scheme has latent as opposed to manifest types. Types are associated with values (also called objects) rather than with variables. (Some authors refer to languages with latent types as weakly typed or dynamically typed languages.) Other languages with latent types are APL, Snobol, and other dialects of Lisp. Languages with manifest types (sometimes referred to as strongly typed or statically typed languages) include Algol 60, Pascal, and C."''

:::Even more confusing is that some authors apparantly restrict the term "type error" to mean type errors that are detected at compile time.

::: The paper [http://citeseer.ist.psu.edu/cardelli85understanding.html On Understanding Types, Data Abstraction, and Polymorphism] by [[Luca Cardelli]] and [[Peter Wegner]] says: ''"Programming languages in which the type of every expression can be determined by static program analysis are said to be statically typed. Static typing is a useful property, but the requirement that all variables and expressions are bound to a type at compile time is sometimes too restrictive. It may be replaced by the weaker requirement that all expressions are guaranteed to be type-consistent although the type itself may be statically unknown; this can be generally done by introducing some run-time type checking. Languages in which all expressions are type-consistent are called strongly typed languages. If a language is strongly typed its compiler can guarantee that the programs it accepts will execute without type errors. In general, we should strive for strong typing, and adopt static typing whenever possible. Note that every statically typed language is strongly typed but the converse is not necessarily true."'' This view is at least consistent with that expressed on [[type system]]. &mdash; [[User:Tobias Bergemann|Tobias Bergemann]] 07:40, 31 May 2006 (UTC)

::::Ok I'll put strongly typed back in, unless anyone else has an opinion. [[User:Ideogram|Ideogram]] 11:55, 31 May 2006 (UTC)