text:
Print your code backwards - reverse quine
Write a program that prints its own source code out backwards, in other words an eniuq.
Scoring:

+50 if you use pull data from the Internet.
+25 if you read your own source code.
+1 point per character
Lowest score wins.

Rules:

No using other files (e.g. reverse.txt)
Minimum code length is two characters.
Your program cannot be a palindrome.

Looks like this has been done before, just without the "no palindromes" rule.

Are those scores bonuses or penalties? You need to specify in words if something is a penalty or a bonus, because saying +10 can be taken to mean either "score as if it had 10 more characters than it actually does" or "the code can have 10 more characters that won't be scored", or other interpretations.

@AJMansfield Lowest score wins means that +x would be a penalty, -x would be a bonus.

They are penalties.

The one question I have, then, is why is pulling data from the internet given a larger penalty than reading the source file?

Woohoo, 1st place on the hot network questions list :D Our site needs more attention...

I posted the challenge http://codegolf.stackexchange.com/questions/16043/mirror-quine-or-my-head-hurts which has tighter rules than this one, so every answer there would qualify as an answer here, but would not score as well. My current answer there is over 6000 characters.

Next time this needs an extra rule about syntax errors (or possibly standard error).

@DoorknobofSnow There's good attention and bad attention. I don't think it's a coincidence that the quality of new questions just dropped considerably (and it wasn't that high to begin with).

When are you actually going to accept a solution?

I can't post an answer but can add a comment. Here's a solution in R. reverse <- function() cat(paste(rev(strsplit(paste(deparse(get(as.character(match.call()[[1]]))), collapse="\n"),"")[[1]]), collapse="")). reverse() will print out ))"" = espalloc ,)]]1[[)"" ,)"n\" = espalloc          ,)))]]1[[)(llac.hctam(retcarahc.sa(teg(esraped(etsap(tilpsrts(ver(etsap(tac     {  )( noitcnuf :P

@lebatsnok You could move your comment to an answer now. :)

This ruins Stack Cats...

GolfScript - 2

1

(ie \n1 where \n is the newline character)
Output:
1

(ie 1\n)

To quote Ilmari:

GolfScript automatically appends a newline to the end of the output

Thus a newline followed by a number will print the number followed by a newline.

+1 I didn't think anything could beat the Mathematica solution.

Pretty boring solution...

@theonlygusti It's golfscript, whaddya expect...

huh?, 5 characters
!hcuO

I actually have NO idea how it works, but If you download the interpreter, and if you write !hcuO, then you get Ouch!
To run this, you need to execute the program like this:
huh.exe !hcuO

It will actually look for a file called !hcuO, but it doesn't exist, so it outputs Ouch!

+1 for writing something you don't understand

Is it not just a little ironic that you don't understand how your own code works, in an esolang that by design isn't supposed to understand your code either?

@Iszi That's the joke.

I'm not sure you're using huh? right, though I'm having a hard time finding proper documentation. It seems the usage is intended to be huh.exe <path to source code> and Ouch! is returned for an invalid path. Try putting your code into an actual file, and feeding that file as an argument to huh? and see what happens. It's also interesting to see that it generates a Notes.txt file with some commentary.

Ok, this thing just told me it thinks it understands but I didn't see anything happen. Maybe I should stop toying with it on my primary system.

What if there IS a file name !hcuO?

Mathematica, 3 chars
a 2

a 2 means a times 2. So the answer is 2 a.

This will probably win unless someone can get a two char solution.

In fact I know a two char solution. Also in Mathematica: 1#. The output is #1.

@alephalpha: Then you should post that as an answer!

H9+, 13 characters
!dlrow ,olleH

As the web page says, all characters that are not H, 9 or + are ignored, so my program will print Hello, world!

The one and only practical benefit of crazy esoteric languages is to answer these crazy questions.

It'd be more practical if these questions were so.

That's pretty darned clever!

According to the JS implementation, H seems to output hello, world\n, therefore your code should be \ndlrow ,olleh, with no bytes added.

Javascript: 34 characters
reifitnedi detcepxenU :rorrExatnyS

outputs SyntaxError: Unexpected identifier, at least in the Chrome console

Clever use of abusing the system through error abuse

You sir, have made my day :D

Not an original idea, there already was an answer about this in python 2.

@Lohoris Sorry, I didn't see that one

Firebug console in Mozilla Firefox: tnemetats erofeb ; gnissim :rorrExatnyS => SyntaxError: missing ; before statement.

Python, 43 41
_=']0~::[_%%_ tnirp;%r=_';print _%_[::~0]

Mathematica, 2 bytes
1#

Outputs:

#1

TI-BASIC, 2
i2

Where i is the imaginary number.
Outputs 2i

This only works in the home screen, not inside a PRGM.

@kernigh Did you try it? It works fine. (If the last statement of a TI-BASIC program evaluates as an expression, its result is printed instead of 'Done' when the program terminates)

BASIC, 22 12 7 characters
:-)
1 enil ni rorre xatnyS

EDIT: If you're allowed to enter the program in immediate mode, then this could be reduced to rorre xatnyS (12 characters).
In BBC BASIC, you only need 7 characters:
ekatsiM

ksh (21 chars)
$ dnuof ton :found :hsk
ksh: dnuof: not found

bash (31 chars)
$ dnuof ton dnammoc :found :hsab-
-bash: dnuof: command not found

sh (29 chars)
$ dnuof ton dnammoc :found :hs-
sh: dnuof: command not found

This one could not work on some Linux distributions, but works on OSX.

tcsh (26 chars)
$ .dnuof ton dnammoC :found.
.dnuof: Command not found.

csh (26 chars)
% .dnuof ton dnammoC :found.
.dnuof: Command not found.

Above should work on all *unix based OS.

Assumptions:

You don't have dnuof command or alias present.

bash (2-4 chars)
This one most likely doesn't qualify, but I'll share it as curiosity.
Assuming the previous shell command in Bash was $!. The following command:
!$

will produce: $!.

Doesn't work for me, i have a command named dnuof

I forgot to add, it doesn't work on distributions which has dnuof installed (whatever it is). Damn hackers.

Hahaha, there's a command named dnuof? :D what does it do?

From the name I can tell dnuof = (d)aily (n)ew (u)ser (of). This outputs how many users have been created on this computer today. Its arguments filter which computer(s) on the Internet to show for the daily new users. (The computer names are decoded by the program; each computer is given a different name.) (.dnuof is an alias for dnuof.)

ha ha this is funny :))

C++ 472 characters
A lot of characters but I cant think of a simpler way in a c-based language.
#include<iostream>
#include<string.h>
#define p(t) std::cout<<'}'<<';'<<')'<<strrev(&std::string(#t)[0])<<t;
char* strrev(char*p){char*t=p;char*q=p;while(q&&*q)++q;for(--q;p<q;++p,--q)*p=*p^*q,*q=*p^*q,*p=*p^*q;return t;}
int main(){p("(p{)(niam tni};t nruter;q*^p*=p*,q*^p*=q*,q*^p*=p*)q--,p++;q<p;q--(rof;q++)q*&&q(elihw;p=q*rahc;p=t*rahc{)p*rahc(verrts *rahc;t<<)]0[)t#(gnirts::dts&(verrts<<')'<<';'<<'}'<<tuoc::dts )t(p enifed#>h.gnirts<edulcni#>maertsoi<edulcni#");}

Befunge 98 - 10 chars
"8k,'!1+,@

This works if your interpreter does not interpret wrapped lines after " as adding an extra space. If your interpreter does interpret wrapped lines like that, then this 11 char solution works (because duplicate spaces in a string literal are interpreted as one):
"9k,'!1+,@

If I can use g without penalty, then these also work (7 and 8 chars respectively):
"5k,g,@

and
"6k,g,@

GolfScript, 12 chars
"-1%.`"-1%.`

This code takes the double-quoted string "-1%.`", reverses it (-1%), duplicates it (.) and un-evals (`) the second copy, restoring the double quotes around it.
Previous entry (13 chars):
{`'.~'+-1%}.~

Based on the 8-char quine {'.~'}.~ from this answer; the extra 5 chars are needed to stringify and reverse the output.
Ps. Note that GolfScript automatically appends a newline to the end of the output.  If this is counted as part of the output, a corresponding newline can be prepended to either version of the code without affecting the output, for a cost of one extra char.

Fission, 6 bytes
A rare case of a generalised quine that is the same length as the normal quine:
"LO+!'

The idea is the same as that of the normal quine, but we're using a left-going atom (starting at the L) so that print mode traverses the code in the opposite order.

Ruby, 60
puts(2,s=<<2.chop.reverse,s)
puts(2,s=<<2.chop.reverse,s)
2

Based on a classic Ruby quine.

Nice use of heredocs.

Perl, 41
$_=q{print~~reverse"\$_=q{$_};eval"};eval

Old 52 character answer (27+25 penalty)
open+0;print ~~ reverse <0>

Reads its own source, stores the reverse in a scalar, and prints that.

The scalar operator can be replaced by ~~. However, you need to add +25 to your score for reading your own source code.

@breadbox noted

+1. I was about to post something like my shell solution: $_='say"lave;\047",~~reverse,"\047=_\$"';eval, but your solution is shorter :-) Note that you can golf it down to 39 characters using say. Hope you will beat all the esoteric weirdness :-)

@Tomas are you suggesting replacing print with say? That ends up not printing anything.

Did you run perl with -Mfeature=say option?

No, I didn't. I don't know if that would count against my score or not.

J: 26
Standard quining (26 chars): by defining a function and passing it its own definition, in quotes:
|.(,],2#{:)'|.(,],2#{:)'''

Could probably be made shorter.
J-specific (33 chars): by defining a variable and asking what file the variable was defined in, i.e. this one, then printing out the contents of that file:
1!:2&2|.1!:1(4!:4 a=:<'a'){4!:3''

Must be saved & run from a script (i.e. not in the REPL, because then the answer to the question is "your argument wasn't defined in a file", so there's no file to read).

The second one should get the + 25 bonus to read the own file.

@JohannesKuhn: Penalty, but yeah.

"Bonus" sounds nicer.

Microscript, 11 bytes
I kind of had to do this.
0"Caxq"Caxq

Surprisingly, this is actually shorter than the language's shortest known true quine. q and a are otherwise equivalent, except q adds wrapping quotes while a does not.

><>, 25 bytes
I was surprised to find this hadn't been done yet. :)
...yhsif sllems gnihtemoS

Paste code here and run it.
. is the Jump command, popping x and y off the stack, and moving the IP to (x, y) in the code box. In this case, the stack is empty, so the language's only error message is printed:
Something smells fishy...

The best answer

PHP, 41 characters (+25)
Don't know if I understood the assignment correctly. But here's a PHP try:
while(!isset($s) || $s) echo isset($s) ? array_pop($s) : ($s = str_split(file_get_contents(__FILE__)) and null);

edit: this can be much shorter:
echo strrev(file_get_contents(__FILE__));

But since it can be that simple, this is probably not what is being asked...

phpFiddle: http://phpfiddle.org/main/code/fuy-mv0

When I click run, I get a whole bunch of useless nonsense (here is a short snippet of it: >? ;)llun dna ))__ELIF__(f$(tilps_rts = s$( : )s$(pop_yarra ? )s$(tessi ohce )s$ || )s$(tessi!(elihw ;"stnetnoc_"=.f$ ;'teg_elif'=f$ php?<>?}};ESLAF nruter;"ec6x\i66x\02x\e47x\96x\rw ; there is much much more). Also, include your character count; this is a code golf. Also, it seems that you are reading your source file, so add 25 to your character count and that is your score. Lowest score wins.

@Quincunx First off, it is backwards ... but secondly, this is the source code that phpfiddle generates! (but backwards...) They seem to escape a lot of thing, trying to keep things safe. Replace array_pop with array_shift to see the source code not backwards...

Yes I can see the reversed source code, but what is with all the extraneous text? There are a lot of escape sequences, but there are some that aren't (eg: ESLAF nruter ie return FALSE).

@Quincunx Sorry, I'm not catching if you are showing interest in the way phpFiddle works, or if you are criticizing my code. If it's the latter, then in my defense, put my code in a .php file and run it in a browser, and it'll work cleanly. I just thought phpfiddle was a nice thing to let you see, so you can see a bit of it's inner workings.

Sorry if it seems I am criticizing. I was just confused by the extraneous detail. Also, with your new version, please state the character count (41) and include the +25 (for total of 66) for reading the file.

This is tagged as [tag:code-golf]

JavaScript jQuery 119 92 74 70  characters
alert($("#answer-16051 pre code").text().split("").reverse().join(""))

Now using jQuery, as minitech suggested in the comments, and manually wrapping with <pre><code> so I can use text() without fear of other code blocks in this post interfering. Manually wrapping with <h4> was incompatible with chromeium when I tested it, so now it should work in most browsers.
This program, if run from this page, finds the code block directly above, reverses its contents, and puts it in an alertbox.
Its easy enough to verify, just paste it into the dev console.

This is way longer than just using a function. And you should use jQuery (on this page) or at least querySelector anyways…

@minitech thanks for the tip, I swapped it for a querySelector now. I would like to look into the jQuery possibility, but it looks like it will take a little longer for me to figure out.

@minitech ok, thanks for the jQuery tip. (I only started learning javascript yesterday.)

I like this solution; thinking outside the box.

UNIX shell, 31
Real solution at 52 characters:
A='printf "A$ lave;\047`echo $A|rev`\047=A"';eval $A

But beware! Honesty doesn't pay off in today's world! Penalty is too low!!
6 chars + 25 = 31:
rev $0

On OSX rev $0 generates the error: rev: illegal option -- b.

MATLAB, 78 characters:

|
.snoisserpxe ro stnemetats BALTAM ni dilav ton si retcarahc tupni ehT :rorrE

Note that the solution requires you to begin with a special character (alt+0160) and that it prints exactly the reversed message. (Unlike the python solution)

MS-DOS, 24 bytes
eman elif ro dnammoc daB

Output:
Bad command or file name

Windows 10 .EXE, 98 bytes
.rehsilbup erawtfos eht htiw kcehc ,CP ruoy htiw noisrev a dnif oT

.CP ruoy no nur t'nac ppa sihT

Is there a version for my PC?

JavaScript, 62
function f(){alert((f+'f()').split('').reverse().join(''))}f()

Works for me on latest Chrome (v 31.0.1650.63). Some other browsers may give a different output. (If you reverse that output, then it would work :P)

SmileBASIC, 118 102 bytes
FOR I=-101TO.?MID$(("+CHR$(34))*3,30,102)[-I];:NEXTFOR I=-100TO.?MID$(("+CHR$(34))*3,30,102)[-I];:NEXT

Japt, 12 bytes
"iQ ²w"iQ ²w

Try it online!
Based off the standard Japt quine
Explanation
"iQ ²w"      // Take this string.        iQ ²w
       iQ    // Insert a quote.          "iQ ²w
          ²  // Double.                  "iQ ²w"iQ ²w
           w // Reverse.                 w² Qi"w² Qi"
             // Implicitly output.

Congrats on your 5th Japt solution; bounty on its way.

@Shaggy wait >_> I wasn't doing this for the bounty

Happy coincidentally for you, so, that there's one going :)

Windows command prompt, 93 bytes
.elif hctab ro margorp elbarepo ,dnammoc lanretxe ro lanretni na sa dezingocer ton si 'file.'

JavaScript, 56
($=_=>_!=$._?_?$(_.slice(1))+_[0]:')':$('($='+$+')('))()

Please state your environment because this does not work in Chrome. Is this Rhino or what?

@GeorgeReith: Anything with ES6 arrow function support. All SpiderMonkeys should work fine, for example (Rhino included).

C, 148
char *a="};)43,b,43,a(ftnirp;]i-57[a=]i[b)++i;67<i;(rof{)(niam;i,]99[b,%c%s%c=a* rahc",b[99],i;main(){for(;i<76;i++)b[i]=a[75-i];printf(a,34,b,34);}

Just a fun play on a typical C quine.

CSS, 88 bytes
<style>:before,*{display:block;unicode-bidi:bidi-override;direction:rtl;content:'<style>

Put in a blank html page to avoid conflict with other tags.

JavaScript, 53 50 46 43 bytes

q=_=>("q="+q+";q()").split("").reverse().join("");q()

(q=_=>`(q=${q})()`.split("").reverse().join(""))()

(q=_=>`(q=${q})()`.split``.reverse().join``)()

(q=_=>[...`(q=${q})()`].reverse().join``)()

Please help me shorten this up.

You don't need the wrapper. q=_=>[...`q=${q}`].reverse().join``  works just as well.

If I remove the wrapper, it will not automatically execute itself.

it doesn't need to.  Functions are fine.

But then, the code returns the function reference, not the output of the function.

@ericw31415 is right. the function call is necessary.

Fuzzy Octo Guacamole, 4 bytes
KNU_

K prints _UNK, N pushes None, and U pushes 0. And _ pops the top value on the stack (but doesn't print). So only _UNK is printed.

Why does K output _UNK?

@RandomUser ask Riker for more details, he's the language's creator. I just read the docs.

Brain-Flak, 3836 + 3 = 3839
(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()())(()()()())(()())(()()())(()()()())(()()()()()()()())(()()())(()()()())(())(()()()()())(()()()()()())(()())(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()()()())(())(()())(()()()()()())(()()())(())(())(()()()()()()())(()()()()()()()())(()()()()())(())(()())(()()()()()())(()()())(())(())(())(())(())(())(())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()()()()()()())(()()()()()()()())(()())(()()()()()()())(()()()()()()()())(()())(()()()()()()())(()()()()()()()())(()())(()()())(()()()())(()())(()())(())(()())(()())(()())(()()()())(()())(()()())(()()()())(()())(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()()()())(())(()())(()()()()()())(()()())(())(()()()()()()())(()()()()()()()())(())(()())(()())(()()()())(()())(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()()()())(())(()())(()()()()()())(()()())(())(()()()()()()())(()()()()()()()())(())(())(())(())(()())(())(()())(())(()())(()())(()())(()()()()()()())(()()()()()()()())(()()()()()()())(()()()()()()()())(()())(()()()()()()())(()()()()()()()())(())(()())(()())(()()()())(()())(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()()()())(())(()())(()()()()()())(()()())(())(()()()()()()())(()()()()()()()())(())(()())(())(()())(()())(()()()())(()())(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()()()())(())(()())(()()()()()())(()()())(())(()()()()()()())(()()()()()()()())(())(())(())(())(()())(())(()())(())(()())(()())(()()()()()()())(()()()()()()()())(())(()())(()())(()()()()()()())(()()()()()()()())(()())(()()()()()()())(()()()()()()()())(())(()())(()())(()()()())(()())(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()()()())(())(()())(()()()()()())(()()())(())(()()()()()()())(()()()()()()()())(())(()())(())(()())(()())(()()()())(()())(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()()()())(())(()())(()()()()()())(()()())(())(()()()()()()())(()()()()()()()())(())(())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()()()()()()())(()()()()()()()())(()()()()()()())(()()()()()()()())(()())(()()()()()()())(()()()()()()()())(()())(()()()())(()())(()()()()()()())(())(()()())(()()()()()()())(()()()()()()()())(())(()()()()()()())(()()()()()()()())(())(()())(())(()())(()())(()()()())(()())(()()()()()()()())(()()()()()()()())(()()()()()()()())(()()()()()()()())(()()()()()()()())(()()()()()()()())(()()()()()()()())(()()()()()()())(()()()()()()()())(())(()()()()())(()()()()()())(()()())(())(()()()()()()())(()()()()()()()())(()()())(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()())(()()()())(()())(()()())(()()()())(()()()()()()()())(()()())(()()()())(()()()())(()())(()()()())(()())(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()()()())(())(()())(()()()()()())(()()())(())(()()()()()()())(()()()()()()()())(()()())(()()()())(()())(()()())(()()()())(()()()())(()())(()()()()()()()())(()()()()()()())(()()()()()()()())(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()()()())(())(()())(()()()()()())(()()())(())(())(())(()()()()()()())(()()()()()()()())(()()()()())(())(()())(()()()()()())(()())(())(()())(()())(()())(()()()())(()())(()()()()()()()())(()()()()()()())(()()()()()()()())(()()())(()()()())(()()()())(()())(()()()()()()()())(()()()()()()())(()()()()()()()())(()()()()()()())(())(()()()()()()())(()()()()()()()())(()()())(()()()())(()())(()()())(()()()())(()()()()()()()())(()()())(()()()()){({}<>)<>}<>([]){({}[()]<(({}[()]<((((((((()()()()()){}){}){})<>))()))>)<>){({}[()]<({}())>){({}[()]<({}(((()()())){}{}){}())>){({}[()]<({}()())>){({}[()]<({}(((()()()){}()){}){}())>){({}[()]<({}()())>){({}[()]<({}(((()()()()())){}{}){})>){(<{}({}()())>)}}}}}}}{}([]<({}<{({}<>)<>}<>>)>){({}[()]<({}<>)<>>)}{}{({}[()]<((({}[()])()))>)}{}<>>)}{}{({}<>)<>}<>

Try it online
+3 bytes from the -A flag
This is a very simple variation on the standard Brain-Flak Quine.   In fact this variant is obtained by removing bytes from the original Quine.  Here is a picture of the original Quine with the removed characters in red:

The reason this variation is so simple is that the original Quine builds two parts of the program each on its own stack.  One of the two parts is reversed so that when they are joined it becomes un-reversed.
So to make the reverse Quine we simply remove a stack swap.
We also have to remove the part of the program that encodes these two bytes otherwise they will be printed as well.

How come the -A flag is 3 bytes?

@MDXF The flag is  -A you need to add a space to call.  For programs that take input you only need plus one because -f can become -fA for one extra byte.

I thought the general concensus on compiler/interpreter flags was that they did not have to include the space or the - in the byte count.

@MDXF No, you do have to include them.

C, 115 bytes
f(){char*s="f(){char*s=c%s%c%;printf(s+42,34,a,34);};)43,s,43,24+s(ftnirp;%c%s%c=s*rahc{)(f";printf(s+42,34,s,34);}

Haha, this is possible in C! Took me a few hours and nearly cheats, but it gets the job done.

Perl, 49 characters
(Note: the actual program is three lines long, the third line being empty.)
print$/,~~reverse<<''x2
print$/,~~reverse<<''x2

Newlines can be a little unintuitive when text is reversed: the output starts with two blank lines. A naive user might expect the output to look more like this program, which is actually significantly shorter:
say~~reverse<< x2
say~~reverse<< x2

But only first listing is actually correct.

Racket 178
(let((l(list->string(reverse(string->list"(let((l(list->string(reverse(string->lista~a~a~))))(q (integer->char 34)))(printf l q l q))"))))(q (integer->char 34)))(printf l q l q))

Output:
))q l q l ftnirp()))43 rahc>-regetni( q())))"))q l q l ftnirp()))43 rahc>-regetni( q())))~a~a~atsil>-gnirts(esrever(gnirts>-tsil(l((tel("tsil>-gnirts(esrever(gnirts>-tsil(l((tel(

Using the powerful printf makes it almost cheating (though I see people pulling their own sources for only 25 penalty.)

beeswax,22 bytes
This is a variant of my beeswax quine (golf you a quine for great good!), also using beeswax’ ability to modify its own code.
J~@D@~1~M.8~3@.+~++~4*

GitHub repository to my beeswax interpreter written in Julia.

><>, 10 8 bytes
2 bytes saved thanks to @JoKing by using ' strings instead of " strings
'd3*}>o<

Try it online!
Explanation
'd3*}>o<               Push the code points of every character in the string 'd3*}>o<'
d3*                    Computes 39, the code point of ' (13*3)
                       Now the stack contains the quote on top of the stack
}                      Shift the stack to the right, so that the ' will be shifted to the bottom of the stack
                       This is required because the ' needs to be printed last
>o<                    Print everything in the stack until the stack is empty
                       And finally the program ends in an error

Would 00g (rather than 84*2+) count as reading the source code?

@Challenger5 I would think so.

How about you use ' instead? 'd3*}>o<?

@JoKing Thanks, that was a neat find

Apple ][ BASIC, 12 bytes
RORRE XATNYS?

Hit the soft RESET key on the emulator to enter BASIC mode.

Commodore 64 BASIC, 13 bytes
RORRE  XATNYS?

@user56656 Being my answer https://codegolf.stackexchange.com/a/105688/29325 invalid, this one should be too.

@DJMcMayhem Being my answer https://codegolf.stackexchange.com/a/105688/29325 invalid, this one should be too.

@ike Being my answer https://codegolf.stackexchange.com/a/105688/29325 invalid, this one should be too.

@sergiol just leaving the comment should be fine (as opposed to pinging three people), I'm willing to delete this if it's invalid. However I disagree that error quines are not allowed by default; this is not asking for a quine, rather a quine variant. I've long thought those two tags should be differentiated.

Additionally, this program defines its own rules for what constitutes as a valid submission as opposed to going along with the "proper quine" rules discussed on the meta.

CJam, 12 bytes
{"~_"\`W%}_~

Explanation:
{             e# Push this block literal:
 "~_"         e#   Push the string "~_"
     \        e#   Swap
      `       e#   Escape
       W%     e#   Reverse
         }    e# End
          _   e# Duplicate
           ~  e# Execute

Wumpus, 11 bytes
"@o&l]=43#"

Try it online!
Explanation
In Wumpus, the IP gets reflected off the boundaries of the grid, so without any further control flow redirection, a program on a single line will bounce back and forth through the code.
"@o&l]=43#"    Push the individual code points of this string to the stack.
               This gives us the entire code except the quotes.
               The IP then bounces off the end and starts moving back through
               the code. Since the " ended string mode, this time around the
               code will actually be executed.
#34            Push 34, the code point of double quotes.
=              Duplicate.
]              Shift one copy to the bottom of the stack.
l              Push the stack depth (i.e. the program length 11).
&o             Print that many characters.
@              Terminate the program.

Python 2, 38 bytes

s="print's cexe;%r=s'%s[::-1]";exec s

Try it online!

JavaScript, 42 bytes
(f=([a,...b]=`(f=${f})()`)=>a?f(b)+a:'')()

Try it online!

Jstx, 3 bytes
£↕o

Try it online!

Gol><>, 6 bytes
"2ss}H

Try it online!
Same as regular Gol><> quine, except that we just put the 34 at the bottom of the stack, instead of flipping the entire stack.

Pepe, 7 bytes
!RORRER

Link to interpreter (paste the code above, link removes the ! and O)
Explanation:
The interpreter ignores characters other than R,r,E,e so the code is:
RRRER

Now to put the code in explanation:
  RE  # Push 0
RR    # (RR flag: doesn't exist)
    R # R doesn't exist, so output RERROR!

05AB1E, 15 bytes
0"D34çýR"D34çýR

Try it online.
Or 17 bytes if a default trailing newline isn't allowed:
0"D34çýR?"D34çýR?

Try it online.
Modification of the default quine 0"D34çý"D34çý by adding R.
Explanation:
0                   # Push 0 to the stack
                    #  STACK: [0]
 "D34çýR"           # Push the string 'D34çýR' to the stack
                    #  STACK: [0, 'D34çýR']
          D         # Duplicate this string
                    #  STACK: [0, 'D34çýR', 'D34çýR']
           34ç      # Push '"' to the stack
                    #  STACK: [0, 'D34çýR', 'D34çýR', '"']
              ý     # Join the stack by this '"' delimiter
                    #  STACK: ['0"D34çýR"D34çýR']
               R    # Reverse the top value on the stack:
                    #  STACK ['Rýç43D"Rýç43D"0']
                    # (Output the top of the stack implicitly)

Your first TIO link is returning 1 for me. I assume you're avoiding the boring 2-byte solution? :P

@Oliver Ah, my first TIO link was a copy-paste error from another quine challenge (the one that checks if an input is a substring of the program itself). I've fixed the TIO link, thanks for noticing. As for the 2-byte solution, that is no longer considered a valid quine in the current meta. More information about it here.

Oracle SQL, 142 bytes
select
reverse(replace('@''[@'||chr(93)||'''))from dual;','@',q'[select
reverse(replace('@''[@'||chr(93)||'''))from dual;','@',q]'))from dual;

Oracle SQL, 118 bytes
select
reverse(substr(rpad(1,144,'||chr(39)),27))from dual;select
reverse(substr(rpad(1,144,'||chr(39)),27))from dual;

Test in SQL Plus
SQL> set lines 80 pages 0
SQL> select
  2  reverse(replace('@''[@'||chr(93)||'''))from dual;','@',q'[select
  3  reverse(replace('@''[@'||chr(93)||'''))from dual;','@',q]'))from dual;
;laud morf))']q,'@',';laud morf))'''||)39(rhc||'@[''@'(ecalper(esrever
tceles['q,'@',';laud morf))'''||)39(rhc||'@[''@'(ecalper(esrever
tceles

SQL> select
  2  reverse(substr(rpad(1,144,'||chr(39)),27))from dual;select
  3  reverse(substr(rpad(1,144,'||chr(39)),27))from dual;
;laud morf))72,))93(rhc||',441,1(dapr(rtsbus(esrever
tceles;laud morf))72,))93(rhc||',441,1(dapr(rtsbus(esrever
tceles

JavaScript, 33 32 bytes
f=([c,...s]='f='+f)=>c?f(s)+c:''

Recursively reverses the string by first providing the quine as the default argument.  This beats the syntax error version, which isn't even consistent between browsers.

Gol><>, 6 bytes
sP#Hr"

This is just another way of doing a reverse quine, similar to Bubbler's answer
Try it online!

MS SQL Server 2017, 173 bytes
declare @ char=1
select
reverse(substring(left(@+replicate('+char(39),3),201),28,174))
declare @ char=1
select
reverse(substring(left(@+replicate('+char(39),3),201),28,174))

Output:
))471,82,)102,)3,)93(rahc+'(etacilper+@(tfel(gnirtsbus(esrever
tceles
1=rahc @ eralced
))471,82,)102,)3,)93(rahc+'(etacilper+@(tfel(gnirtsbus(esrever
tceles
1=rahc @ eralced

Try it on db<>fiddle!

Keg, 16 bytes (SBCS)
`÷^℠⅀:,.`÷^℠⅀:,.

Outputs:
.,:⅀℠^÷`.,:⅀℠^÷`

Explained
`÷^℠⅀:,.`÷^℠⅀:,.

`÷^℠⅀:,.`           #Push the string '÷^℠⅀:,.'
÷^                  #Item split string and reverse stack
℠⅀                  #Summate it all into a string
:,.                 #Standard Keg quine procedure

Try it online!

Vyxal D, 6 bytes
`IṘ`IṘ

Try it Online!
Explained
`IṘ`IṘ
`IṘ`   # The string "IṘ"
    I  # appended to a backtick-surrounded version of itself
     Ṙ # Reversed

PHP, 59
34 + 25 for reading own sourcecode.
<?=strrev(join(file((__FILE__))));

Online demo

Doesn't this get the 25 penalty?

@ike you're right, I edited accordingly

Ruby, 33+25=58
print File.read(__FILE__).reverse

Lua, 31 Characters
'''' raen rorre xatnys :1:tupni

Looks like lua to me, on LUA it says STDIN:1: syntax error near 'rorre'

Matlab, 111
function d=g();d='gvodujpo!e>h)*<e>(<e>gmjqms)\e)2;29*.2-e-e)29;foe*.2^*<';d=fliplr([d(1:18)-1,d,d(18:end)-1]);

Bash, 8 + 25 for reading source = 33 bytes
rev "$0"

31 for no space in path to file
rev $0

Help, WarDoq!, 2 bytes + 25 = 27
 q

The space is needed.

Minimum code length is two characters.

This reads its own source code via the q built-in, so I think this is subject to the +25 bytes penalty.

@Dennis I will add them. Thanks for pointing, although there is no other way to make quines here.

Alice, 10 bytes
"9&o57*to@

Try it online!
Explanation
"9&o57*to@"   Push code points of the entire program except the " to the stack.
9&            Execute the next command 9 times.
o             Print 9 characters from top to bottom (i.e. in reverse order).
57*           Compute 5*7 = 35.
t             Decrement to 34 (the code point of ").
o             Print the quote.
@             Terminate the program.

I'm not 100% sure whether this is optimal. 4 bytes to compute 34 seems painful and while I've found a whole bunch of 4-byte alternatives, I haven't found anything in 3 bytes yet. Some of those alternatives (some of these give other results, but they're 34 (mod 256)):
aN4Y
7aRY
5R1Y
4Pa+
7PYN

CJam, 10 bytes
"W%_`"W%_`

Try it online!
Alternatively:
"`W%_"_W%`

Explanation
"W%_`"   e# Push this string which contains the code after the string.
W%       e# Reverse the string.
_        e# Duplicate it.
`        e# Stringify the copy which wraps it in quotes. The unquoted and
         e# quoted versions are then implicitly printed to STDOUT back to back.

In the alternative solution, the string itself already contains the code in reverse and then we only reverse the copy (i.e. the string representation). It's kinda neat that it's then just one character off from being a palindrome.

Java 8 (function), 144 bytes
v->{String s="v->{String s=%c%s%1$c;return new StringBuffer(s.format(s,34,s)).reverse();}";return new StringBuffer(s.format(s,34,s)).reverse();}

Try it online.
Java 8 (full program), 240 bytes
interface M{static void main(String[]a){String s="interface M{static void main(String[]a){String s=%c%s%1$c;System.out.print(new StringBuffer(s.format(s,34,s)).reverse());}}";System.out.print(new StringBuffer(s.format(s,34,s)).reverse());}}

Try it online.
Explanation:

The String s contains the unformatted source code.
%s is used to input this String into itself with the s.format(...).
%c, %1$c and the 34 are used to format the double-quotes.
s.format(s,34,s) puts it all together.

And then new StringBuffer(...).reverse() is used to reverse this source code.

Haskell, 66 bytes
main=putStr$reverse$s++show s;s="main=putStr$reverse$s++show s;s="

Try it online!

64 bytes: Try it online!

Tcl, 38 bytes
puts [string rev [read [open $argv0]]]

Try it online!

Jelly, 2 bytes
1-

Try it online!
Short but boring.
1 gets ignored when - makes -1 the argument which gets printed.
Jelly, 8 bytes
“ṚṾȮ”ȮṾṚ

Try it online!
(More) interesting but long.
“ṚṾȮ” is a string literal for ṚṾȮ. Ȯ prints the string and returns it. Ṿ unevals the string, yielding the string “ṚṾȮ” (with the quote characters “” as part of the string). Ṛ reverses this string and its result, ”ȮṾṚ“ implicitly gets printed.

Befunge-93 (FBBI), 13 bytes
">:#,_98+2*,@

Try it online!
Relies on nonstandard interpreter behavior. Works pretty much the same as this answer, except it's reversed.

J, 24 Bytes
(|.@,quote)'(|.@,quote)'

Evaluates to the string ')etouq,@.|(')etouq,@.|(
Try it online! Uses echo in order to print result.
Alternatively, if a full program is required:
(echo@|.@,quote)'(echo@|.@,quote)'

Is 34 bytes and prints ')etouq,@.|@ohce(')etouq,@.|@ohce(
Explanation:
Both of these work in the same way:
(|.@,quote)'(|.@,quote)' | Expression to be evaluated
           '(|.@,quote)' | String literal containing the code
(         )              | Hook, (f g) y is evaluated as y f (g y)
     quote               | Wrap the string in quotes
    ,                    | Append to the unquoted version
 |.@                     | Reverse the whole thing

Stax, 14 bytes
"r34b4l"r34b4l

Run and debug it
Yet another adaption of the "34bL"34bL quine.

PowerShell Core, 36 bytes
&($f={&{-join"&(`$f={$f})"[35..0]}})

Try it online!

Julia 1.0, 48 bytes
(a=:(print(reverse("(a=:($(a)))|>eval"))))|>eval

Try it online!
based on this quine
Julia 1.0, 52 bytes
"]esrever∘wohs,tnirp[>|.".|>[print,show∘reverse]

Try it online!
based on this quine


text:
Bloatware contest: producing 100+ MiB executable
Create short source code in your favourite compiled language that compiles into a big (not less than 104857600 bytes) executable file. The program must be runnable (assuming 1GB of free memory) and can do anything (preferrable something simple like a hello world).
Usage of non-obvious tricks is encouraged.
Boring example in C:
int a[1024*1024*25] = { 1 };

int main(){}

Bonus points if it can be "explained" why the executable can't be reduced in size (i.e. all bloat is actually used somehow).

Statically link ALL the libraries!

That's why initially thought about 10+ MiB, but revised to 100+... Or it means all libraries in the system?

Can a HTML file be considered as an executable?

Unlikely.

This could stay on-topic if the winning criterion was changed to "largest output file" or something, but that would invalidate the current answers and make this a duplicate of at least one other challenge. See The state of the popularity contest tag

@cat, Can you please review all my questions and give recommendataion: shall I continue to invent questions like them or they generally no loger fit here?

The modern variant is https://codegolf.stackexchange.com/questions/69189/build-a-compiler-bomb .

OK, here's another one in C, going for the vaguely defined bonus points:
#define a(x) x,x|1,x|2,x|3,x|4,x|5,x|6,x|7
#define b(x) a(x),a(x|8),a(x|16),a(x|24)
#define c(x) b(x),b(x|32),b(x|64),b(x|96)
#define d(x) c(x),c(x|128),c(x|256),c(x|384)
#define e(x) d(x),d(x|512),d(x|4<<8),d(x|6<<8)
#define f(x) e(x),e(x|2048),e(x|4096),e(x|6144)
#define g(x) f(x),f(x|8192),f(x|4<<12),f(x|6<<12)
#define h(x) g(x),g(x|2<<14),g(x|4<<14),g(x|6<<14)
#define i(x) h(x),h(x|2<<16),h(x|4<<16),h(x|6<<16)
#define j(x) i(x),i(x|2<<18),i(x|4<<18),i(x|6<<18)
#define k(x) j(x),j(x|2<<20),j(x|4<<20),j(x|6<<20)
int u,v,z[]={k(0),k(2<<22),k(4<<22),k(6<<22)}
int main(){for(u=v=0;u<1<<25;u++)v|=u!=z[u];return v;}

Basically, at compile time, it build a ascending sequence of integers from 0 to 225 − 1.  At runtime, it verifies that the sequence indeed contains the expected values, and if not, returns a non-zero error code.
Ps. If I did my math right, the executable should be over 100 MiB.  I'll let you know the exact size once it's done compiling...

Ps. My attempts to verify the actual size have been (hopefully temporarily) stymied by what I suspect to be a rather unusual GCC error message: virtual memory exhausted: Cannot allocate memory. o_O Will try to tweak options to see if I can get it to compile somehow.

Aww, I was just picturing you standing on a rolling chair and having a sword fight with another developer.

Also can't build with clang (ICE) and tcc.

Turn off all optimization (-O0) to minimize the demands on the compiler, and enabling pipes (-pipe) might or might not help.

@dmckee: I've tried -O0. Will try -pipe later, once I'm back at my desktop again. (Ps. If I cut it down to 1/4 of its current size, it does compile, giving an executable a bit over 32 MiB. That suggests that the principle is sound, I just need to find a beefier compile server. Now that it's weekend, I might try it on one of the University servers.)

That compiling problem reminds of a winning entry of IOCCC who write his own preprocessor to verify that the program was correct: http://www.ioccc.org/2004/vik2.hint

@IlmariKaronen When I attempt compilation I get the error cc1.exe: out of memory allocating 65536 bytes haha. Perhaps if I had a 64 bit build of GCC it could work.

wasnt able to build, too (64bit GCC; 12GB ram with windows;)
Got up to 10GB of ram usage and heavily filled pagefile and it didnt finish....) had to restart firefox after due to it being pagefiled and getting laggy

C#
Not sure if this qualifies as short, because the source code ended up being >30k :)
I.e - too big to quote. Here's a slightly shortened version of it
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var a = new List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<List<int>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>();
    }
}

The code I actually compiled can be found here: http://pastebin.com/R5T3e3J0
This will create a .EXE file of ~45KiB when compiled without optimizations. Compile it again with Ngen.exe (Native Image Generator) and it becomes a whopping 104MiB!
This works due to how the CLR generic type system works. Each and every List<> in the above code will generate a new type declaration (normally through JIT compilation, but Ngen performs AOT compilation). So one type for List< int >, another for List< List< int > >, and so on. So for this code, a total of 5160 different generic lists will be created.

What you need is a script that will write your program.

It's rather trivial to reduce the size of the program (by removing nesting levels of List). Can it be made so that you can't easily remove the repeating code without affecting program function?

Well of course you can just remove the nesting, but likewise, in the C example you could just remove a few #defines and make the program smaller.
The way I interpreted the requirement that it can't be reduced in size, was that it can't be optimized away. If you're allowed to just modify the source code I don't quite see the point. :)

Although it should be noted that this can probably be optimized away, since the variable a is never used.

COBOL
   ID DIVISION.
   PROGRAM-ID. BLOAT.
   ENVIRONMENT DIVISION.
   DATA DIVISION.
   WORKING-STORAGE SECTION.
   01  THE-TEST-STRINGS.
       05  FILLER OCCURS 11584 TIMES.
           10  TEST-STRING          PIC X(11584).
   LOCAL-STORAGE SECTION.
   01  FIRST-TIME-FLAG              PIC X VALUE "Y".
   01  DISP-BEFORE-STRING     COMP  PIC 9(8).
   01  LOOP-COUNTER           COMP  PIC 9(8).
   01  START-STRING.
       05  FILLER OCCURS 0 TO 11584 TIMES
           DEPENDING ON DISP-BEFORE-STRING.
           10  FILLER               PIC X.
       05  THE-SUBSTRING            PIC X(12).
   01  INITIAL-STRING               PIC X(12)
                                     VALUE "HELLO WORLD!".
   LINKAGE SECTION.
   01  STRING-PARAMETER             PIC X(11584).
   01  THE-RESULT                   PIC X.
   PROCEDURE DIVISION USING
                                    STRING-PARAMETER
                                    THE-RESULT
                                    .

       IF FIRST-TIME-FLAG = "Y"
           PERFORM                  SET-UP-STRINGS
       END-IF
       PERFORM
         VARYING                    LOOP-COUNTER
         FROM                       1
           BY                       1
         UNTIL                      LOOP-COUNTER
           GREATER THAN 11584
         OR STRING-PARAMETER
             EQUAL TO               TEST-STRING
                                        ( LOOP-COUNTER )
       END-PERFORM
       IF STRING-PARAMETER
         EQUAL TO TEST-STRING ( LOOP-COUNTER )
           MOVE "Y"                TO THE-RESULT
       ELSE
           MOVE "N"                TO THE-RESULT
       END-IF
       GOBACK
       .
   SET-UP-STRINGS.
       PERFORM
         VARYING                    LOOP-COUNTER
         FROM                       0
           BY                       1
         UNTIL                      LOOP-COUNTER
           EQUAL TO 11584
           MOVE 11584               TO DISP-BEFORE-STRING
           MOVE SPACE               TO START-STRING
           MOVE LOOP-COUNTER        TO DISP-BEFORE-STRING
           MOVE INITIAL-STRING      TO THE-SUBSTRING
           MOVE START-STRING        TO TEST-STRING
                                        ( LOOP-COUNTER + 1 )
       END-PERFORM
       MOVE "N"                     TO FIRST-TIME-FLAG
       .

A little knowledge can be a dangerous thing.
It can be faster to do one large compare than a lot of small compares; IBM's Enterprise COBOL (up to Version 4.2) can have a maximum WORKING-STORAGE of 128MB (Version 5.0 can have 2GB); LOCAL-STORAGE offers a further 128MB if you need more space.
The task is to confirm that a 11584-byte piece of storage has the value "HELLO WORLD!" somewhere, and the rest is space.
The, fictitious, programmer decides to write a sub-program for this (just in case it is needed elsewhere), and to include their high-performance technique (bonus).
The programmer calculates that 11584 * 11584 is 128MB, so uses WORKING-STORAGE for a huge table, and LOCAL-STORAGE for everything else that is needed.
The programmer codes it up, and smiles knowingly to themselves when the compile is clean. They were right about the 128MB.
Tests the code. It works. Possibly a little slow, but there's a heavy load on machine. Smiles again, thinking how slow it would be if coded without their level of expert knowledge.
The WORKING-STORAGE comes in at 134,189,056 bytes, and there's a good few bytes of other stuff as well. Should be large enough.
The reality is that doing a long compare instead of a short compare, as implemented here, is a very slow way to do it.
Even slower, the LOCAL-STORAGE, which is initialised by run-time routines every time a sub-program is called, causes the entire 128MB to be set up for each CALL.
The programmer was just plain wrong about the size of the table, there is enough room without using LOCAL-STORAGE. Long compares can beat short compares, but only when the actual number of compares is reduced.
I considered swapping the LOCAL-STORAGE and WORKING-STORAGE around, it is just far less likely someone would code it that way round, so I didn't. Putting a VALUE SPACE on the table (if it had been in LOCAL-STORAGE) would have initilised the table twice on each CALL, so even slower.
The Bloat can't be removed, without rewriting the program. Most of the code is bad, though there is one useful technique.
This is not a real-life example, but I can imagine someone doing it, if that someone is clever enough :-)
Compiling is no problem at all. Running it with every possibility quickly proves to be not worth attempting.
Of course, there is a plain old Bug as well. A very common one in "searching" tasks.

PowerBASIC
#BLOAT(104857600)
FUNCTION PBMAIN
  PRINT "Hello World"
  BEEP
END FUNCTION

It's comparable to the C example in the question.

Scala
import scala.{specialized=>s}
import scala.Specializable.{Everything=>E}
class Printer[@s(E) A, @s(E) B, @s(E) C, @s(E) D, @s(E) E, @s(E) F, @s(E) G, @s(E) H]{
    def print(a:A,b:B,c:C)=println(s"$a, $b, $c")
}

object Main extends App{
    (new Printer[Int,Int,Int,Int,Int,Int,Int,Int]).print(1,2,3)
}

The specialized annotation creates a new class for each type in order to prevent boxing when the types eventually all get turned into objects. It will create 10^8 ((Everything consists of 10 types)^(8 type parameters on the class)) class files, each 300-500 bytes, if it doesn't crash first.

This could be explained by saying that performance is important, especially if the class actually did more than have a method to print. Using generic specialized methods instead of putting it all in the declaration would also make it harder to notice

Which scala version do I need to build this? 2.9.2+dfsg-1 does not like s"whatever" and don't know about scala.Specializable.

Scala 2.10 includes the interpolated strings with s"", but you can remove that string without any effect on size. Scala 2.8 has the specialization feature, so if you remove the interpolated string, everything should work fine.

Javascript
function bigenough(){
        var kbytes = $('html').html().length;
        return (kbytes>1024*100);
}
while(!bigenough()){
$('html').append('
WASSUP
');}

Run this code in Browser Console on this page and when complete, save the page. it should result in a file size greater than 100 MB. Still testing. Will post actual size once done.
update-
the saved page is the result executable. The v8 engine of chrome is the compiler. And the code I posted is the program. i admit that it does take quiet a long to compile. :D

Doesn't work as required. The task is to create a executable file that is way too big, not one that consumes way too much memory when run. Also, overuse of jQuery.

@JanDvorak it will create a HTML File with size greater than 100MB. Also the Question doesnot specify any JQuery usage limitations.  The program is still executing on my Chrome and the page is consumning 300mb of memory as reported by the Chrome Task Manager.

It won't. Every append you do happens purely in memory. It will only create an 100MB HTML file if the user triggers a save operation. Which he might not be able to do, nor want to. Also, even if you call this process of appending "compilation" and you manage to store the resulting HTML as a file, I don't think you're allowed to write your own compiler.

@JanDvorak I have pointed out in the answer that the page must be saved. here, the page is the result executable. The v8 engine of chrome is the compiler. And the code I posted is the program.

V8 is a compiler that produces a tiny "executable" (which never gets it to the hard drive) and executes it, which then proceeds on to generate a huge "source file" (in a language that isn't even compiled, nor a programming language). If you call the result of your script an executable (nope...) then we must call your script the compiler, not V8. It's not called compilation if your script gets executed in the process (macros kinda blur that line, but this isn't a macro)

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Mirror quine (or my head hurts)
I was reading Print your code backwards - reverse quine And I thought, this could be more interesting if your backwards code is also executable. So this challenge will have all the rules and requirements of the other, but must also be valid source once reversed (in the same or another language and still print its source backwards).
All rules and scoring from the reverse quine challenge apply, so all answers to this question will answer that one (but not score as well).
Rules:

Write a program p which when executed produces output p' where p' is p backwards and p' when executed produces p.
No using other files (e.g. reverse.txt)
Minimum code length is two characters.
Your program cannot be a palindrome.

Scoring:

+50 if you use pull data from the Internet.
+25 if you read your own source code.
+1 point per character.
Lowest score wins.

eval(eval(eval(eval(eval(eval(eval(eval(eval(p)))))))))

I'm just saying that you'd be able to execute the output of executing the output of executing the output of [...] executing the output of p (same as any quine except for the backwards quine).

@AndrewLarsson Indeed although The proof of concept I am building p will be written in c and p' in perl.

Oh, that'd be cool!

I assume that palindromic programs are not allowed? Because otherwise 1 (or even just the empty program) will work in many languages.

could you move the rules from the other question here so that this question is self-contained?

Yeah, saw that too late. Not a duplicate.

Does executable mean interpretable in an interpreted language?

Related. It took me a few minutes to realise the difference: this one disallows palindromes, the other one asks for a palindrome. That said, the GolfScript answer shows that the restriction against palindromes doesn't really change the challenge significantly as it's fairly easy to sneak in an unused character that breaks it.

The requirement minimum code length is two characters is redundant here because you also require that the program cannot be a palindrome: any sequences of length 0 and 1 are automatically palindromes.

GolfScript, 46 chars
0{`".~#"+.-1%+\.!@@}.~##~.}@@!.\+%1-.+"#~."`{1

Well, this is ugly, but it works.  The output equals the code reversed, and is also a valid GolfScript program which outputs the original code again.
OK, let me try to explain how I constructed it.  First, I started from the quine {".~"}.~, and modified it as in this answer to reverse itself.  To make the output an executable quine in itself, I made a copy of the code before reversing it, and included a # at the end of the code, so that the reversed version at the end became just a comment.  Thus, we get the palindromic quine:
{`".~#"+.-1%}.~##~.}%1-.+"#~."`{

However, by the rules, palindromes are not allowed, so I needed to break the symmetry somehow.  I figured the easiest way would be to include a 0 (which, in itself, is a quine in GolfScript) in the code and flip it to 1 with ! after creating the reversed copy.  Most of the remaining complexity is just ugly stack manipulation to get everything in the right order.

Is it also golfscript when reversed or is it another language?

Yes, it's GolfScript both ways.  Indeed, except for the 0 and 1 at the beginning and end, the rest of the code is a palindrome.

Wow. Okay, I don't feel smart enough for this SE anymore :(

Perl and C 6478 1955
#!/usr/bin/perl -i//
$_=<<'rahc';eval $_; #//
print scalar reverse "#!/usr/bin/perl -i//\n\$_=<<'rahc';eval \$_; #//\n${_}rahc\n" #//
__END__
__END__ enifed#
};)"{ = ][cn\rahcn\n\"(p
};)'n\'( rahctup) 1 == 21%b ( fi
;)d(p;)]1-b[c,",d%",)d(foezis,d( ftnirpns{)b--;b;)c(foezis=b( rof
;)c(p;]9[d rahc;b tni{)(niam diov
}};)]1-b[c(rahctup )]1-b[c(fi{)b--;b;)c(nelrts=b(rof;b tni{)c*rahc(p diov
>h.gnirts< edulcni#
>h.oidts< edulcni#
;}
,0
,53,33,74,711,511,411,74,89,501,011,74,211
,101,411,801,23,54,501,74,74,01,63,59,16
,06,06,93,411,79,401,99,93,95,101,811,79
,801,23,63,59,95,23,53,74,74,01,211,411
,501,011,611,23,511,99,79,801,79,411,23,411
,101,811,101,411,511,101,23,43,53,33,74,711
,511,411,74,89,501,011,74,211,101,411,801,23
,54,501,74,74,29,011,29,63,59,16,06,06
,93,411,79,401,99,93,95,101,811,79,801,23
,29,63,59,95,23,53,74,74,29,011,63,321
,59,521,411,79,401,99,29,011,43,23,53,74
,74,01,59,59,96,87,86,59,59,01,59,59
,96,87,86,59,59,23,101,011,501,201,101,001
,53,01,521,95,14,43,321,23,16,23,39,19
,99,011,29,411,79,401,99,011,29,011,29,43
,04,211,01,521,95,14,93,011,29,93,04,23
,411,79,401,99,611,711,211,14,23,94,23,16
,16,23,05,94,73,89,23,04,23,201,501,01
,95,14,001,04,211,95,14,39,94,54,89,19
,99,44,43,44,001,73,43,44,14,001,04,201
,111,101,221,501,511,44,001,04,23,201,611,011
,501,411,211,011,511,321,14,89,54,54,95,89
,95,14,99,04,201,111,101,221,501,511,16,89
,04,23,411,111,201,01,95,14,99,04,211,95
,39,75,19,001,23,411,79,401,99,95,89,23
,611,011,501,321,14,04,011,501,79,901,23,001
,501,111,811,01,521,521,95,14,39,94,54,89
,19,99,04,411,79,401,99,611,711,211,23,14
,39,94,54,89,19,99,04,201,501,321,14,89
,54,54,95,89,95,14,99,04,011,101,801,411
,611,511,16,89,04,411,111,201,95,89,23,611
,011,501,321,14,99,24,411,79,401,99,04,211
,23,001,501,111,811,01,26,401,64,301,011,501
,411,611,511,06,23,101,001,711,801,99,011,501
,53,01,26,401,64,111,501,001,611,511,06,23
,101,001,711,801,99,011,501,53,01,95,521,01
{ = ][c
rahc

Edit:
Brief explanation: from perl the two interesting lines are the second and the third. The second line has two statements the first of which reads the rest of the document into a string. The second evals the string. The Third line prints everything backwards. every thing else gets ignored. from the c side you have an array which has the program as a string, which gets printed as an array and a string, and the rest is a comment.

wat. :O My head exploded. But I count 6536 characters in that...

What...how... 0_0

@DoorknobofSnow I counted the wrong version. But here is a shorter version.

This is incredible! I think Haskell/C might be another feasible combination.

@theonlygusti, if you post it and I can compile it, I will upvote it.

Ruby 145

DATA.read.tap{|a|puts a.reverse,a.tr("\x79\x59","\x59\x79")}
:y
__END__
__DNE__
Y:
})"97x\95x\","95x\97x\"(rt.a,esrever.a stup|a|{pat.daer.ATAD

The main idea is simple: just put the first half of the source code backwards after the __END__ which can be read using DATA from ruby. Then just print the reverse of this data, then print the data, and you get back the original source code
The problem is, that this becomes a palindrome (note that the first line needs an endline), so we have to break the symmetry. I just added a symbol :y to the code, and some code that will transform this symbol between lowercase and uppercase between runs, thereby reverting to the original state after two runs.
Test one: they can be executed
$ ruby rq2.rb > rq2t.rb
$ ruby rq2t.rb > rq2tt.rb

Test two: the result of two runs will return the original source
$ diff rq2.rb rq2tt.rb
$

Test three: the code is not a palindrome (the middle run is different)
$ diff rq2.rb rq2t.rb
3c3
< :y
---
> :Y
6c6
< Y:
---
> y:

Gol><>, 11 bytes
":5-}H}+5:'

A whole byte chopped off! it almost is a palindrome, but technically isn't because of the '+' and '-', haha!
Try it online!
The two below don't work, or at least they don't meet the specifications of the challenge, but the code above does.
slightly younger version, 12 bytes
"r2ssrH}+5:'

Golfed off a byte, simply by using the double quote and incrementing it by 5! And this new version looks less like a palindrome.
Try it online!
older version, 13 bytes
"r2ssrHrss7r'

There was a problem with the previous that JoKing pointed out, thank you for that, now it works, but with the price of 4 extra bytes...
Try it online!

Python 3.8 (pre-release), 99 bytes
forward :
a=1;exec(s:=#)]a::[
"print(('a=1;exec(s:=#)]a::[\\n%r\\n)#=:s(cexe;1-=a'%s)[::-a])"
)#=:s(cexe;1-=a

Try it online!
backward:
a=-1;exec(s:=#)
")]a-::[)s%'a=-1;exec(s:=#)n\\r%n\\[::a])#=:s(cexe;1=a'((tnirp"
[::a])#=:s(cexe;1=a

Try it online!
How it works:
I based my solution on the quine exec(s:="print('exec(s:=%r)'%s)")

In the forward solution, a=1 transforms the slices to have something like :

exec(s:="print('<string for the quine>'[::-1])")

which prints the backward quine

in the backward solution, a=-1 transforms the slice to have something like :

exec(s:=")]1::['<string for the quine in backward>'(tnirp"[::-1])

which (due to the [::-1]) gives:
exec(s:="print('<string for the quine>'[::1])")

and prints the original quine

><>, 21 19 bytes
'rd3*70.r l?!;o90.<

Try it here!
Uses the *><> interpreter for convenience, but this is valid ><> code.

If erroring out is allowed, then it can be done in 16 bytes:
'd3*}70.!r  !|o|

Try it here!

"Try it" links are dead.

@pppery thanks, fixed.

Help, WarDoq! (27 bytes)
25 bytes added because of reading source code.
<space>q

How it works:
<space> - a comment that ends on non-space character
q - print source code reversed (q"space")
Reversed:
q<space>

How it works:
q - print source code reversed (q for now)
<space> - a comment that ends on non-space character, and add a character to beginning of q command (making "space"q)

JavaScript (V8), 817 bytes
I'm sure this can be golfed further. I might also try to translate this into Python.
//))""(nioj.)(esrever.])q+s+q(nioj.))53(edoCrahCmorf.gnirtS(tilps.)c,)63(edoCrahCmorf.gnirtS(ecalper.)q+c+q,)33(edoCrahCmorf.gnirtS(ecalper.))""(nioj.)(esrever.]c...[,)621(edoCrahCmorf.gnirtS(ecalper.s...[(gol.elosnoc
c=//
`console.log([...s.replace(String.fromCharCode(126),[...c].reverse().join("")).replace(String.fromCharCode(33),q+c+q).replace(String.fromCharCode(36),c).split(String.fromCharCode(35)).join(q+s+q)].reverse().join(""))//`
//=c
s=//
`~
c=//
!
//=c
s=//
#
//=s
q=String.fromCharCode(96)//
//)69(edoCrahCmorf.gnirtS=q
$`
//=s
q=String.fromCharCode(96)//
//)69(edoCrahCmorf.gnirtS=q
console.log([...s.replace(String.fromCharCode(126),[...c].reverse().join("")).replace(String.fromCharCode(33),q+c+q).replace(String.fromCharCode(36),c).split(String.fromCharCode(35)).join(q+s+q)].reverse().join(""))//

Try it online!
How?
Line comments at the end of the line comment out that line in the reversed version.
Although the entire program is not a palindrome, it is made up of several palindromic or semi-palindromic sections. These are not true palindromes, but are close enough.
// This line is the last line reversed
//))""(nioj.)(esrever.])q+s+q(nioj.))53(edoCrahCmorf.gnirtS(tilps.)c,)63(edoCrahCmorf.gnirtS(ecalper.)q+c+q,)33(edoCrahCmorf.gnirtS(ecalper.))""(nioj.)(esrever.]c...[,)621(edoCrahCmorf.gnirtS(ecalper.s...[(gol.elosnoc

// This is a palindrome (apart from the string in the middle)
c=//
`console.log([...s.replace(String.fromCharCode(126),[...c].reverse().join("")).replace(String.fromCharCode(33),q+c+q).replace(String.fromCharCode(36),c).split(String.fromCharCode(35)).join(q+s+q)].reverse().join(""))//`
//=c

// This is a palindrome (apart from the string in the middle)
s=//
`~
c=//
!
//=c
s=//
#
//=s
q=String.fromCharCode(96)//
//)69(edoCrahCmorf.gnirtS=q
$`
//=s

// This is also a palindrome
q=String.fromCharCode(96)//
//)69(edoCrahCmorf.gnirtS=q

// This line is the first line reversed
console.log([...s.replace(String.fromCharCode(126),[...c].reverse().join("")).replace(String.fromCharCode(33),q+c+q).replace(String.fromCharCode(36),c).split(String.fromCharCode(35)).join(q+s+q)].reverse().join(""))//

Apart from this, it's a pretty standard quine. Writing the code twice, once in code and once in a string, and substituting the string into itself is a common quine technique.

Julia, 194 177 bytes
~=reverse;(s= #lave>|esrap.ateM>|))
"print(~\"~=reverse;(s= #lave>|esrap.ateM>|))\\n\$(~repr(~s))\\n)|>Meta.parse|>eval#(esrever=s(;* =~\")"
)|>Meta.parse|>eval#(esrever=s(;* =~

Attempt This Online!
port of Jakque's answer, Julia is not very good at quines
previous answer, 194 bytes: (q=:(print(replace((k = "(q=:($(q)))|>eval#") |> (*), 'q' => :Q, 'Q' => :q), reverse(k))))|>eval##lave>|))))k(esrever ,)Q: >= 'q' ,q: >= 'Q' ,)*( >| )"#lave>|)))Q($(:=Q(" = k((ecalper(tnirp(:=Q(
based on this quine, by appending the reversed program in a comment, and switching between lowercase and uppercase Q so it's not a palindrome

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Write a program to compose a quine of a specified length
Write a program, in a language of your choice, that will compose a quine program of a requested size. The generated program may be in the same or a different language, if desired.
Programs are scored based on the following formula:

generating_program_length + smallest_supported_size + 512 * number_of_supported_sizes ^ (-3/4)

Halve your score if you support every size between the minimum and maximum supported sizes.
Lowest score wins.

Also, to explain the rather complicated scoring criteria, the point is to ensure trivial "any color as long as it's black" solutions don't work, and to encourage solutions that tend toward supporting all the numbers possible, without penalizing more limited solutions too harshly.

so wait... more possible supported sizes is penalized?!

@DoorknobofSnow Sorry, fixed it.

Perhaps a little late, but I think there should be a significant bonus here for programs that produce the quines in their own language. Otherwise, everyone's going to be writing quine generators for HQ9+ or languages where quining is similarly simple.

@Iszi I think you're right, also I have another possible change that could eliminate trivial quining solutions: output must not contain any matches of the regex (.+)\1.

GolfScript → GolfScript: (4 + 0 + 0) / 2 = 2
~1`*

Program length: 4
Minimum supported size: 0
Maximum supported size: unbounded
All sizes supported: yes

This program simply reads an integer n from its input, and outputs an n-digit integer consisting of n 1 digits.  For example, the input 5 yields the output 11111.  In GolfScript, any integer literal (without leading zeros) is a quine, and since GolfScript integers can be arbitrarily large, the maximum supported length is only bounded by the amount of memory available.
For the input 0, the code outputs an empty program, which is also a quine in GolfScript.
Ps. The generated quines work for several other languages too, including PHP.

Damn Golfscript and its arbitrary precision. I was going to do the same in PowerShell, but it falls back to scientific notation after a point. Does PHP support arbitrary precision by default also?

@Iszi: No, but PHP will echo back verbatim anything outside <? ?> tags.

Ah. For PowerShell you'd have to force the integer to a string with quotes if it's too big, at which point that alone is no longer a quine.

Beat me to it in APL, and smaller

The first character ~ is not even necessary. For me, 1\*` works perfectly.

@ProgramFOX: I assumed the input was to be provided on stdin, in which case the ~ is needed to turn it from a string into a number. You're right that, if the desired length is provided as a number on the stack, three characters is enough.

@IlmariKaronen: I understand. When I tested it, I had to push the input as a number on the stack (I didn't see a way to provide the input using STDIN, I tried the way as said in the GolfScript tutorial, but it doesn't seem to work on my Windows computer).

@ProgramFOX: An easy way to test GolfScript code using "canned" input is to insert ;'input goes here' at the beginning of the program.

Ruby -> JavaScript, 38
45 character program
31 smallest supported size
Infinity possible sizes
Supports any size in range
(45 + 31 + 512 * Infinity ^ -3/4) / 2 = 38
"function f(){alert(f+'f()')#{?;*(i-31)}}f()"

GolfScript -> JavaScript, 37.5
1 char less :P
"function f(){alert(f+'f()')"";"i 31-*"}f()"

Example output for i = 31:
function f(){alert(f+'f()')}f()

For i = 41:
function f(){alert(f+'f()');;;;;;;;;;}f()

The output quines work on latest Chrome (31.0.1650.63), at least. (Untested for any other browser)

Sorry, fixed it, I meant the exponent to be negative.

@AJMansfield  Yay, now I have a score of negative infinity :P Impossible to beat!

No. 512 * x^(-3/4) tends toward 0 as x increases without bound.

@AJMansfield Whoops, I fail at math. Fixed

No, still wrong, the score is 71.

@AJMansfield Gah! Sorry, really not thinking straight at all :P

+1 Solving the problem with "real" programming languages instead of taking advantage of esoteric languages. I'm impressed!

@Kevin I don't really take advantage of esoteric languages. I use them. For instance, it is rather fun (ie difficult) to solve project euler problems using Befunge.

@Quincunx I was comparing your answer to the others that output quines in H9Q+, which has a quine operator, making the problem trivial. I don't doubt that languages like Befunge are challenging to use!

Ruby or GolfScript -> HQ9+, 6
11 character program
1 smallest supported size
Infinity possible sizes
Supports any size in range
(11 + 1 + 512 * Infinity ^ -3/4) / 2 = 6
?Q+?+*(i-1)

Same size program written in GolfScript:
"Q""+"i 1-*

Example output for i = 1:
Q

For i = 10:
Q+++++++++

Befunge 98 - (14 + 0 + 0) / 2 = 7
'1&k:$$>,:# _@

Output is in HQ9+ Golfscript (Thanks to Ilmari)
Output for 0:

Output for 1:
1

Output for 10:
1111111111

Explanation:
'1             ;push the character `'1'` onto the stack
  &            ;get the inputted number (`n`), push on stack
'1&k:          ;duplicate the `'1'`, `n + 1` times, leaving `n + 2` of `'1'` on the stack
'1&k:$$        ;drop the top two `'1'`s on the stack
       >,      ;print the top element of the stack
       >,:# _  ;duplicate the next, then check if it is `0`.
             @ ;if it is `0`, execute this, which ends the program.
        , # _  ;otherwise, go back the other way and continue printing
       >       ;turn back to the right.
'1&k:$$>,:# _@

Python 2 - 62.6 points
s='s=%r;print(s%%s+s*99)[:input()]#';print(s%s+s*99)[:input()]

This code is both the generator and the core of the quine. It expects you to provide a length on standard input, and prints to standard output a version of itself of that length (larger sizes get a trailing comment full of junk).
So, if you pass it 62, it prints itself (this is the minimum size). If you call it with some longer length (up to the maximum length of 3231), it will produce output of that length. Any version will be a quine if passed its own length.
The length limit was the result of my attempts at minimizing the number of characters used. Supporting more lengths was costing more in points for code length than it was reducing the penalty for a limited range. It's not hard to make a variant that will work for unlimited sizes, but it will need to be longer by about 20 characters (and so score worse).
Note that requesting a shorter length than 62 will produce output of the desired size, but that output will not be working code. Passing a larger length than 3231 will produce the 3231-character version of the quine. Passing something other than an integer will raise an exception.
Scoring:

Generator length: 62 characters, 62 points
Minimum quine size: 62 characters, 62 points
Number of supported sizes: 3169, 1.2 points
All sizes between minimum and maximum accepted: Half off all points above.
Total: (62+62+1.212)/2 = 62.6 points

Deserves +10 for not trying to dodge the rules by using dummy languages.

Ruby -> Ruby (79 points)
char: 51
min size: 28
max size: infinite
(0..num){|x|print "eval s=\"print 'eval s=';p s\""}

Golf-Basic 84 -> Golf-Basic 84
(54 + 0 + 0) / 2 = 27

Program length: 54
Minimum supported size: 0
Maximum supported size: none
All sizes supported: yes

Only limited by the calculator's RAM.
i`A:""_Str1:"1"_Str2l`1:A--A:Str1+Str2_Str1@Ag`1d`Str1


text:
Christmas quine!
In the language of your choice, write a program that is arranged in the shape of a Christmas tree that prints itself in the same shape.
What is not allowed:

Printing out the source file
Code that is nothing but statements that get echoed by an interpreter by virtue of them being literals (eg just using a tree-shaped tower of lists in python)

"Printing out the source file" is not allowed, but is reading source code (not from file) and printing it allowed? If it is not, then this is practically impossible with Befunge. :/

JavaScript
The 'star' might be a bit too large for the tree...
        (function _()
     {return('        (')
      +(''+''+''+''+'')
             +_+
            ')()'
           ;'We w'
          +'wis'+0+
         'h you a '
        +0+'merry Ch'
       +'ristmas, '+0+
      +'we '+0+'wish y'
     +0+'ou a merry Chr'
    +'istmas, we w'+0+'i'
   +0+'sh you '+0+'a merr'
  +'y Christmas and a h'+0+
 +'appy'+0+'new year! Ho ho'
+0+' ho! Merry '+0+'Christma'
            +'s!'
            })()

The zeroes are baubles and look best in the editor:

Nice trick with the baubles!

I love the inclusion of "We wish you a merry Christmas!"

Ruby
You never said we couldn't use network access... :D
        #
       s="
      open(
     'http:/
    /pastebin
   .com/raw.ph
  p?i=mGzbahp5'
 ).read";s=eval(
s.gsub! /\s/,'');
      puts(
      s+'')

Outputs itself verbatim.
Yes, I could have used a URL shortener, but that would have made it less obvious and amusing :P Also I needed something to take up space; otherwise the tree would be tiny.
Execute like this:
ruby -ropen-uri christmasquine.rb

In my mind you cheated, but you're right about the rules. Outsmarted by a doorknob. Anyway, here's your upvote, for making me smile :)

@Manishearth Yep, we bend the rules a lot here! Part of the fun. :P (Ex. 0 character quines, etc)

@Manishearth Yeah, what Doorknob said. If you don't want a rule bent, you need to include a rule against bending that rule. Hence why the latest "reverse quine" and "mirror quine" challenges had rules against palindromes and quines shorter than 2 characters.

"You never said we couldn't use network access" No, but loopholes that are forbidden by default did.

perl
#!/usr/bin/perl
$_=<<'the source';eval $_;

          #
         #*#
        print
       "#!/u".
      "sr/bin".
     "/perl \n".
    "\$_=<<'the".
   " source';eva".
  "l \$_;\n${_}th".
 "e source\n";# Mery
#Christmas to all !!!
         ###
         ###
         #*#

the source

Here's a tiny one in GolfScript:
   {
  ".~
 "2/~\
+@@2$*}.
   ~

Note that the code above includes two space characters at the end of the second line from the top; those spaces are essential for correct operation.  Also, the code should be saved using Unix-style (LF) linefeeds, not Windows-style CR+LF.

Here's a slightly bigger (and less whitespace-sensitive) one, including a festive message:
     {
    " "
   MERRY
  5*n\+\n
 CHRISTMAS
".~"+2$*1>}
     .
     ~

A mildly interesting feature is that the words MERRY and CHRISTMAS are not string literals, although they are no-ops, and are copied to the output along with the code block surrounding them.


text:
Four score and twenty. (Complete Obfuscation)
This challenge is to write a program that prints a great famous speech.
Goals:

Obfuscated text (you should not be able to tell what speech it prints without running it)
Obfuscated code (it is more fun if you cant figure out how it works)
non-wrapping text and code is preferred. (78 chars/line)
Low score wins.

Rules:

When picking a speech it must be famous: it must have at least three published references (newspaper, history book, or similar) websites only count 1/3 unless associated with a dead tree publication. (if only using websites you need 9)
When picking a speech it must be great: it must not be too short (5 sentence minimum) or too long (It should be able to be read in less than 15 minutes) and have real meaning (you must assert that you have a strong opinion about the speech)
No input (files, web, etc.)

Scoring:

Punctuation and white space has no score.
Words found in the speech count 20 points.
Words not found in the speech count one point.
choice of language:

golf languages where the longest command is 1 letter cost 15 points.
languages that print to output by default cost 3 points.
interpreted languages cost 1 point.
java and languages where a typical method call is longer than 20 chars get a -5 point bonus.

three free lines of boilerplate (warnings, standard i/o, #!) boilerplate must be generic.

This looks like it should probably go through the Sandbox for hammering out bugs/ambiguities in the rules/scoring first.

@Iszi did you have any specific recommendations to make or did this just look too complicated? before posting this I read the rules proposed in atomic scoring(meta) and looked at a couple questions with great ideas that had failed because the scoring was not well thought out. your advice is appreciated.

I'm not 100% sure the scoring rules are appropriately adjusted, but will let others weigh in. Other than that, leaving the speech choice up to the contestants is horrifically ambiguous even if you have set some sort of objective quality standards. Also, obfuscation of code in general is subjective.

“non-wrapping text and code is preferred. (78 chars/line)” What does that mean? Enforce it or don’t.

@minitech the Goals are subjective, intentionally, to provide guidance of intent, but as they cannot be scored are not scored. They will only earn you smart remarks. The rules are enforced, the scoring tells you how you did.

@Iszi My intent was to solicit maximum creativity, by allowing flexibility, but still having a specific non disputable way to win.

Careful how you do that - that's usually how loopholes are made.

"This is one. This is two. This is three. This is four. This is five" Can I post this on 9 block sites and use it?

@Cruncher what is your strong opinion about that speech?

@hildred That's not a requirement. I simply have to assert that I do have a strong opinion about it.

@Cruncher Those Five sentences do not appear to have real meaning, and if you assert that you have a strong opinion about them I will make fun of you, because I would be unable to reach any conclusion other than that you have abnormal mental development.

@Cruncher is pointing out exactly what I'm talking about, and jazzpi's answer also calls out further ambiguity in the rules. (Personally I would feel that language keywords should not count against "words found in the speech".) Also, what counts as a "word" - whether in the speech or not? Do gibberish character combinations qualify?

whitespace has no score? Ok, write it in whitespace.

Some suggestions: 1. submitters should reveal the output (until the submission period, say, 3 weeks, has ended); others should post comments in which they attempt to identify the speech (BEFORE RUNNING THE CODE). 2. Score is the number of incorrect ids MINUS correct ids. 3. Obfuscation and subterfuges of any sort are encouraged. 4. To be an eligible submitter, one must post guesses that aim to identify the speech of each of the other submissions! 5. Once a guess is posted, it cannot be changed.

Python
import sys, this
sys.stderr.write(''.join(map(lambda i: this.d.get(i, i),
'V nz cebhq gb pbzr gb guvf pvgl nf gur thrfg bs lbhe qvfgvathvfurq Znlbe, jub '
'unf flzobyvmrq guebhtubhg gur jbeyq gur svtugvat fcvevg bs Jrfg Oreyva. Naq V '
'nz cebhq gb ivfvg gur Srqreny Erchoyvp jvgu lbhe qvfgvathvfurq Punapryybe jub '
'sbe fb znal lrnef unf pbzzvggrq Treznal gb qrzbpenpl naq serrqbz naq '
'cebterff, naq gb pbzr urer va gur pbzcnal bs zl sryybj Nzrevpna, Trareny '
'Pynl, jub unf orra va guvf pvgl qhevat vgf terng zbzragf bs pevfvf naq jvyy '
'pbzr ntnva vs rire arrqrq. \n\nGjb gubhfnaq lrnef ntb gur cebhqrfg obnfg jnf '
'"pvivf Ebznahf fhz." Gbqnl, va gur jbeyq bs serrqbz, gur cebhqrfg obnfg vf '
'"Vpu ova rva Oreyvare." \n\nV nccerpvngr zl vagrecergre genafyngvat zl '
'Trezna! \n\nGurer ner znal crbcyr va gur jbeyq jub ernyyl qba\'g haqrefgnaq, '
'be fnl gurl qba\'g, jung vf gur terng vffhr orgjrra gur serr jbeyq naq gur '
'Pbzzhavfg jbeyq. Yrg gurz pbzr gb Oreyva. Gurer ner fbzr jub fnl gung '
'pbzzhavfz vf gur jnir bs gur shgher. Yrg gurz pbzr gb Oreyva. Naq gurer ner '
'fbzr jub fnl va Rhebcr naq ryfrjurer jr pna jbex jvgu gur Pbzzhavfgf. Yrg '
'gurz pbzr gb Oreyva. Naq gurer ner rira n srj jub fnl gung vg vf gehr gung '
'pbzzhavfz vf na rivy flfgrz, ohg vg crezvgf hf gb znxr rpbabzvp cebterff. '
'Ynff\' fvp anpu Oreyva xbzzra. Yrg gurz pbzr gb Oreyva. \n\nSerrqbz unf znal '
'qvssvphygvrf naq qrzbpenpl vf abg cresrpg, ohg jr unir arire unq gb chg n '
'jnyy hc gb xrrc bhe crbcyr va, gb cerirag gurz sebz yrnivat hf. V jnag gb '
'fnl, ba orunys bs zl pbhagelzra, jub yvir znal zvyrf njnl ba gur bgure fvqr '
'bs gur Ngynagvp, jub ner sne qvfgnag sebz lbh, gung gurl gnxr gur terngrfg '
'cevqr gung gurl unir orra noyr gb funer jvgu lbh, rira sebz n qvfgnapr, gur '
'fgbel bs gur ynfg 18 lrnef. V xabj bs ab gbja, ab pvgl, gung unf orra '
'orfvrtrq sbe 18 lrnef gung fgvyy yvirf jvgu gur ivgnyvgl naq gur sbepr, naq '
'gur ubcr naq gur qrgrezvangvba bs gur pvgl bs Jrfg Oreyva. Juvyr gur jnyy vf '
'gur zbfg boivbhf naq ivivq qrzbafgengvba bs gur snvyherf bs. gur Pbzzhavfg '
'flfgrz, sbe nyy gur jbeyq gb frr, jr gnxr ab fngvfsnpgvba va vg, sbe vg vf, '
'nf lbhe Znlbe unf fnvq, na bssrafr abg bayl ntnvafg uvfgbel ohg na bssrafr '
'ntnvafg uhznavgl, frcnengvat snzvyvrf, qvivqvat uhfonaqf naq jvirf naq '
'oebguref naq fvfgref, naq qvivqvat n crbcyr jub jvfu gb or wbvarq gbtrgure. '
'\n\nJung vf gehr bs guvf pvgl vf gehr bs Treznal\xe2\x80\x94erny, ynfgvat '
'crnpr va Rhebcr pna arire or nffherq nf ybat nf bar Trezna bhg bs sbhe vf '
'qravrq gur ryrzragnel evtug bs serr zra, naq gung vf gb znxr n serr pubvpr. '
'Va 18 lrnef bs crnpr naq tbbq snvgu, guvf trarengvba bs Treznaf unf rnearq '
'gur evtug gb or serr, vapyhqvat gur evtug gb havgr gurve snzvyvrf naq gurve '
'angvba va ynfgvat crnpr, jvgu tbbq jvyy gb nyy crbcyr. Lbh yvir va n qrsraqrq '
'vfynaq bs serrqbz, ohg lbhe yvsr vf cneg bs gur znva. Fb yrg zr nfx lbh, nf V '
'pybfr, gb yvsg lbhe rlrf orlbaq gur qnatref bs gbqnl, gb gur ubcrf bs '
'gbzbeebj, orlbaq gur serrqbz zreryl bs guvf pvgl bs Oreyva, be lbhe pbhagel '
'bs Treznal, gb gur nqinapr bs serrqbz rireljurer, orlbaq gur jnyy gb gur qnl '
'bs crnpr jvgu whfgvpr, orlbaq lbhefryirf naq bhefryirf gb nyy znaxvaq. '
'\n\nSerrqbz vf vaqvivfvoyr, naq jura bar zna vf rafynirq, nyy ner abg serr. '
'Jura nyy ner serr, gura jr pna ybbx sbejneq gb gung qnl jura guvf pvgl jvyy '
'or wbvarq nf bar naq guvf pbhagel naq guvf terng Pbagvarag bs Rhebcr va n '
'crnprshy naq ubcrshy tybor. Jura gung qnl svanyyl pbzrf, nf vg jvyy, gur '
'crbcyr bs Jrfg Oreyva pna gnxr fbore fngvfsnpgvba va gur snpg gung gurl jrer '
'va gur sebag yvarf sbe nyzbfg gjb qrpnqrf. \n\nNyy serr zra, jurerire gurl '
'znl yvir, ner pvgvmraf bs Oreyva, naq, gurersber, nf n serr zna, V gnxr cevqr '
'va gur jbeqf "Vpu ova rva Oreyvare!"')))

This should be run with
$ python codegolf.py > /dev/null

I guess the text is pretty obfuscated, and the code as well, if you didn't take a closer look into the this module. Instead of 78 chars, I stuck to 80.
Score:
Language choice:
Interpreted language: 1
Code words:
The words found in the speech are this (1x), for (1x) but I guess they don't really count since they are language keywords (?).
If they count, this is 29.
Otherwise, it's 11.
Encoded speech words:
I guess I have a disadvantage here due to picking a long speech. But it has a total of 673 words, none of them in the speech.
Total score:
Best case (Not counting language keywords and encoded speech words):
1 + 11 = 12
Worst case (Counting language keywords and encoded speech words):
1 + 29 + 673 = 703
Note: Speech is used from here.

language keywords used in the speech count as words used in the speech. your worst case is the correct score. Great job to kick things off with. Let's see if you keep the checkmark.