[Question]
  [
Your task is to calculate the square root of 2 using Newton's Method - with a slight twist. Your program is to calculate an iteration using Newton's Method, and output the source code for the following iteration (which must be able to do the same).
Newton's method is fairly exhaustively described on [Wikipedia](http://en.wikipedia.org/wiki/Newton%27s_Method)
To calculate square root 2 using Newtons method, you:
* Define `f(x) = x^2 - 2`
* Define `f'(x) = 2x`
* Define `x[0]` (the initial guess) `= 1`
* Define `x[n+1] = x[n] - (f[n] / f'[n])`
Each iteration will move x[n] closer to the square root of two. So - 
* `x[0] = 1`
* `x[1] = x[0] - f(x[0])/f'(x[0]) = 1 - (1 ^ 2 - 2) / (2 * 1) = 1.5`
* `x[2] = x[1] - f(x[1])/f'(x[1]) = 1.5 - (1.5 ^ 2 - 2) / (2 * 1.5) = 1.416666667`
* `x[3] = x[2] - f(x[2])/f'(x[1]) = 1.416666667 - (1.416666667 ^ 2 - 2) / (2 * 1.416666667) = 1.414215686`
* and so on
Your program will:
* Calculate `x[n]` where `n` is the amount of times the program has been run
* Output the source code to a valid program in the same language which must calculate `x[n+1]` and satisfy the same criteria of this question.
* The first line of the source code must be the calculate result, properly commented. If the source requires something particular (such as a shebang) on the first line, the result may be put on the second line.
Note that
* Your program must use an initial guess of `x[0] = 1`
* The [Standard Loopholes](http://meta.codegolf.stackexchange.com/questions/1061/standard-loopholes-which-are-no-longer-funny) apply
* Any in-build power, square root or xroot functions are forbidden
* Your program must not accept any input whatsoever. It must be entirely self contained.
Your score is the size of your initial program in UTF-8 bytes. The lowest score wins.
  
[Answer]
# Common Lisp, 223 95 68 66
```
(#1=(lambda(x p)(format t"~S~%~S"p`(,x',x,(+(/ p 2)(/ p)))))'#1#1)
```
Now that I read the problem statement more carefully (thanks, [primo](https://codegolf.stackexchange.com/users/4098/primo)!) I noticed that the first line must *be* the result of calculation, not that it needs to *contain* the result. Thus, I think my earlier attempts did not quite follow the rules. This one should.
Example use (SBCL 1.1.15):
```
$ sbcl --script nq.lisp | tee nq2.lisp
1
((LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 '(LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P))))) 3/2)
$ sbcl --script nq2.lisp | tee nq3.lisp
3/2
((LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 '(LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P))))) 17/12)
$ sbcl --script nq3.lisp | tee nq4.lisp
17/12
((LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 '(LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P))))) 577/408)
$ sbcl --script nq4.lisp | tee nq5.lisp
577/408
((LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 '(LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 665857/470832)
$ sbcl --script nq5.lisp | tee nq6.lisp
665857/470832
((LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 '(LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 886731088897/627013566048)
$
```
[Answer]
## Python 53 bytes
*Saved 7 bytes due to [@Mukundan](https://codegolf.stackexchange.com/posts/comments/472150?noredirect=1).*
```
x=1.
o='print"x=%s\\no=%r;exec o"%(x/2+1/x,o)';exec o
```
I've simplified the formula slightly, using the following substitutions:
```
  x-(x²-2)/(2x)
= (2x²)/(2x)-(x²-2)/(2x)
= (2x²-x²+2)/(2x)
= (x²+2)/(2x)
= (x+2/x)/2
= x/2+1/x
```
I hope that's not an issue.
The program proceeds in the following manner:
```
$ python newton-quine.py
x=1.5
o='print"x=%s\\no=%r;exec o"%(x/2+1/x,o)';exec o
$ python newton-quine.py
x=1.41666666667
o='print"x=%s\\no=%r;exec o"%(x/2+1/x,o)';exec o
$ python newton-quine.py
x=1.41421568627
o='print"x=%s\\no=%r;exec o"%(x/2+1/x,o)';exec o
$ python newton-quine.py
x=1.41421356237
o='print"x=%s\\no=%r;exec o"%(x/2+1/x,o)';exec o
```
etc.
[Answer]
# CJam, 20 bytes
```
1
{\d_2/1@/+p"_~"}_~
```
[Try it online.](http://cjam.aditsu.net/)
### Output
```
$ cjam <(echo -e '1\n{\d_2/1@/+p"_~"}_~'); echo
1.5
{\d_2/1@/+p"_~"}_~
$ cjam <(cjam <(echo -e '1\n{\d_2/1@/+p"_~"}_~')); echo
1.4166666666666665
{\d_2/1@/+p"_~"}_~
$ cjam <(cjam <(cjam <(echo -e '1\n{\d_2/1@/+p"_~"}_~'))); echo
1.4142156862745097
{\d_2/1@/+p"_~"}_~
$ cjam <(cjam <(cjam <(cjam <(echo -e '1\n{\d_2/1@/+p"_~"}_~')))); echo
1.4142135623746899
{\d_2/1@/+p"_~"}_~
```
### How it works
```
1       " Push the initial guess.                                                 ";
{       "                                                                         ";
  \d    " Swap the code block with the initial guess and cast to Double.          ";
  _2/   " Duplicate the initial guess and divide the copy by 2.                   ";
  1@/   " Push 1, rotate the initial guess on top and divide.                     ";
  +p    " Add the quotients and print.                                            ";
  "_~"  " Push the string '_~'.                                                   ";
}       "                                                                         ";
_~      " Duplicate the code block (to leave a copy on the stack) and execute it. ";
```
[Answer]
# ECMAScript 6, 38 36
```
(f=x=>"(f="+f+")("+(x/2+1/x)+")")(1)
(f=x=>"(f="+f+")("+(x/2+1/x)+")")(1.5)
(f=x=>"(f="+f+")("+(x/2+1/x)+")")(1.4166666666666665)
(f=x=>"(f="+f+")("+(x/2+1/x)+")")(1.4142156862745097)
(f=x=>"(f="+f+")("+(x/2+1/x)+")")(1.4142135623746899)
```
---
## JavaScript, 51
```
(function f(x){return "("+f+")("+(x/2+1/x)+")"})(1)
```
This is the same as the above, for older browsers.
[Answer]
# Lua 129
Probably way too long, but the Lua quine sucks because the nested `[[ ]]` is a deprecated feature. But it works regardless:
```
x=1.0;x=x/2.+1./x;l=[[io.write('x=',x,';x=x/2.+1./x;l=[','[',l,']','];',l)]];io.write('x=',x,';x=x/2.+1./x;l=[','[',l,']','];',l)
```
It's a bit nicer to see if you add newlines instead of colons:
```
x=1.0
x=x/2.+1./x
l=[[io.write('x=',x,'\nx=x/2.+1./x\nl=[','[',l,']','];',l)]];io.write('x=',x,'\nx=x/2.+1./x\nl=[','[',l,']','];',l)
```
[Answer]
# J - ~~102~~ 88 bytes
This is as horrible as I'm at making quines (I will probably revise this when I get better ideas). J's floats are limited to 5 decimal places, but by replacing first line with `x=:1x` it would be a fraction with infinite precision.
```
Edit 1: I got better idea. Also added the explanation.
```
---
```
x=:1
((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'x=:((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'''
```
First few iterations:
```
x=:1.5
((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'x=:((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'''
x=:1.41667
((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'x=:((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'''
x=:1.41422
((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'x=:((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'''
```
### Explanation
```
((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'x=:((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'''
((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:) The quine-function
                         3&}.,],{:,{:  Build the second row
                         3&}.          Get everything but the first 3 characters from the string
                             ,]        Get the whole string and concat
                               ,{:     Get the last item (') and concat
                                  ,{:  -||-
 (3&{.,[:":(x%2)+1%x"_)                Build the first row
       [:":(x%2)+1%x"_                 Calculate x/2 + 1/x (stolen from Pythoneer) and stringify
  3&{.                                 Take the first 3 characters from the string (x=:)
      ,                                Concatenate 'x=:' and the result
                       ,:              Concatenate the two rows
```
[Answer]
# Ruby, 65
```
x=1.0
puts"x=#{x/2+1/x}",<<'1'*2,1
puts"x=#{x/2+1/x}",<<'1'*2,1
1
```
As too often happens, this is almost a straight port of the Python solution.
[Answer]
# [Perl 5](https://www.perl.org/), (`-M5.01`) 58 bytes
```
$x=1.;$_=q(say'$x='.($x/2+1/$x).qq(;\$_=q($_);eval));eval
```
[Try it online!](https://tio.run/##K0gtyjH9/1@lwtZQz1ol3rZQozixUh3IVdfTUKnQN9I21Fep0NQrLNSwjgFLq8RrWqeWJeZoQiiu////5ReUZObnFf/X9TXVMzAEAA "Perl 5 – Try It Online")
]