dict.org

The DICT Development Group


Search for:
Search type:
Database:

Database copyright information
Server information
Wiki: Resources, links, and other information


3 definitions found
 for quine
From WordNet (r) 3.0 (2006) :

  Quine
      n 1: United States philosopher and logician who championed an
           empirical view of knowledge that depended on language
           (1908-2001) [syn: Quine, W. V. Quine, Willard Van
           Orman Quine]

From The Jargon File (version 4.4.7, 29 Dec 2003) :

  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:
  
      char*f="char*f=%c%s%c;main()
      printf(f,34,f,34,10);%c";
      main(){printf(f,34,f,34,10);
  
      For excruciatingly exact quinishness, remove the interior line breaks. Here
      is another elegant quine in ANSI C:
  
      #define q(k)main(){return!puts(#k"\nq("#k")");
      q(#define q(k)main(){return!puts(#k"\nq("#k")");)
  
      Some infamous Obfuscated C Contest entries have been quines that
      reproduced in exotic ways. There is an amusing Quine Home Page.
  

From The Free On-line Dictionary of Computing (18 March 2015) :

  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:
  
      char*f="char*f=%c%s%c;main() printf(f,34,f,34,10);%c";
      main(){printf(f,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)
  

Questions or comments about this site? Contact webmaster@dict.org