Talk:Scheme (programming language): Difference between revisions

Revision as of 13:31, 30 August 2005

Latest revision as of 03:36, 3 January 2025

(176 intermediate revisions by 60 users not shown)

Line 1:

{{Talk header}}

==Hygienic macros==

{{ArticleHistory|action1=PR

Hi

|action1date=10:48, 20 June 2006

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

|action1result=reviewed

|action1oldid=59406708

|action2=GAN

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:

|action2date=03:39, 24 June 2006

|action2result=listed

|action2oldid=60283019

|action3=GAR

Scheme macros

|action3date=03:16, 2 December 2008

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

|action3result=delisted

|action3oldid=254278791

|action4=GAN

*Transforms derived expression types into primitive expression types.

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

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

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

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

|action4result=failed

|action4oldid=361456475

|topic=Engtech

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

|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 ==

----

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)

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">

==Evolution of 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.

Two sections, Disadvantages of Scheme and Standards, talk about official and community standards, but in a rather unenligtening 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.

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

== Comments ==

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)

"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)

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

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

== Toki Pona?==

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)

== Disjointness of types ==

[[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)

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)

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

== outdated? ==

"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.)

== Used on Mars rover ==

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."

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)

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

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

== Expansion needed ==

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

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

* 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.

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.

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.

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

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

* 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.

This article should mention SIOD.

The SRFI process should be covered in more depth.

== cryptic tail-recursive factorial example ==

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)

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.

==Language elements==

I don't know how to program in scheme or any lisp dialect for that mater. I am not a CS but am not computer illeterate 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.

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 don't know the specifics of the rest of the discussion, but I really liked the article aside from these rough edges, Good Job!!

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)

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

== Stuff removed from Boolean data type article ==

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

----

----

[[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)

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

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

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

"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)

== Historical revisionism ==

: 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]].

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

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

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

:''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.''

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

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:

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)

:''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.''

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

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)

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."

''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''

: ''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.''

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)

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

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

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

== The Hofstaedter example ==

:::''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).''

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:

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

<syntaxhighlight lang="Scheme">

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

(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)

::: (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)

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

</syntaxhighlight>

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:

::: (I finally found the reference I was originally looking for wrt. 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

<syntaxhighlight lang="Scheme">

::::''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.''

(for-each (lambda (item)

(begin

(display (car item))

(display " ")

(display (cdr item))

(display "\n")))

(hofstaedter-male-female 8))

===> #<unspecified>

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

==Introduction==

The intro currently reads:

1 0

: '''''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]].''

1 0

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 ==

: ''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.)''

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)

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

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

: '''''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.''

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

: ''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]].''

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)

--[[User:Tony Sidaway|Tony Sidaway]][[User talk:Tony Sidaway|<small>^Talk</small>]] 12:21, 29 August 2005 (UTC)

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

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 vry stale) CL propaganda line.