text:
Meta Length Logarithms
Good Evening Golfers,
Your challenge, this evening, is logarithmic, and (as Abed would put it) "Meta"
Your goal is to write a program that takes an input from stdin or the command line, and returns the logarithm of that number, in the base of the length of your program in bytes.
So, if your program is 10 bytes, it must return the Log10 of the input number.
Rules:

Program must be longer then 1 character
Program must be able to accept floating point input in a form of your choice, or scientific format in a form of your choice with a minimum accuracy of 6 digits
Program must output to a minimum of 6 digits of accuracy in decimal or scientific format
Program must be entirely self contained, and must not access any files or network resources.

Your score in the natural logarithm of the amount of bytes in your source code.
Good luck.

APL 1.0986122886681098
3⍟⎕

⎕ Requests numerical screen input. Examples of use:
      3⍟⎕
      10
2.0959032742893844

      3⍟⎕
      1E1
2.0959032742893844

      3⍟⎕
      ○1
1.041978045992186

In the last example ○1 represents pi.

I count 7 bytes in your program so the score should be 1.9459101490553132.

@Bakuriu. I am sorry if you are counting unicode bytes. I have explained this situation so many times now. APL+WIN uses a single byte character set but the only way I can get the characters to render properly on this site I have to convert the characters to UTF-8. The byte count for my solution is a genuine 3!

Then you should declare the encoding you use to let other people check. Probably the OP should have decided a canonical encoding to avoid ambiguous results, and if I were him I'd definitely choose utf-8.

Mathematica: 2.079.. (length in bytes = 8)
8~Log~#&

Usage
8~Log~# &@8
(*
 1
*)

bc (with -l) - log(15) = 2.70805
l(read())/l(15)

Q (log(16) = 2.772589)
16 xlog"F"$(0:)0

Example
q)16 xlog"F"$(0:)0
16
1f

q)16 xlog"F"$(0:)0
1.6e1
1f

q)16 xlog"F"$(0:)0
13.912231123
0.9495705

Ruby: 2.995732273553991 (Math.log 20)
p Math.log$_.to_f,20

Sample run:
bash-4.2$ ruby -ne 'p Math.log$_.to_f,20' <<< 3.14
0.3819509540359265

J, 2.4849066497880003102297094798389 (12 chars)
12^.".1!:1[1

Usage:
   12^.".1!:1[1
12
1

Perl: 2.77258872223978 (log 16)
say log()/log 16

Sample run:
bash-4.2$ perl -nE 'say log()/log 16' <<< 3.14
0.412691139779226

$_=log()/log 15 with option -pe instead of -nE.

Tcl, 3.4011973816621555 (log 30)
puts [expr log($argv)/log(30)]

MATL, ln(2) = 0.6931471805
Zl

Try it online!

05AB1E, score: 0.693147... (2 bytes)
.²

05AB1E has a 2-byte \$\log_2{n}\$ builtin. ¯\_(ツ)_/¯
Try it online or verify the inputs in the range [0,3] in increments of 0.1.
Otherwise it would have been 3 bytes instead:
3.n

Try it online or verify the inputs in the range [0,3] in increments of 0.1.
Explanation:
.²  # Get the logarithm in base 2 of the (implicit) input
    # (after which the result is output implicitly)

3   # Push 3
 .n # Pop and get the logarithm in base 3 of the (implicit) input
    # (after which the result is output implicitly)

Python (log 38) score: 3.6375861597263857 <- how embarrassing
>>> import math;print math.log(input(),38)
38**8
8.0

Lua 3.5835189384561 (36 38 42 chars)
L=math.log;print(L(io.read())/L(36))

Sample run:
C:...>echo 42 | lua -e "L=math.log;print(L(io.read'*n')/L(36))"
1.0430165662508
C:...>echo 38 | lua -e "L=math.log;print(L(io.read'*n')/L(36))"
1.0150877453695
C:...>echo 36 | lua -e "L=math.log;print(L(io.read'*n')/L(36))"
1
C:...>

Do you really need to force the input into a number? For numeric input works anyway and for non-numeric input crashes anyway. (Beside that, handling input error was not required in the question.) You can spare 2 characters by using () instead of '*n': http://pastebin.com/461tUsse

Hmm, apparently the '*n' isn't needed. Lua generally avoids automatic type coercions, but there are a few cases where strings do get converted to numbers. The team keeps threatening to remove them and a lot of Lua users just assume type coercions don't happen as a safety measure. So, this brings us down to 36 chars, as soon as I make the edit.

Scala - ln(46) = 3.82864...
print(math.log(args(0).toDouble)/math.log(46))
scala log.scala 12.34 -> 0.6563283834264416

Smalltalk (Pharo 2.0) (41 ln) 3.713572066704308
Pharo -headless Pharo-2.0.image eval "FileStream stdin nextLine asNumber log:41"

No syntactic sugar is Smalltalk's pride, just regular sentence ;)

CJam - ln(5) = 1.60943791243
rd5mL

JavaScript 69 bytes, score=4.23410650459726
function f(n){return Math.log(n)/Math.log(69);}

I counted bytes following this discussion:
https://stackoverflow.com/questions/2219526/how-many-bytes-in-a-javascript-string
function byteCount(s) {
        return encodeURI(s).split(/%..|./).length - 1;
    }

The number of characters is only 37.
Any advice on counting bytes in code golf?

If you put your source code in a file, the file size will be the number of bytes

Pyth, 1.38629436112
.lQ4

Try it online!

Pyt, score \$\ln(2)=0.693147...\$
ļƥ

Try it online!
ļ       implicit input; log base 2
 ƥ      prints the top of the stack

source: Stack Exchange

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

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

sort: votes


text:
Write the shortest self-identifying program (a quine variant)
Write a program that will generate a "true" output iff the input matches the source code of the program, and which generates a "false" output iff the input does not match the source code of the program.
This problem can be described as being related to quines, as the program must be able to somehow compute its own source code in the process.
This is code golf: standard rules apply.  Your program must not access any special files, such as the file of its own source code.
Edit: If you so choose, true/false can be replaced with True/False or 1/0.
Example
If the source code of your program is bhiofvewoibh46948732));:/)4, then here is what your program must do:
Input (Stdin)
bhiofvewoibh46948732));:/)4

Output (Stdout)
true

Input
(Anything other than your source code)

Output
false

Is the true/false output a strong requirement, or are variations (True/False, 1/0) acceptable as well?

Is it a problem if the program outputs a little more than true/false (if it keeps being unambiguous and ends with true/false) ?

Related: Interpret your lang, but not yourself?

So you mean a Narcissist program?

Very much related

JavaScript : 26
function f(s){return s==f}

I don't know if a JavaScript file really qualifies as a "program".

+1 This works because all objects have a .toString() method in JavaScript.

This can be shortened using an arrow function f=s=>s=='f='+f

@Jonathan yes. But in 2013 it couldn't...

Haskell, 72 characters
main=interact$show.(==s++show s);s="main=interact$show.(==s++show s);s="

Note: there is no end-of-line character at the end of the script.
$ runhaskell Self.hs < Self.hs
True

Perl, Infinity 41 38 Characters
$_=q(print<>eq"\$_=q($_);eval"|0);eval

Update: The program no longer ends with a newline, which means it will work correctly on multi-line files.  You have to enter input from STDIN without hitting enter. On Windows I was only able to do this by reading from a file.
Original solution:
print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(...

Nicely done! . . .

Fails for a file that begins with the code, e.g. (cat id.pl; echo foo)|perl id.pl

@GeoffReedy, thanks; the program did not handle multi-line input before.  It is corrected now.

Darn, is this code bowling?

GolfScript, 11 chars
{`".~"+=}.~

Without the =, this code would be a quine that generates its own source code as a string.  The = makes it compare this string to its input and output 1 if they match and 0 if they don't.
Note that the comparison is exact — in particular, a trailing newline at the end of the input will cause it to fail.
Explanation:

{ } is a code block literal in GolfScript;
. duplicates this code block, and ~ executes the second copy (leaving the first on the stack);
` stringifies the code block, and ".~"+ appends .~ to it;
finally, = compares the resulting string with the input (which is pushed on the stack as a string by the GolfScript interpreter before the program starts) and returns 1 if they match and 0 if they don't.

><>, 68 bytes
Fishes love eating fish poop. Now we know they can distinguish theirs from their friends'.
00v      0+1~$^?)0~\;n0\
  >:@@:@gi:0(?\:a=?/=?!/$1+
  0n;n*=f$=2~~/

You can try it online !

This outputs 1 for any prefix of the code as well

@JoKing it was worst than just prefixes of the script, it accepted truncated lines too ! I've fixed it, but I'm disappointed it's not as generic as I wanted it to be, I had to check the reached cell at the end of the script to make sure the whole code was matched. It can certainly be improved, but I'm not sure I will bother.

Python 2, 55
a='a=%r;print a%%a==raw_input()';print a%a==raw_input()

Tested:
a='a=%r;print a%%a==raw_input()';print a%a==raw_input() -> True
(anything else) -> False

Fails on any file that begins with the first line equal to a='a=%r;print a%%a==raw_input()';print a%a==raw_input().

True, multi-line input is not supported.

A trivial fix would be to replace raw_input() with __import__('sys').stdin.read().

I am confused by the challenge wording ('cause I am not good with english grammar). Is this allowed? print raw_input()==open(__file__).read() ? It is only 40 bytes, uses your raw_input() approach, but reads it's code.

@Simon That is not allowed, it is one of the standard loopholes for challenges like this.  And yes, this is what it means by Your program must not access any special files, such as the file of its own source code.

JavaScript ES6, 16 14 bytes
$=_=>_==`$=`+$

Minus two bytes thanks to Neil.
31 bytes if we must take input via prompt.
$=_=>prompt()==`$=${$};$()`;$()

38 bytes if we must output via alert.
$=_=>alert(prompt()==`$=${$};$()`);$()

This is the proper way to do it, as Optimizer's answer does not accept the entire source code.

Nice, although I would just write '$='+$.

Oh, true. @Neil

I'm pretty sure you need the ending ;$() because the function call is part of the quine. This also means that you'll need to switch to prompt to account for input.

@MamaFunRoll I don't think so. The OP allowed functions in other submissions.

That's not the problem. The function call is necessary because it's a part of the quine. Allowing the user to call it as a function would ruin the quine.

@MamaFunRoll Then how might I incorporate input?

try $=_=>prompt()==\$=${$};$()`;$()`

Node.js : 54
function f(){console.log(f+'f()'==process.argv[2])}f()

You test it by saving it into a file f.js (the exact name has no importance) and using
node f.js "test"

(which outputs false) or
node f.js "$(< f.js)"

(which outputs true)
I also made a different version based on eval :
eval(f="console.log('eval(f='+JSON.stringify(f)+')'==process.argv[2])")

It's now at 72 chars, I'll try to shorten that when I have time.

@dan1111 Why ? It doesn't access any file. I was just pointing how to launch the program to people not used to node.js. It doesn't read the file.

All of the Javascript solutions take advantage of the fact that you can access your own source code in JS.  That may not be technically "accessing the file of its own source code", but it accomplishes the exact same thing.   I suppose your answer is legal, though, as the question didn't specifically forbid this.

Well, you access the source of a function (only the body to be precise) which is part of the program. That's like using mixin() in D. But I don't think the two other JS answers, including one from me, really qualify as "programs", though.

@dystroy actually mixin in D is more like using eval than reading source

@ratchetfreak yes, you're right. But I think your program uses a kind of toString of the enum value, right ? And any code using eval/mixin is about the same trick than using the source of the function.

@dystroy eval/mixin requires more setup before you can access the source (like saving into a var and escaping), reading the source directly doesn't and can work on all programs in a modular fashion

Smalltalk (Pharo 2.0 dialect), 41 bytes
Implement this 41 chars method in String (ugly formatting for code-golf):
isItMe^self=thisContext method sourceCode

Then evaluate this in a Workspace (printIt the traditional Smalltalk way)
The input is not read from stdin, it's just a String to which we send the message (what else a program could be in Smalltalk?):
'isItMe^self=thisContext method sourceCode' isItMe.

But we are cheating, sourceCode reads some source file...
Here is a variant with 51 chars which does not:
isItMe
    ^ self = thisContext method decompileString

And test with:
'isItMe
    ^ self = thisContext method decompileString' isItMe

If a String in a Workspace is not considered a valid input, then let's see how to use some Dialog Box in 116 chars
Just evaluate this sentence:
(UIManager default request: 'type me') = (thisContext method decompileString withSeparatorsCompacted allButFirst: 7)

Since decompile format includes CR and TAB, we change that withSeparatorsCompacted.
Then we skip the first 7 chars are 'doIt ^ '
Finally a 105 chars variant using stdin, just interpret this sentence from command line, just to feel more mainstream:
Pharo -headless Pharo-2.0.image eval "FileStream stdin nextLine = (thisContext method decompileString withSeparatorsCompacted allButFirst: 7)"

flex - 312 chars
Q \"
N \n
S " "
B \\
P "Q{S}{B}{Q}{N}N{S}{B}n{N}S{S}{Q}{S}{Q}{N}B{S}{B}{B}{N}P{S}{Q}{P}{Q}{N}M{S}{Q}{M}{Q}{N}%%{N}{P}{N}{M}{N} putchar('1');"
M "(.|{N})* putchar('0');"
%%
Q{S}{B}{Q}{N}N{S}{B}n{N}S{S}{Q}{S}{Q}{N}B{S}{B}{B}{N}P{S}{Q}{P}{Q}{N}M{S}{Q}{M}{Q}{N}%%{N}{P}{N}{M}{N} putchar('1');
(.|{N})* putchar('0');

Can probably be made shorter, but it works with multi-line input (necessary since the source code is multiple lines) and even for inputs that contain the program as a substring. It seems many of the answers so far fail on one or both of these.
Compile command: flex id.l && gcc -lfl lex.yy.c

D (133 chars)
enum c=q{import std.stdio;import std.algorithm;void main(){auto i=readln();writeln(equal("auto c=q{"~c~"};mixin(c);",i));}};mixin(c);

JavaScript (V8), 35
function i(){alert(prompt()==i+[])}

call i() and it will prompt for input

The +[] should be optional as JS will auto-type-cast it

GolfScript - 26
":@;[34]@+2*=":@;[34]@+2*=

Inspired from http://esolangs.org/wiki/GolfScript#Examples
Another version:
"[34].@@;+2*="[34].@@;+2*=

Too bad that \ is both swap and escape...

Python, 187 bytes
import sys;code="import sys;code=!X!;print(sys.stdin.read()==code.replace(chr(33),chr(34)).replace(!X!,code,1))";print(sys.stdin.read()==code.replace(chr(33),chr(34)).replace("X",code,1))

Careful not to add newline at the end. Someone with better Python-fu might be able to shorten it.

You can use C=chr to drop several bytes. Also, shorten the variable name code.

Since nobody said it for over a year, Welcome to PPCG!

Python 2, 47 bytes
_='_=%r;print _%%_==input()';print _%_==input()

A simple quine with the added check.

This doesn't work. print is a function is Python 3. You'd need to do print(_%%_==input())';print(_%_==input()) or change it to Python 2.

CJam, 12 bytes
{s"_~"+q=}_~

Try it online!
Explanation
This just uses the standard CJam quine framework.
{s"_~"+q=}    e# Push this block (function literal).
          _~  e# Copy and run it.

What the block does:
 s            e# Stringify the top element (this block itself).
  "_~"+       e# Append "_~". Now the source code is on the stack.
       q      e# Read the input.
        =     e# Check if it equals the source code.

This is exactly the solution I had ._.

Tcl, 111 chars
set c {set c {$c};puts [expr {[read stdin] eq [subst -noc \$c]}]};puts [expr {[read stdin] eq [subst -noc $c]}]

Perl, 52 char
$_='$/=$\;$_="\$_=\47$_\47;eval";print<>eq$_|0';eval

Husk, 11 bytes
=hS+s"=hS+s

Try it online!
Explanation
The explanation uses ¨ to delimit strings (to avoid unreadable escaping):
     "=hS+s  -- string literal: ¨=hS+s¨
  S+         -- join itself with
    s        -- | itself "showed": ¨"=hS+s"¨
             -- : ¨=hS+s"=hS+s"¨
 h           -- init: ¨=hS+s"=hS+s¨
=            -- is the input equal?

By removing the function = you can verify that it will indeed only match the source itself.

Python 2, 40 bytes
s="print's=%r;exec s'%s==input()";exec s

Try it online!

><>, 24 bytes
'1rd3*i={*}50l3-?.~i)*n;

Try it online!
Wrapping string literal followed by checking whether the input is identical to the stack, with a final check that there is no more input.

Jelly, 10 bytes
“Ṿ;$⁼”Ṿ;$⁼

Try it online!
“Ṿ;$⁼”Ṿ;$⁼
“Ṿ;$⁼”      String literal: 'Ṿ;$⁼'
        $   Next two links act on the string literal
      Ṿ     Uneval: '“Ṿ;$⁼”'
       ;    Append string: '“Ṿ;$⁼”Ṿ;$⁼' (source code)
         ⁼  Is the string above equal to the input?

Zsh, 33 bytes
f () {
	[ "`type -f f`" = $1 ]
}

Try it online!
The extra spaces, tab, and newlines are required. type -f f does not print the original source, but the function formatted in a particular way, with indentation and a trailing newline.

R, 54 bytes
f=function(s)s==paste0("f=function(s)s==", body(f)[3])

Try it online!
body gets the body of the function (splitting it a bit, so that body(f)[3] is everything from paste0 onwards). Interestingly, body reformats the code, adding spaces after commas, etc. This is thus a rare case of an R golf answer with a space after a comma.
This works because body(f) is an object of type language, and there exists an as.character method for this type. On the other hand, f and args(f) are of type closure, and cannot be converted to character type as far as I can tell. Please don't ask me what the language type is for…

As we've noted before, R's code-reformatting is quite version-dependent.  My old R version 3.2.1 let's me use f=function(x)x==paste0('f=',capture.output(f)) successfully for only 46 bytes, but the later version in TIO fills it up with annoying spaces & newlines...

@DominicvanEssen Good find! capture.output works as you would want on my later version of R (3.6.3), but it adds a bytecode at the end. The output is thus a vector of 2 logicals: the first one corresponds to what you want, the second tests equality with the bytecode. I believe this is acceptable: in R, a vector of two logicals is truthy iff the first logical is TRUE (per the definition along the lines of "how would if handle it?). You should post this separately!

Thanks very much for checking that!  It seems that only specific R versions don't work (annoyingly including the one at TIO) - I now tested version 4 and it works Ok, too.  So I've posted a separate version-dependent R answer now.

R (version-dependent), 46 bytes
f=function(x)x==paste0('f=',capture.output(f))

capture.output - as the function name suggests - retrieves the text string that results from entering the function name f directly to R, which should output the body of the function.  We manually prepend this with f= so that it exactly* matches the program code, and check whether the function argument x is the same as this.
*See below
There are a couple of caveats, though, that depend on the R version used:

Early versions of R (like my own version 3.2.1) return the originally-defined function body as-is when the function name is entered to R.  However, later versions add additional formatting, like inserting spaces and newlines, which breaks this code: this unfortunately includes the installation (3.5.2) on 'Try it online'.  Later still, much newer R versions (I tested 4.0.3) return to the as-is output formatting and everything is Ok again...  except...
The most recent versions of R compile functions at the first run, and thereafter append a 'byte code' specific for the compiled function to the outputted function body.  This means that capture.output returns two strings, beginning at the second time the function is run.  Luckily, the function body is still the first one (the byte code is the second one), so the result of supplying the program code as input is TRUE FALSE, which evaluates to 'truthy' in R and so counts as a 'true' output for this challenge.

Special thanks to Robin Ryder for helping to uncover the version-dependence of R's function outputting.

Vyxal, 12 bytes
`:q$+=`:q$+=

Try it Online!
I finished making this, and then realized that it is almost identical to the Vyxal quine that @Lyxal wrote, but with the addition of = to check if the input is equal.
Explanation:
              # Implicit input
`:q$+=`       # Push the string ':q$+='
       :      # Duplicate the string
        q     # Quotify; put backticks around the topmost string
         $    # Swap the top two values on the stack
          +   # Concatenate the two strings
           =  # Check if the input is equal to the string
              # Implicit output

C - 186 176 characters
One liner:
 *a="*a=%c%s%c,b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}",b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}

With whitespace (note that this breaks the program):
*a="*a=%c%s%c,b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}",b[999],c[999];
main() {
  sprintf(b,a,34,a,34);
  gets(c);
  putchar(strcmp(b,c)?'0':'1');
}

#PowerShell, 28 bytes
Very similar to this JavaScript answer, uses function provider.
filter f{"$Function:f"-eq$_}

#Example
PS > '"$Function:f"-eq$_' | f
True

PS > 'xxx' | f
False

Stax, 26 bytes
"34bLN26)s:f="34bLN26)s:f=

Run and debug it

JavaScript ES6, 14 bytes
Like the other javascript answer but includes it's entire source code and not just the function
a=q=>'a='+a==q

Example usage:
a("q=>'a='+a==q") // returns false
a("a=q=>'a='+a==q") // returns true

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

Modifies the default quine 0"D34çý"D34çý by adding Q (check for equality with the implicit input)
Try it online.
Explanation:
0                # Push 0 to the stack
                 #  STACK: [0]
 "D34çýQ"        # Push the string 'D34çýQ' to the stack
                 #  STACK: [0, 'D34çýIå']
         D       # Duplicate this string
                 #  STACK: [0, 'D34çýIå', 'D34çýIå']
          34ç    # Push '"' to the stack
                 #  STACK: [0, 'D34çýIå', 'D34çýIå', '"']
             ý   # Join the stack by this '"' delimiter
                 #  STACK: ['0"D34çýIå"D34çýIå']
              Q  # Check if it's equal to the (implicit) input
                 # (and output the top of the stack implicitly as result)

Cool 15 bytes alternative provided by @Grimy:
187745012D27BJQ

Try it online.
Explanation:
187745012        # Push integer 187745012
                 #  STACK: [187745012]
         D       # Duplicate it
                 #  STACK: [187745012, 187745012]
          27     # Push integer 27
                 #  STACK: [187745012, 187745012, 27]
            B    # Convert 187745012 to base-27
                 #  STACK: [187745012, "D27BJQ"]
             J   # Join the values on the stack together
                 #  STACK: ["187745012D27BJQ"]
              Q  # Check if it's equal to the (implicit) input
                 # (and output the top of the stack implicitly as result)

187745012D27BJQ is a tie.

q, 8 bytes
{x~.z.s}

Return boolean on input matching the self-referential .z.s

Runic, 11 bytes
"3X4+kSqi=@

Try it online!
TIO got updated and there's no longer an issue reading input (and no longer requires a trailing whitespace).
Explanation
>                 Implicit entry
 "                Begin reading as string
  3X4+kSqi=@      Pushed to the stack as a string, loop around
 "                End reading as string
  3X4+            Push 3*10 and 4 to the stack, add them together
      k           Convert to character (")
       S          Swap the top two items on the stack
        q         Concatenate. This leaves only "3X4+kSqi=@ on the stack
         i        Read input
          =       Compare using .Equals, push 1 if equal, else 0
           @      Print and terminate

JoKing's solution:
"'<~qi=@|

Explanation
  <              Entry
 '               Read character (loop around)
"                Push "
         |       Mirror
"                Begin reading string (loop around)
 '<~ri=@|        Push the string '<~qi=@| (loop around)
"                End reading string
 '<~             Push the character < and then discard it
    q            Concatenate, stack contains only "'<~qi=@|
      i          Read input
       =         Compare
        @        Print and terminate

10 bytes

@JoKing Very clever.

Actually, 9 bytes avoids the reverse

@JoKing I probably should've been able to arrive at that (from the 10 byte solution) myself, but I haven't had my cawfee yet. I'd already worked out yesterday that having the " on the left is the only place it can really go, because having it elsewhere complicates things. (But just now I had to run it in my debugger to see what it was doing...)

Keg, 36 28 26 bytes
`:&\`ⁿ^\`ⁿ&⅀=`:&\`ⁿ^\`ⁿ&⅀=

Try it online!
Same concept as before, but shorter.
Answer History
`:&\`ⁿ⅍^\`ⁿ⅍++&+¿=`:&\`ⁿ⅍^\`ⁿ⅍++&+¿=

Try it online!
Who knew generating a program that knows itself would be so unreadable!
Explained
The very first step here is to generate the string that will be checked against. At this point, we don't particularly know what the checking part will look like, but we do know that there will be a string that looks like so:
`\`ⁿ⅍^\`ⁿ⅍++`

Which would consequently be followed by:
 \`ⁿ⅍^\`ⁿ⅍++

This creates a string which contains itself quoted... Something needed for when input is taken, as the quotes are going to be present.
From here, string equality is quite easy, coming in at a trivial 2 bytes:
¿=

Incorporating this into the string gives:
`\`ⁿ⅍^\`ⁿ⅍++¿=`\`ⁿ⅍^\`ⁿ⅍++¿=

At this stage, one might think the quine is complete... It has the string part and it has the equality part... What else could be needed? Well. Let me tell you we ain't done yet.
Y'see, we have a quoted string on the stack, but we don't have it's unquoted equivalent present, meaning we need to account for that. The register works well here:
`:&\`ⁿ⅍^\`ⁿ⅍++&+¿=`:&\`ⁿ⅍^\`ⁿ⅍++&+¿=

And there you have it: a self identifying program written completely on a phone keyboard.

It still outputs 1 if the input is followed by a newline and then anything else

Well of course it would, because Keg only reads one line at a time. I'll have to clarify input methods with Keg, because otherwise multi line input isn't possible.

Perl 6, 33 bytes
<dd "<$_>~~.EVAL"eq slurp>~~.EVAL

Try it online!
Outputs either Bool::True or Bool::False to STDERR. This is the basic quine format, with an added check against input (eq slurp).

Japt, 22 16 14 bytes
"iQ ²¶U"iQ ²¶U

Try it online!
Explanation
"iQ ²¶U"iQ ²¶U
"iQ ²¶U"        // Take this string.        iQ ²¶U
        iQ      // Insert a quote.          "iQ ²¶U
           ²    // Double.                  "iQ ²¶U"iQ ²¶U
            ¶U  // Check if equal to input.

Ruby -0n, 32 27 bytes
Saved 5 bytes thanks to a comment by @Sisyphus on another answer.
eval s="p$_=='eval s=%p'%s"

Try it online!
Disclosure: very similar to my answer on a duplicate question.
The -0 flag sets the null byte as the input record separator. Without -0, each line of the input would be read (and tested for equality with the code) separately.

C (gcc), 132 bytes
#define Q(X)main(c,v)int**v;{return!strcmp(#X"\nQ("#X")",v[1]);}
Q(#define Q(X)main(c,v)int**v;{return!strcmp(#X"\nQ("#X")",v[1]);})

Try it online!
It turns out using a macro works out better than using (a)sprintf, even with %c%s%1$c.
I'm not sure if this type of input (a single multiline command-line argument) and output (return value of 1 for true or 0 for false) are allowed.
If they aren't:

C (gcc), 152 bytes
x,y[99];main(z){asprintf(&x,z="x,y[99];main(z){asprintf(&x,z=%c%s%1$c,34,z);gets(y);putchar(48+!strcmp(x,y));}",34,z);gets(y);putchar(48+!strcmp(x,y));}

Try it online!
Assumes an ASCII environment. Reads from stdin, writes 1 or 0 to stdout. Abuses ints as pointers, leaks memory, and uses the dreaded gets :)

In case you're curious, here's the opposite combinations of quine and IO methods:
C (gcc), 136 bytes
x;main(y,v)int**v;{asprintf(&x,y="x;main(y,v)int**v;{asprintf(&x,y=%c%s%1$c,34,y);return!strcmp(x,v[1]);}",34,y);return!strcmp(x,v[1]);}

Try it online!
C (gcc), 158 bytes
#define Q(X)v[40];main(){read(0,v,159);putchar(48+!strcmp(#X"\nQ("#X")",v));}
Q(#define Q(X)v[40];main(){read(0,v,159);putchar(48+!strcmp(#X"\nQ("#X")",v));})

Try it online!

Julia 1.0, 48 bytes
(a=:(show(ARGS[] == "(a=:($(a)))|>eval")))|>eval

Try it online!

Uiua, 38 bytes
≅&sc⊂∶!(⊂⊂↷.+1@!)."≅&sc⊂:!(⊂⊂↷.+1@!)."

Explained
≅&sc⊂∶!(⊂⊂↷.+1@!)."≅&sc⊂:!(⊂⊂↷.+1@!)."
                  "≅&sc⊂:!(⊂⊂↷.+1@!)."  # The string "≅&sc⊂:!(⊂⊂↷.+1@!)."
                 .                      # Duplicate it
      !(        )                       # Call the following function on the top copy:
           .+1@!                        #   Push two "
         ⊂↷                             #   Append the first
        ⊂                               #   Prepend the second
# The top of the stack is now a quotified string
    ⊂∶                                  # Prepend the original string without quotes
≅&sc                                    # Does that equal the input?

Created with the help of Luminespire.

Vyxal, 38 bitsv2, 4.75 bytes
`I=`I=

Try it Online!
Explained
`I=`I=
     =  # Does the input equal
`I=`    # The string "I="
    I   # With itself wrapped in backticks prepended

Created with the help of Luminespire.

V, 19 bytes
ñOÑ~"qpxØ¥^¨©î±¥$

Try it online!
Prints 1 or 0. Here is a hexdump:
00000000: f14f d11b 7e22 7170 78d8 a55e a881 a9ee  .O..~"qpx..^....
00000010: b1a5 24                                  ..$

Java 8, 288 bytes (Full Program with STDIN)
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(s.format(s,34,s).equals(new java.util.Scanner(System.in).nextLine()));}}";System.out.print(s.format(s,34,s).equals(new java.util.Scanner(System.in).nextLine()));}}

Try it online.
Java 8, 210 bytes (Full Program with Console Arguments)
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(s.format(s,34,s).equals(a[0]));}}";System.out.print(s.format(s,34,s).equals(a[0]));}}

Try it online.
Java 8, 108 bytes (Function)
i->{String s="i->{String s=%c%s%1$c;return s.format(s,34,s).equals(i);}";return s.format(s,34,s).equals(i);}

Try it online.
Explanation:
quine-part:

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

Challenge-part:

.equals(...) checks if this formatted source code equals the input.

java.util.Scanner(System.in).nextLine() is used as this input for STDIN
a[0] is used as this input for Console arguments
i is used as this input for the lambda function

Pascal (FPC), 167 157 bytes
const b=#39';var s:string;begin read(s);write(s=a+b+#39#59#97#61#39+a+b)end.';a='const b=#39';var s:string;begin read(s);write(s=a+b+#39#59#97#61#39+a+b)end.

Try it online!
While substring can be easily extracted, like in my regular quine, unfortunately, they cannot be concatenated because FPC thinks it is an array in these circumstances. In a and b are characters before and after constant definitions. #39#59#97#61#39 is a replacement for ';a=' as this is not represented in the constants. #39 represents ' and is at the start of b, glued together to the rest of b, to shorten the comparison expression as much as possible.

TeX, 55 bytes
The file has to be saved as a.tex and should be run using pdftex a.tex. The script doesn't terminate after returning 1 or 0, if that should be necessary append it by \end (+4 bytes). If it should work for arbitrary file names replace \openin0a with \openin0\jobname (+7 bytes).
\openin0=a\read0to\0\read1to~\message{\ifx\0~1\else0\fi}

Python 3.8 (pre-release), 42 bytes
exec(s:="print('exec(s:=%r)'%s==input())")

Try it online!

Java, 318 bytes
interface Q{static void main(String[]a){char q=34;String s="interface Q{static void main(String[]a){char q=34;String s=%c%s%c;System.out.print(new java.util.Scanner(System.in).nextLine().equals(String.format(s,q,s,q)));}}";System.out.print(new java.util.Scanner(System.in).nextLine().equals(String.format(s,q,s,q)));}}

Try it online!

Japt, 11 bytes
¶BîQi"¶BîQi

Try it
¶BîQi"¶BîQi     :Implicit input of string
¶               :Is strictly equal to
 B              :  11
  î             :  Mold to length B
   Q            :    Quotation mark
    i           :    Prepend
     "¶BîQi     :      Literal string

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


text:
Fault-Tolerant Hello World
At the end of your interview, the Evil Interviewer tells you, "We make all of our applicants take a short coding test, to see if they really know what they are talking about.  Don't worry; it's easy.  And if you create a working program, I'll offer you the job immediately."  He gestures for you to sit down at a nearby computer.  "All you have to do is create a working  Hello World program.  But"--and he grins broadly--"there's a catch.  Unfortunately the only compiler we have on this machine has a small bug.  It randomly deletes one character from the source code file before compiling.  Ok, see you in five minutes!"  And he walks out of the room, whistling happily.
Can you guarantee that you will get the job?
The Task
Write a program that will print Hello, world! to standard output even after a single character is removed from any position in the file. Or come as close to this as possible.
The Rules
No Extraneous Output - Hello, world! must be the only substantive thing printed to standard output.  It is ok to include other characters if they are naturally produced by your language of choice--such as a trailing newline or even something like [1] "Hello, world!" (for example if you were using R), but it must print the exact same thing every time.  It cannot print Hello, world!Hello, world! or Hello world!" && x==1 some of the time, for example.  Warnings, however, are allowed.
Testing In order to test determine your score, you have to test each possible permutation of the program: test it with each character removed, and see if it produces the correct output.  I have included a simple Perl program for this purpose below, which should work for many languages.  If it doesn't work for you, please create a test program and include it in your answer.
Scoring Your score is the number of times your program fails.  In other words, the number of individual positions in your file where deleting a character prevents your program from working.  Lowest score wins.  In the event of a tie, the shortest code wins.
Trivial Solutions such as "Hello, world!" in several languages (score of 15) are acceptable, but they aren't going to win.
Happy programming, and may you get the job. But if you fail, you probably didn't want to work for that evil boss anyway.
Perl test script:
use warnings;
use strict;

my $program   = 'test.pl';
my $temp_file = 'corrupt.pl';
my $command = "perl -X $temp_file"; #Disabled warnings for cleaner output.
my $expected_result = "Hello, world!";

open my $in,'<',$program or die $!;
local $/;           #Undef the line separator
my $code = <$in>;   #Read the entire file in.

my $fails = 0;
for my $omit_pos (0..length($code)-1)
{
    my $corrupt = $code;
    $corrupt =~ s/^.{$omit_pos}\K.//s;  #Delete a single character

    open my $out,'>',$temp_file or die $!;
    print {$out} $corrupt;  #Write the corrupt program to a file
    close $out;

    my $result = `$command`;    #Execute system command.
    if ($result ne $expected_result)
    {
        $fails++;
        print "Failure $fails:\nResult: ($result)\n$corrupt";
    }
}

print "\n$fails failed out of " . length $code;

Can the deleted character result in the program not compiling? Is that still counted as not working?

@lochok, yes, that would count as a failure.  Any deleted character which leads to Hello, World! not being printed is a failure.

Similar question: http://codegolf.stackexchange.com/questions/4486/write-a-program-that-always-outputs-2012-even-if-its-modified

@Walkerneo, thanks! I searched for similar questions and didn't find that one. I think this is significantly different, though. In particular, that question guarantees that only modifications resulting in syntactically valid code have to be handled.

The Perl test script should be subject to the same 1-character deletion

Befunge, Score 0, 96 bytes
I think I cracked it - no single character deletion will change the output.
Deleting any character from line 1 changes nothing - it still goes down at the same place.
Lines 2 and 3 are redundant. Normally line 2 is executed, but if you delete a character from it, the < is missed, and line 3 takes charge.
Deleting newlines doesn't break it either (it did break my previous version).
No test program, sorry.
EDIT: simplified a lot.
                              vv
@,,,,,,,,,,,,,"Hello, world!"<<
@,,,,,,,,,,,,,"Hello, world!"<<

A short explanation of the flow:

Befunge starts executing from top-left, moving right. Spaces do nothing.
v turns the execution flow downward, so it goes down one line.
< turns the execution flow left, so it reads line 2 in reversed order.
"Hello, world!" pushes the string to the stack. It's pushed in reversed order, because we're executing right to left.
, pops a character and prints it. The last character pushed is printed first, which reverses the string once more.
@ terminates the program.

+1, great solution. I don't think a test program is needed, because it is obvious that there is only a small number of potentially significant deletions.

So easy to verify and no discussion involved. Genius!

Congratulations on an excellent solution.

I know this isn't [tag:code-golf], but here's a version in 66 bytes.

HQ9+
This will never fail to produce the intended result when a character is deleted so gets a score of zero.
HH

When do I start?

It produces "hello, world" though, not "Hello, world!" as specified.

Nonsense, the language was just incorrectly specified on the esolang wiki ;)

Good for you if they have an HQ9+ compiler on the interview computer... :)

You could write your own buggy compiler.

@mbomb007 This interpreter prints Hello, world! for the H command.

Perl, Score 0
(147 characters)
Here is my solution, which I managed to get from 4 down to 0:
eval +qq(;\$_="Hello, world!";;*a=print()if length==13or!m/./#)||
+eval +qq(;\$_="Hello, world!";;print()if*a!~/1/||!m/./#)##)||
print"Hello, world!"

It must appear all on one line to work; line breaks are for "readability" only.
It benefits from Perl's pathologically permissive syntax.  Some highlights:

Barewords that are not recognized are treated as strings. So when eval becomes evl, that is not an error if a string is permissible at that point.
Unary + operator, which does nothing other than disambiguate syntax in certain situations.  This is useful with the above, because function +argument (where + is unary) becomes string + argument (addition) when a function name is mangled and becomes a string.
Many ways to declare strings: a double quoted string qq( ) can become a single-quoted string q(); a string delimited by parentheses qq(; ... ) can become a string delimited by a semicolon qq; ... ;. # inside strings can eliminate balancing issues by converting things to comments.

The length of this can probably be reduced somewhat, though I doubt ugoren's solution can be beaten.

+1 for line breaks are for readability only ...

Befunge-98, score 0, 45 bytes
20020xx""!!ddllrrooww  ,,oolllleeHH""cckk,,@@

Try it online!
Although an optimal solution has already been found (and there's no tie breaker), I thought I'd show that this can be simplified considerably with Befunge 98.
Explanation
The 20020xx reliably sets the delta (the steps of the instruction pointer between ticks) to (2,0) so that starting at the first x, only every other command is executed. See this answer for a detailed explanation of why this works. Afterwards, the code is merely:
"!dlrow ,olleH"ck,@

We first push all the relevant character codes onto the stack with "!dlrow ,olleH". Then ck, means print the top of the stack (,), 13 (c plus 1) times (k). @ terminates the program.

J, 7 points
Selecting every letter with odd position:
   _2{.\'HHeellllo,,  wwoorrlldd!!'
Hello, world!

The same thing in golfscript would be 4 points: 'HHeelllloo,,  wwoorrlldd!!'2%

@cardboard_box Feel free to submit it. :)

Upvoting because I understand it, and it doesn't feel like cheating.

Unary, score 0, 74817134662624094502265949627214372599829 bytes
The code is not included due to post length limitations, but it consists of 74817134662624094502265949627214372599829 zeros.
If any of these zeros is removed, the resulting brainfuck program is KSab's hello world program.
Sadly, I didn't get the job because my machine had only 500 GB of hard disk space.

Lost, Score 0, 122 bytes
>>>>>>>>>>>>>%%/>>>>>>>>>>/
\\
>>>>>>>>>>>>>//>>>>>>>>>>>\\
//
/@+-(  "vUvdlrow ,olleH"?<<
///
/@+-("vUvdlrow ,olleH"? <<<

Try it online!
It never stops amazing me that radiation-hardening are possible in Lost.
If you haven't seen Lost before it is a 2-D programming language in which instead of starting execution at a fixed location it chooses a random location and direction and starts there.  This makes writing any lost program a bit of a radiation hardening challenge normally, since a program must work from every start location.  But now we layer on radiation-hardening too and every program must work from every start location.  With 122 bytes, four directions and a 28 by 6 bounding box, this means there are approximately 80,000 different programs that must be work.
This program is built with a mix of standard lost methods and standard radiation hardening methods.  To start here is the normal Hello World for lost:
v<<<<<<<<<<>>>>>>>>>>>
>%?"Hello, worldvU"-+@

It is comprised of a "collector" which gathers all the stray instruction pointers and points them to the beginning of the actual program.
v<<<<<<<<<<>>>>>>>>>>>
>               v

A more detailed explanation of how this program works can be found here.
Now we want to modify this program to use the duplicate alignment method of radiation hardening.  This method works by having two copies of the desired code and entering them from the end of the line.
>>>>>>>>>vv
 program <
 program <

This way when on of the programs is edited it becomes misaligned and the other one is executed
>>>>>>>>>vv
 progam <
 program <

To do this with our lost program is pretty simple:
>>>>>>>>>>>>>>>>>>>>>\\
@+-"Uvdlrow ,olleH"?%<
@+-"Uvdlrow ,olleH"?%<

However there are some problems with this.  The alignment of the "s is an issue because it causes infinite loops (in the example above there are basically two strings ">" lain out vertically, so if you start on the quotes going in the right direction you just push the > character endlessly).  So you need to make sure the quotes don't line up even when a character has been deleted.
>>>>>>>>>>>>>>>>>>>>>>>\\
@+-  "Uvdlrow ,olleH"?%<
@+-"Uvdlrow ,olleH"?%  <

Also since v is needed to escape the inside of the string it's deletion is potentially a problem.  So we need a backup.
>>>>>>>>>>>>>>>>>>>>>>>>>\\
@+-(  "vUvdlrow ,olleH"?%<
@+-("vUvdlrow ,olleH"?%  <

Now while alignment prevents most pointers from entering the wrong program, if we delete a non-critical character from a program, e.g.
>>>>>>>>>>>>>>>>>>>>>>>>>\\
@+-(  "vUvdlrow ,olle"?%<
@+-("vUvdlrow ,olleH"?%  <

Then if execution starts on the % it doesn't need to care about the alignment at all and it will just execute the bad program.  So we need to move % before the alignment
>>>>>>>>>>>>>>>>>>>>>>%%\\
@+-(  "vUvdlrow ,olleH"?<
@+-("vUvdlrow ,olleH"?  <

Now another line of collector is needed to fill the gap we made by adding non-redirecting characters to our collector (%s).
>>>>>>>>>>>>>>%%/>>>>>>>/
>>>>>>>>>>>>>>//>>>>>>>>\\
@+-(  "vUvdlrow ,olleH"?<
@+-("vUvdlrow ,olleH"?  <

(Some small changes are glossed over here mainly just edge casey nonsense)
Now we have to worry about what happens when a newline is deleted.  This would normally be ok because the alignment doubling strategy works for these, however for us it opens the door to a lot of potential infinite loops for example in the program:
>>>>>>>>>>>>>>%%/>>>>>>>/
>>>>>>>>>>>>>>//>>>>>>>>\\@+-(  "vUvdlrow ,olleH"?<
@+-("vUvdlrow ,olleH"?  <

we now have a bunch of columns with no redirecting characters on them, so pointers starting there can just loop up or down endlessly.
The trick we use here is to add (nearly) blank lines so that deleting a newline doesn't smash two big lines together.
>>>>>>>>>>>>>>%%/>>>>>>>/

>>>>>>>>>>>>>>//>>>>>>>>\\

@+-(  "vUvdlrow ,olleH"?<

@+-("vUvdlrow ,olleH"?  <

So if we delete a newline:
>>>>>>>>>>>>>>%%/>>>>>>>/

>>>>>>>>>>>>>>//>>>>>>>>\\
@+-(  "vUvdlrow ,olleH"?<

@+-("vUvdlrow ,olleH"?  <

Nothing fundamentally changed about our program.  However these lines can't be completely blank as it leaves the door open for infinite loops.  In fact they need to have at least two (because one could be deleted) redirecting characters.
>>>>>>>>>>>>>>%%/>>>>>>>/
//
>>>>>>>>>>>>>>//>>>>>>>>\\
//
@+-(  "vUvdlrow ,olleH"?<
//
@+-("vUvdlrow ,olleH"?  <

Now if we delete the last newline our quotes align again:
>>>>>>>>>>>>>>%%/>>>>>>>/
//
>>>>>>>>>>>>>>//>>>>>>>>\\
//
@+-(  "vUvdlrow ,olleH"?<
//@+-("vUvdlrow ,olleH"?  <

Which is no good so we use 3 characters on the 3rd filler line:
>>>>>>>>>>>>>>%%/>>>>>>>/
//
>>>>>>>>>>>>>>//>>>>>>>>\\
//
@+-(  "vUvdlrow ,olleH"?<
///
@+-("vUvdlrow ,olleH"?  <

From here we arrive at the final program with just some minor fiddling.  Iteratively fixing and finding mistakes.  I've covered everything I think is interesting, but if you are interested in exactly why this or that just leave a commend and I will add it to the explanation.

Klein 0X1, score 0, 38 bytes
Works in both 011 (real projective plane) and 001 (Klein bottle)
//
@"!dlrow ,olleH"<
@"!dlrow ,olleH"<

Try it online!
This reflects the ip over the top of the program.  The geometry causes the ip to reenter the program on the opposite end of the program.  This makes it a lot shorter than the traditional method which requires a full length line to reach the right side of the program.
000, score 0, 38 bytes
<<@"!dlrow ,olleH"/
<@"!dlrow ,olleH"/

Try it online!
1X1 or 20X, score 0, 39 bytes
Works in 101, 111, 200, and 201
..

@"!dlrow ,olleH"<
@"!dlrow ,olleH"<

Try it online!
Due to the longstanding bug that spaces are trimmed off the front of Klein programs two .s are needed to make this work.  If it were not for this bug the 37 byte program:

@"!dlrow ,olleH"<
@"!dlrow ,olleH"<

world work in all of these geometries.
The idea here is that we choose a geometry that naturally reaches the location we want and clear its way. Particularly we want geometries that connect the east edge to either the north or south edges with the proper twisting so that the ip leaving the east edge enters on the right side of the program.  There are 4 of these.
0X0, score 0, 40 bytes
Works in both 000 (torus) and 010 (Klein bottle)
||@"!dlrow ,olleH"./
..@"!dlrow ,olleH"/

Try it online!
1X1, 20X, 210, or 101, score 0, 43 bytes
Works in 101, 111, 200, 201, 210, and 101
..

  @"!dlrow ,olleH"<
  @"!dlrow ,olleH"<

Try it online!
A modified version of the above where we move the @s out of the path so that 210 and 101 work.  Once again .. is required due to a bug and could be removed for a 2 byte save if the bug were fixed.
XXX, score 0, 54 bytes
Works in every geometry
.               \\
@"!dlrow ,olleH"<
@"!dlrow ,olleH"<

Try it online!

Python 3, score = 6 4, 454 426 bytes
xec=eec=exc=exe=exeexec=rint=pint=prnt=prit=prin=ppprint=hhh=hh=hhh=fr=""""pp(fr[1::2]) rrr________:__"ii______p____;nn____p______ptt__(________p(( __________(ff__________rfrr________[__r[[______1____[11____:______1::__:________:22 __________:66__________-2::________4__]22______]____)]]____)______ ))"""##"""
xec=eec=exc=exe=exec
pp=print
fr=fr=fr=""""HHeelllloo,,  wwoorrlldd!!"""##"""

exec(hhh[1::2++2++2++2++2++2++2++00])

Try it online!
The undeletable char are parenthesis for the exec function and the brackets.
How it works:

hhh=hh=hhh=fr=... initialize the main code and stor it in hhh

xec=...=ppprint=... initialize all possibe deletion of exec and print to avoid a future NameError

xec=eec=exc=exe=exec ensure that exec (with possible deletions) is well defined

fr=fr=fr=""""HHeelllloo,,  wwoorrlldd!!"""##""" store in fr the string Hello, world! but doubled to keep the information even with a deletion

the last slice can be equal to either [1::14], [::14], [1:14] or [1::12]. Both of them slice the main code to have respectively print(fr[1:26:2]), "r";pp(fr[1::2]) , pp(fr[1::2])  or p :pp( fr[1:: 6-4])

Thanks to @Jo King♦ for pointing me my errors, helping me to solve them and helped me to golf the result

457 bytes

@JoKing Thanks a lot. I even gained 3 bytes by using fr instead of rr as variable name

What if a bracket is deleted?

@Anm The program fails then ("The undeletable char are parenthesis for the exec function and the brackets."). That's why it has a score of four, not zero.

8086 machine code (MS-DOS .COM), 71 bytes, score = 0
Slight variation on previous answers on the same theme.
In binary form:
00000000 : EB 28 28 E8 00 00 5A 83 C2 09 B4 09 CD 21 C3 48 : .((...Z......!.H
00000010 : 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21 24 90 90 90 : ello, World!$...
00000020 : 90 90 90 90 90 90 90 90 90 90 EB D7 D7 E8 00 00 : ................
00000030 : 5A 83 C2 09 B4 09 CD 21 C3 48 65 6C 6C 6F 2C 20 : Z......!.Hello,
00000040 : 57 6F 72 6C 64 21 24                            : World!$

In readable form (NASM syntax):
cpu 8086
org 0x100

%macro CODEPART 0
    call near .nextline
.nextline:
    pop dx
    add dx, 0x09
    mov ah, 0x09
    int 0x21
    ret

.msg        db "Hello, World!$"
%endmacro

jump1:
    jmp jump2
    db 0x28

part1:
    CODEPART

filler:
    times 13    db 0x90

jump2:
    jmp part1
    db 0xd7

part2:
    CODEPART

Rundown
The active part is duplicated so that there is always one untouched by radiation. We select the healthy version by way of jumps. Each jump is a short jump, and so is only two bytes long, where the second byte is the displacement (i.e. distance to jump, with sign determining direction).
We can divide the code into four parts which could be irradiated: jump 1, code 1, jump 2, and code 2. The idea is to make sure a clean code part is always used. If one of the code parts is irradiated, the other must be chosen, but if one of the jumps is irradiated, both code parts will be clean, so it will not matter which one is chosen.
The reason for having two jump parts is to detect irradiation in the first part by jumping over it. If the first code part is irradiated, it means we will arrive one byte off the mark. If we make sure that such a botched landing selects code 2, and a proper landing selects code 1, we're golden.
For both jumps, we duplicate the displacement byte, making each jump part 3 bytes long. This ensures that irradiation in one of the two last bytes will still make the jump valid. Irradiation in the first byte will stop the jump from happening at all, since the last two bytes will form a completely different instruction.
Take the first jump:
EB 28 28        jmp +0x28 / db 0x28

If either of the 0x28 bytes are removed, it will still jump to the same place. If the 0xEB byte is removed, we will instead end up with
28 28           sub [bx + si], ch

which is a benign instruction on MS-DOS (other flavours might disagree), and then we fall through to code 1, which must be clean, since the damage was in jump 1.
If the jump is taken, we land at the second jump:
EB D7 D7        jmp -0x29 / db 0xd7

If this byte sequence is intact, and we land right on the mark, that means that code 1 was clean, and this instruction jumps back to that part. The duplicated displacement byte guarantees this, even if it is one of these displacement bytes that were damaged. If we either land one byte off (because of a damaged code 1 or jump 1) or the 0xEB byte is the damaged one, the two remaining bytes will also here be benign:
D7 D7           xlatb / xlatb

Whichever the case, if we end up executing those two instructions, we know that either jump 1, code 1, or jump 2 were irradiated, which makes a fall-through to code 2 safe.
Testing
The following program takes the COM filename as an argument, and creates all variants of it, along with a file called tester.bat. When run in DOS, this BAT file will run each of the created binaries, redirecting the outputs into one text file per program.
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    FILE *fin, *fout, *fbat;
    int fsize;
    char *data;

    if (!(fin = fopen(argv[1], "rb")))
    {
        fprintf(stderr, "Could not open input file \"%s\".\n", argv[1]);
        exit(1);
    }

    if (!(fbat = fopen("tester.bat", "w")))
    {
        fprintf(stderr, "Could not create BAT test file.\n");
        exit(2);
    }

    fseek(fin, 0L, SEEK_END);
    fsize = ftell(fin);
    fseek(fin, 0L, SEEK_SET);

    if (!(data = malloc(fsize)))
    {
        fprintf(stderr, "Could not allocate memory.\n");
        exit(3);
    }

    fread(data, 1, fsize, fin);

    fprintf(fbat, "@echo off\n");

    for (int i = 0; i < fsize; i++)
    {
        char fname[512];

        sprintf(fname, "%02d.com", i);
        fprintf(fbat, "%s > %02d.txt\n", fname, i);

        fout = fopen(fname, "wb");

        fwrite(data, 1, i, fout);
        fwrite(data + i + 1, 1, fsize - i - 1, fout);

        fclose(fout);
    }

    free(data);
    fclose(fin);
    fclose(fbat);
}

DOSBox, where I tested this, does not have the fc command, so another BAT file was created to run under Windows. It compares each text file with the first one to make sure they are all identical:
@echo off

for %%x in (*.txt) do (
    fc %%x 00.txt > nul
    if ERRORLEVEL 1 echo Failed: %%x
)

Ocular inspection of one of the text files is still needed.

Why 28 and some fill? Is it least to make them benign?

@l4m2 It was a while, so I can't remember super clearly, but that should be it. Something that makes both jumps benign if either is truncated.

Refered to the answer you linked, it's from there and a lazy move

@l4m2 Well, if you have an alternative that is shorter, by all means.

So I saved from the 13 nops, 3+4 add dx,9 into call AFTERTEXT

Befunge-93, Score 0 (63 bytes)
I know this isn't a code-golf challenge, but I thought it would be interesting to see if the existing Befunge-93 solution could be improved upon in terms of size. I had originally developed this technique for use in the similar Error 404 challenge, but the need for a wrapping payload in that case made the 3 line solution more optimal.
This isn't quite as good as Martin's Befunge-98 answer, but it's still a fairly significant reduction on the winning Befunge-93 solution.
<>>  "!dlrow ,olleH">:#,_@  vv
  ^^@_,#!>#:<"Hello, world!"<<>#

Try it online!
Explanation
There are two versions of the payload. For an unaltered program, the first < causes the program to execute right to left, wrapping around to the end of the line, until it reaches a v directing it down to the second line, and a < directing it left into the left-to-right version of the payload.
An error on the second line causes the final < to be shifted left and replaced with a > directing the flow right instead. The # (bridge) command has nothing to jump over, so the code just continues until it wraps around and reaches a ^ at the start of the line, directing it up to the first line, and then a > directing it right into the right-to-left payload.
Most errors on the first line just cause the final v commands to shift across by one, but that doesn't alter the main flow of the code. Deleting the first < is slightly different, though - in that case the execution path just flows directly into the left-to-right payload on the first line.
The other special case is the removal of the line break. When the code wraps around to the end of the line, in this case it's now the end of the what used to be the second line. When it encounters the # command from the right, this jumps over the > and thus continues directly into the right-to-left payload.
In case there's any doubt, I've also tested with the perl script and it confirmed that "0 failed out of 63".

Gol><>, score 0, 38 bytes
<<H"Hello, world!"/
H"Hello, world!" <

The language is released after the challenge.

!@#$%^&*()_+, score 2, 242 bytes
!!!!!!!!!!!!!! ^!!!!!!!!!!!!!ddddddddddddddllllllllllllllrrrrrrrrrrrrrrooooooooooooooWWWWWWWWWWWWWW              ,,,,,,,,,,,,,,oooooooooooooolllllllllllllllllllllllllllleeeeeeeeeeeeeeHHHHHHHHHHHHHH(((@%%%%%%%%%%%%%%))üü&& ^dlroW ,olleH((@)

Try it online!
Well, I give up.
I'm on a mobile phone, so I cannot put the null character there. If someone would be so kind to replace the !!_+ in the TIO link, I would appreciate it. The two weaknesses are the  ^ between the exclamation marks.
This is not particularly clever, and most of the characters are just padding. Contains two Unicode characters; the challenge specifications said remove one character, not one byte.
The HW is repeated 14 times to be immune to % removal or removal in the HW string. !@#$%^&*()_+ allow unmatched ( but not unmatched ) when parsing, so the left parenthesis is repeated one more time than the right parenthesis.
What if the @ was removed? We can know from the stack size if 13 characters went missing, so we use stack indexing to exit by error if the stack size is too short. Each character is doubled to make sure the test is performed. If the test passed, it means the @ is the removed character, and none of the characters after the test was removed, so you can put a normal Hello, World program there.
I made this one bored afternoon at school with a pencil, but I did not have time to debug and post this until now. Bugs might still be present.

><>, score 0, 40 bytes
||o<"Hello, world!"\
|o<"Hello, world!"\

Try it online!
This is a port of my klein 000 answer.  It's a little more costly to output in ><>, but overall this is nicely competitive.  This halts by triggering an error, as suggested by JoKing.  For my original version that exits properly:
><>, score 0, 54 bytes
||>!;!?o!l<"Hello, world!"\
|>!;!?o!l<"Hello, world!"\

Try it online!

Vyxal, 9 bytes, score 0
kH0kH ∴¡¡

Try it Online!
Explanation :
# unaltered
kH        # push 'Hello, World!'  => [ Hello, World! ]
  0       # push 0                => [ Hello, World! , 0 ]
   kH     # push 'Hello, World!'  => [ Hello, World! , 0 , Hello, World! ]
      ∴   # max(a,b)              => [ Hello, World! , Hello, World! ]
       ¡¡ # sentence case (twice) => [ Hello, World! , Hello, world! ]
          # implicit output

# 1st char missing
H         # convert to hex        => [ 0 ]
 0        # Push 0                => [ 0 , 0 ]
  kH      # push 'Hello, World!'  => [ 0 , 0 , Hello, World! ]
     ∴¡¡  # max and sentence case => [ 0 , Hello, world! ]

# 2nd char missing
k0        # do nothing            => [ ]
  kH      # push 'Hello, World!'  => [ Hello, World! ]
     ∴¡¡  # max and sentence case => [ Hello, world! ]

# 3nd char missing
kH        # push 'Hello, World!'  => [ Hello, World! ]
  kH      # push 'Hello, World!'  => [ Hello, World! , Hello, World! ]
     ∴¡¡  # max and sentence case => [ Hello, world! ]

# 4th char missing
kH        # push 'Hello, World!'  => [ Hello, World! ]
  0       # push 0                => [ Hello, World! , 0 ]
   H      # convert to hex        => [ Hello, World! , 0 ]
     ∴¡¡  # max and sentence case => [ Hello, world! ]

# 5th char missing
kH        # push 'Hello, World!'  => [ Hello, World! ]
  0       # push 0                => [ Hello, World! , 0 ]
   k      # do nothing            => [ Hello, World! , 0 ]
     ∴¡¡  # max and sentence case => [ Hello, world! ]

# 6th same as unaltered

# 7th char missing
kH        # push 'Hello, World!'  => [ Hello, World! ]
  0       # push 0                => [ Hello, World! , 0 ]
   kH     # push 'Hello, World!'  => [ Hello, World! , 0 , Hello, World! ]
      ¡¡  # sentence case (twice) => [ Hello, World! , 0 , Hello, world! ]

# 8th or 9th char missing same as unaltered but sentence case only once

Fun fact, the char 0 can be replaced by any of $123456789₀₄₆₇₈Ȯ (and maybe some more) and the program is still a solution

R REPL*, 204 137 130 99 bytes, score 0
*(or any other R environment in which errors do not halt execution of subsequent commands: entering the program into the R interactive console works fine; alternatively (and as simulated in the TIO link) we can use the command-line option -e 'options(error=function(){})' (which would then define the language as "R -e 'options(error=function(){})'").
a="Hello, world!"##"
b="Hello, world!"##"
T=cat(`if`(exists("a")&&(nchar(a)==13),a,b));
if(T)cat(a)

Try it online!
Explanation:
Lines 1 & 2:
At least one of a or b should contain the text "Hello, world!" even if any character is deleted:

any deletion inside one quoted string shouldn't affect the other;
deletion of any of a=" will simply error without assigning a (or the same for b);
deletion of the second " will assign ```"Hello, world!##"```` to that string without affecting the other;
deletion of any of ##" has no effect;
deletion of the first newline will convert the following line into a comment and prevent assignment of b, without affecting a;
deletion of the second newline will convert the following line into a comment, without affecting either a or b (see line 3 below).

Line 3:
Aims to output one of a or b that exists and is the correct, 13-character "Hello, world!" string, or to error.
If it succeeds without erroring, the variable T is re-assigned to NULL (instead of its default value of TRUE).

deletion of any of T=, cat(),  `if`(,,b),  exists("a"), or nchar(a)== will error and fail to re-assign T.
deletion of any of 13 will select b instead of a to output; however, since this was the single deletion made, b is intact so this is Ok.
deletion of either ; or the third newline has no effect;
if the entire line is commented-out (by deletion of the second newline), it will not re-assign T.

Line 4:
If T is not NULL, then either an error has occurred (so the deletion was on line 3), or the second newline was deleted (so line 3 was commented-out).
In either case a should be the correct "Hello, world!" string, and nothing has yet been output, so we can safely output a.
Any deletion to this line should cause an error so that it doesn't output anything to stdout.

deletion of any of if(T) will error;
if T is NULL (so no error has yet occurred, and line 3 ran Ok), if(T) will error and this line will not output anything.
if T is still TRUE, then the single deletion already happened on another line, so we shouldn't need to worry about further deletions on this line.

MSDOS .COM, 51 bytes
00000000: eb18 18e8 0e00 4865 6c6c 6f2c 2057 6f72  ......Hello, Wor
00000010: 6c64 2124 b409 5acd 21c3 ebe7 e7b4 09ba  ld!$..Z.!.......
00000020: 2401 cd21 c348 656c 6c6f 2c20 576f 726c  $..!.Hello, Worl
00000030: 6421 24                                  d!$

    org 100h
    jmp .L2       ; SBB [BX+SI],BL if 1B removed
    db  .L2-$
.L0:call .L1
    db  "Hello, World!$"
.L1:mov ah, 9
    pop dx
    int 0x21
    ret
    db 0x11A-$ dup ? ; Actually none
.L2:jmp .L0       ; OUT E7, AX if 1B removed
    db .L0-$
    mov ah, 9
    mov dx, .L3-1 ; If it goes this way
    int 0x21      ; then 1 byte missing
    ret
.L3:db  "Hello, World!$"

gastropner suggests me do this
Collection of all programs with at most 1 byte removed in base64, confirmed
/Td6WFoAAATm1rRGAgAhARYAAAB0L+Wj4NX/AgVdACCLvBunjDQGwDuQeO2LBXimvB64zX4rztWL/i5Av150lJoeOSHW05X92oDP65IyBlb67MdiB3tAoqaEfRm3gzRuAXuwZhHgJsxZs0QpbeW6y0O+IUD3a6M3dV4n+YbVbdSu8MWbR9qg76ck36pl5sy9kzvUv9hcAczs00fsjGJS10OdrU6sDxTIOpMk13Z+WxChUK04r19vxvShWbKDb2pZawGxFVJ2Sks0JvZNOJExJQx8l0fa6sSqQtOJR4oWVmOf/lePTc/ZDE3pz2nVPYgxQeLN31fGGeoso1JwWvr3sDyL6v49m2ZR9y0fVwc/nactXKMTJLzKmxSuwq6azF2f6ddf+0OL5fgVgccV5M1P9lQ6WV+sp80RWo1ceO8OJWmvIGM3ZTcl7ZcYqWUxQyvqAp0aL9ZDvXJhnybKXDSKOhzjtLcKM/07aCsVmBe5hZwllSnjiAOwKeH/8KyP/Uxfwl0xO5zyWshxWa0Znji7HAQH9ais1UHVHAP9P9EQF+g0rU5WehexGtrRg74lGF9/hUSepXTZZAZLpMURXJC9zlhkAj7xKsL3Lmm/yNZyETgDiZMB2kD/k3js5jDnmAZjU15KkYHpuNVsjsFcP6ERVipU4b3WRGCjsMgzbTcN1naVFUNOWXLGcvdY2Y5o2Wf2+TMTD275J51Db4aNUX8rIRd3NUwAAAAASNVP9/NyC/kAAaEEgKwDAKrxg/KxxGf7AgAAAAAEWVo=

E7 isn't listed here so is it a nop?

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


text:
Display a bézier curve in the browser
The goal is to display a bézier curve in any classical browser (except maybe old IE versions, because... are they really browsers?) client side.
Rules:

You must provide one or more files (or their content). These files must contain all the code.
The code must work offline, no imports from a remote source. No installation should be needed on the computer (except a vanilla browser).
This is a Javascript contest. A very simple way would be to use SVG files that can be read with browsers. Don't!
No need to pass the W3C validator test, you can omit the doctype and the surrounding tags (html, head, body, ...)
The input can take any form: GET, POST, written in the code, etc.
The quadratic bézier must be implemented. (2nd degree bézier: starting point, ending point and 1 intermediate point). It means 3 points (= 6 coordinates) must be given in whatever format you prefer (XML, JSON, ...).
If you don't know what a bézier curve is, you should! Check on Wikipedia to know about it.

Scoring:

In his great kindness, OP offers you 10'000 point just by posting a valid answer.
The sum of the sizes of the files in bytes will give negative points. 1 byte = -1 point*.
Implementing the cubic bézier curve instead of the quadratic multiplies your points by 120%.
Implementing n-th degree bézier curve instead of the quadratic or cubic double your points. (Which means implementing both the cubic and the n-th degree is useless, pointless and very dumb).
Implementing filled bézier (with inner color) will double your points again.
There is no limit in the number of files or libraries you use, just remember adding jQuery, for example, already gives you about -26'000 points.

The contestant with the highest score wins. (duh!)
*A 10'000 characters answer gives you 0 points.

I'm not sure I get the question. Is it allowed to generate some SVG ? Is it allowed to use canvas (in which a native bezier api is available) ?

Good question. Of course, you can't use any built-in bézier whatsoever (SVG, canvas bézier, ...) you must implement the bézier. After that, you can use canvas to display it, if you want.

This challenge is really quite old, and the site has changed quite a bit in the meantime.  Aside from stylistic changes in how challenges are written, this just doesn't adequately describe the task required.  So I'm closing this as unclear as a way to tidy this up.  If anyone including the OP wants to fix this challenge I would recommend opening a new challenge, maybe use the sandbox if you need to.

Haha! I didn't even remember that challenge. I guess you took a good action by closing it and your reasons seam… well… reasonnable.

39240 points (190 chars)
<script>P='<svg><path stroke=red d=M'+X[n]+','+Y[n]
for(t=N=99;t--;P+='L'+x+','+y)for(x=y=i=0,z=Math.pow(1-t/N,n);i<=n;z*=t/(N-t)*(n-i)/++i)x+=z*X[i],y+=z*Y[i]
document.write(P+'>')</script>

Input is supplied in three variables: X and Y hold the coordinates, and n holds the degree of the polynomial. If more coordinates are supplied than are needed, the surplus ones are ignored. The line is stroked in red and filled in black.
This example draws substantially from the existing ones, but with an improvement of 40% in character count over the current best character count I think it's worth a separate answer.
Demo: http://jsfiddle.net/MBCGJ/7/
This is stretching the flexibility of the rules too far IMO, but three characters can be saved by making N a "fineness" parameter which must be initialised along with the input coordinates and degree.
Also, Chrome at least doesn't care about closing the path element at all, which allows saving the 4 chars +'>', so if that works cross-platform and the fineness parameter abuse is allowed this can go down to 183 chars.

The preferred way of rendering Bézier curves is, of course, adaptive subdivision using the de Casteljau algorithm. Unfortunately this uses more characters because it's necessary to do a test to decide whether to subdivide and then to do a moderate amount of work for the subdivision itself. Currently I'm at 371 chars, although I think this could be reduced with an explicit stack.
<script>P='<svg><path stroke=red d=M'+X[0]+','+Y[0]
function Z(A,B,E,F){function d(p,q){return(t=A[p]-A[q])*t+(t=B[p]-B[q])*t}for(e=i=0;++i<n;e|=b+c-d(n,0)+Math.sqrt(3.9*b*c)>0)b=d(i,0),c=d(n,i)
for(E=[],F=[i=-1];e?i++<n||Z(E,F)|Z(A,B):0;)for(E[i]=A[0],F[i]=B[j=0];j<n-i;B[j]=(B[j]+B[++j])/2)A[j]=(A[j]+A[j+1])/2
P+='L'+A[n]+','+B[n]}Z(X,Y)
document.write(P+'>')</script>

The figure 3.9 in the middle there is the quality parameter, which must be less than 4 to avoid infinite recursion. The closer it gets to 4, the better the quality.
http://jsfiddle.net/FrJLn/2/

38,716 points (321 chars)
<canvas id="c"></canvas><script>function c(n,k){return k<1||c(n-1,k-1)*n/k}function b(p,f){d=document.getElementById('c').getContext('2d')
for(t=0;t<1.009;t+=0.01){n=p.length-1
x=y=i=0
e=Math.pow
for(;i<=n;z=c(n,i)*e(1-t,n-i)*e(t,i),x+=z*p[i][0],y+=z*p[i][1],i++);d.lineTo(x,y)}d.stroke()
d.fillStyle=f
d.fill()}</script>

Given an array of points and the desired fill colour, the b function draws an n-th degree bézier curve onto the canvas. It uses the binomial theorem to calculate the location of 101 different points along the curve, and then joins them together with straight lines.
Example

ah man function c(n,k){return k<1||c(n-1,k-1)*n/k} is clever. Annoyed with myself for not thinking of that

I actually copied the idea from one of my previous golfs. I was well into writing it the factorial way before I realised I had done it before :)

Don't reinvent the wheel, even in golfing! :)

Why make it a function? You can save 32 chars (at least) by inlining it.

I don't know how to save that many chars without copying other parts of your answer. I'll just leave mine as it is since you've already done it better than I'd be able to (and I've had enough of bézier curves) :P

What I had in mind was to initialise B=1 and then each time round the loop B*=(n-i)/++i, using a different property of binomials. Then I started looking at the rest of the Bernstein polynomial and inlined the powers too.

716 Chars - 37136 points
<script>function f(n){return n<1||n*f(n-1)}function c(n,k){return f(n)/(f(k)*f(n-k))}U=")*Math.pow(",G="createElementNS",$="setAttribute",d=document,w="appendChild",y=["",j=""];window.onload=function(){v=d.getElementById("s");q=prompt().split(" ");e=q.length-1;for(z=0;z<=e;z++){q[z]=q[z].split(",");p=q[z]={x:q[z][0],y:q[z][1]};_=d[G]("http://www.w3.org/2000/svg","circle");_[$]("cx",p.x);_[$]("cy",p.y);_[$]("r",5);_[$]("fill","red");v[w](_);for(u=0;u<2;u++)y[u]+="(c("+e+","+z+U+"1-t,"+(e-z)+U+"t,"+z+")*q["+z+"]."+"xy"[u]+")"+(z^e?"+":"")}for(t=0;t<=1.01;t+=0.01)j+=eval(y[0])+","+eval(y[1])+" ";l=d[G]("http://www.w3.org/2000/svg","polyline");l[$]("points",j);l[$]("stroke","red");v[w](l)}</script><svg id="s"/>

Try it in this JFiddle
You will be prompted to provide your points in the following format:
x1,y1 x2,y2 x3,y3 x4,y4 x5,y5
Check list

n-degree handled
beziers are filled
no external libraries
plots control points

An example output of a 34th degree curve (non filled):

441 Chars - 38236 points
This doesn't plot the control points and it, shamelessly, uses grc's n-choose-k function. so it's not my real submission
<script>function c(n,k){return k<1||c(n-1,k-1)*n/k}V=Math.pow,$="setAttribute",d=document,window.onload=function(){A=prompt().split(" ");e=A.length-1,j="";for(t=0;t<=1.01;t+=0.01){x=y=0;for(z=0;z<=e;z++)p=A[z].split(","),f=c(e,z)*V(1-t,e-z)*V(t,z),x+=f*p[0],y+=f*p[1];j+=x+","+y+" "}l=d.createElementNS("http://www.w3.org/2000/svg","polyline");l[$]("points",j);l[$]("stroke","red");d.getElementById("s").appendChild(l)}</script><svg id="s"/>

186 bytes (39256 points?)
<script>function m(a,j,l){return l?m(a,j,--l)*(1-i)+m(a,j+1,l)*i:a[j]}P='<svg><path stroke=red d='
for(i=0;i<=1;i+=1/64)P+='ML'[i&&1]+m(X,0,n)+','+m(Y,0,n)
document.write(P+'>')</script>

Usage is exactly the same as Peter Taylor's solution. Also credits to Peter for the svg path approach (I wanted to use a canvas but it turns out to be longer). I would normally delete the "stroke=red" part (to get 175 bytes) but I kept it for having a fair comparison.

I think the answers so far assume that stroke=red is necessary to qualify for the filled curve bonus.

@PeterTaylor I assume it's not necessary - it's already filled with black

The question is whether "(with inner color)" implies that the inner colour must be different to the stroke colour. Although I should test whether fill=red works, since it's definitely shorter...