Get Affordable VMs - excellent virtual server hosting


browse words by letter
a b c d e f g h i j k l m n o p q r s t u v w x y z

quinemore about quine

quine

 

  3  definitions  found 
 
  From  WordNet  r  1.6  [wn]: 
 
  Quine 
  n  :  1908-  [syn:  {Quine},  {Willard  Van  Orman  Quine}] 
 
  From  Jargon  File  (4.2.3,  23  NOV  2000)  [jargon]: 
 
  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 
  (http://www.nyx.org/~gthompso/quine.htm). 
 
 
 
  From  The  Free  On-line  Dictionary  of  Computing  (13  Mar  01)  [foldoc]: 
 
  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)




more about quine