[1] : WordNet (r) 2.0

quine
     n : united states philosopher and logician who championed an
         empirical view of knowledge that depended on language
         1908-2001 syn: w. v. quine, willard van orman quine
see also:
w. v. quine willard van orman quine 

[2] : Jargon File (4.3.1, 29 Jun 2001)

quine /kwi:n/ n. from the name of the logician willard van orman
   quine, via douglas hofstadter a program that generates a copy of its
   own source text as its complete output. devising the shortest possible
   quine in some given programming language is a common hackish amusement.
   we ignore some variants of basic in which a program consisting of a
   single empty string literal reproduces itself trivially. here is one
   classic quine:

  lambda x
    list x list quote quote x
   quote
      lambda x
        list x list quote quote x
  
   this one works in lisp or scheme. it's relatively easy to write quines
   in other languages such as postscript which readily handle programs as
   data; much harder and thus more challenging in languages like c which
   do not. here is a classic c quine for ascii machines:

  charf="charf=csc;main
  printff,34,f,34,10;c";
  mainprintff,34,f,34,10;
  
   for excruciatingly exact quinishness, remove the interior line breaks.
   here is another elegant quine in ansi c:

  define qkmainreturnputsk"\nq"k"";
  qdefine qkmainreturnputsk"\nq"k"";
  
   some infamous obfuscated c contest entries have been quines that
   reproduced in exotic ways. there is an amusing quine home page
   http://www.nyx.org/~gthompso/quine.htm.


see also:
printff,34,f,34,10; returnputsk"\nq"k""; obfuscated c contest 

[3] : The Free On-line Dictionary of Computing (27 SEP 03)

quine
     
         /kwi:n/ after the logician willard v. quine,
        via douglas hofstadter a program that generates a copy of its
        own source text as its complete output.  devising the shortest
        possible quine in some given programming language is a common
        hackish amusement.
     
        in most interpreted languages, any constant, e.g. 42, is a
        quine because it "evaluates to itself".  in certain lisp
        dialects e.g. emacs lisp, the symbols "nil" and "t" are
        "self-quoting", i.e. they are both a symbol and also the value
        of that symbol.  in some dialects, the function-forming
        function symbol, "lambda" is self-quoting so that, when
        applied to some arguments, it returns itself applied to those
        arguments.  here is a quine in lisp using this idea:
     
         lambda x list x x lambda x list x x
     
        compare this to the lambda expression:
     
        	\ x . x x \ x . x x
     
        which reproduces itself after one step of beta reduction.
        this is simply the result of applying the combinator fix
        to the identity function.  in fact any quine can be
        considered as a fixed point of the language's evaluation
        mechanism.
     
        we can write this in lisp:
     
         lambda x funcall x x lambda x funcall x x
     
        where "funcall" applies its first argument to the rest of its
        arguments, but evaluation of this expression will never
        terminate so it cannot be called a quine.
     
        here is a more complex version of the above lisp quine, which
        will work in scheme and other lisps where "lambda" is not
        self-quoting:
     
         lambda x
           list x list quote quote x
          quote
             lambda x
               list x list quote quote x
     
        it's relatively easy to write quines in other languages such
        as postscript which readily handle programs as data; much
        harder and thus more challenging in languages like c
        which do not.  here is a classic c quine for ascii
        machines:
     
         charf="charf=csc;main printff,34,f,34,10;c";
         mainprintff,34,f,34,10;
     
        for excruciatingly exact quinishness, remove the interior line
        break.  some infamous obfuscated c contest entries have been
        quines that reproduced in exotic ways.
     
        ken thompson's back door involved an interesting variant
        of a quine - a compiler which reproduced part of itself when
        compiling a version of itself.
     
        jargon file
     
        1995-04-25
     
     
see also:
lisp emacs lisp lambda expression beta reduction combinator fix 
identity function fixed point postscript c ascii 
printff,34,f,34,10; obfuscated c contest ken thompson back door jargon file 

Quine >> Q Words
Quine, definition of term: Quine
quine_pag1.html