[Question]
  [
Let's define a *pristine program* as a program that does not have any errors itself but will error if you modify it by removing any contiguous substring of \$N\$ characters, where \$1 \le N < \text{program length}\$.
For example, the three character Python 2 program
```
`8`
```
is a pristine program ([thanks, Sp](https://chat.stackexchange.com/transcript/message/25274283#25274283)) because all the programs resulting from removing substrings of length 1 cause errors (syntax errors in fact, but any type of error will do):
```
8`
``
`8
```
and also all the programs resulting from removing substrings of length 2 cause errors:
```
`
`
```
If, for example, ``8` had been a non-erroring program then ``8`` would not be pristine because **all** the results of substring removal must error.
Your task in this challenge is to write the shortest pristine program possible that takes no input but outputs any one of the following five words:
```
world
earth
globe
planet
sphere
```
Which word you choose is entirely up to you. The sole word plus an optional trailing newline should be printed to stdout (or your language's closest alternative). The shortest program in bytes wins.
**Notes:**
* A standalone program is required, not a function.
* The words are case sensitive; outputting `World` or `EARTH` is not allowed.
* Compiler warnings do not count as errors.
* The erroring subprograms can take input or give output or do anything else as long as they always eventually error.
Here's a stack snippet that will list what programs need to error given a potentially pristine program:
```
<script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>function go() { var s = $('#i').val(), e = []; for (var i = 1; i < s.length; i++) { for (var j = 0; j <= s.length - i; j++) { e.push(s.substring(0, j) + s.substring(j + i)); } } $('#o').val(e.join('\n---\n')); }</script>Program:<br><textarea id='i' rows='16' cols='80'>`8`</textarea><br><button onclick='go()' type='button'>Go</button><br><br>Programs that should error: (--- separated)<br><textarea id='o' rows='16' cols='80'></textarea><br>
```
  
[Answer]
# [Rail](https://esolangs.org/wiki/Rail), 24 bytes
```
$'main'    #
 -[world]o/
```
I *think* this works. And it's both short and readable (as far as Rail goes).
* If the removed substring includes any part of `$'main'` we get `Internal Error: Crash: No 'main' function found`.
* If the removed substring includes the `#`, there is no way for the program to exit cleanly, so it will always terminate with `Crash: No valid move`. I believe that it's not possible to delete a substring such that the track forms a valid (infinite) loop.
* If the removed substring is in front of the `#`, it will be disconnected from the end of the track, so the train will crash (with the same error as above).
* If the removed substring is after the `#`, it will also disconnect the `#` from the end of the track (and potentially even the beginning of the track from the entry point `$`). So again the same error.
As for the actual program: every Rail program needs to have a `$'main'` (or a longer variant, but we're golfing here) as an entry point into the function and the train starts on the `$` going South-East. Everything on that first line can be part of the track though, so removing the `'main'` the track is:
```
$          #
 -[world]o/
```
The `-` and `/` are simply pieces of rail which we need to let the train take those 45° turns.
`[world]` pushes the string `world` and `o` prints it. `#` marks the end of the track - the only way to safely terminate a Rail program.
Interestingly, this solution is *only* possible because Rail allows the tracks to go through the `main` line - if that wasn't possible `#` would be after the first newline and the code could always be shortened to
```
$'main'
 #
```
which is a valid program that doesn't do anything. (Non-space characters between `'` and `#` wouldn't affect that.)
Also quite interesting: if I had just *golfed* the task printing `world` it wouldn't have been much shorter or simpler:
```
$'main'
 -[world]o#
```
[Answer]
# [Funciton](http://esolangs.org/wiki/Funciton) (~~186~~ 136 bytes in UTF-16)
```
╔══════════════╗
║19342823075080╟
║88037380718711║
╚══════════════╝
```
This program prints “world”.
Most substrings you remove from this will stop it from being a complete box, which the parser will complain about. The only possible removals that leave a complete box are:
```
 ╔══════════════╗
|║19342823075080╟  (remove this whole line)
|║88037380718711║
 ╚══════════════╝
 ╔══════════════╗
 ║|19342823075080╟   ← substring starts at | here
 ║|88037380718711║   ← substring ends at | here
 ╚══════════════╝
... ↕ or anything in between these that removes a whole line’s worth ↕ ...
 ╔══════════════╗
 ║19342823075080|╟   ← substring starts at | here
 ║88037380718711|║   ← substring ends at | here
 ╚══════════════╝
 ╔══════════════╗
|║19342823075080╟
 ║88037380718711║  (both lines entirely)
|╚══════════════╝
 ╔══════════════╗
 ║19342823075080╟
|║88037380718711║  (remove this whole line)
|╚══════════════╝
```
Most of these remove the dangling end at the top right of the box, which is the output connector. Without this loose end, the box is just a comment:
```
╔══════════════╗
║88037380718711║
╚══════════════╝
```
This is no longer a valid program because the parser expects a program with exactly one output:
> 
> Error: Source files do not contain a program (program must have an output).
> 
> 
> 
The only possibility that leaves an output connector is the last one of the above, which leaves this:
```
╔══════════════╗
║19342823075080╟
╚══════════════╝
```
However, this number does not encode a valid Unicode string in Funciton’s esoteric UTF-21. Try to run this, you get:
> 
> Unhandled Exception: System.ArgumentOutOfRangeException: A valid UTF32 value is between 0x000000 and 0x10ffff, inclusive, and should not include surrogate codepoint values (0x00d800 ~ 0x00dfff).
> 
> 
> 
Therefore, this program is pristine.
[Answer]
## Visual C++ - 96 95 bytes
```
#include<iostream>
#define I(a,b)a<<b
int main()I({std::cout,I('w',I('o',I('r',I('l','d';)))))}
```
**Properties:**
1. You can't remove any part of `int main()` without a compile error.
2. You can't remove the modify the macros expansion AT ALL, removing `a` at all means `main()` never gets `{`, removing `b` at all means our line doesn't end in a `;`, removing `<` means `std::cout<'w'` causes an error, and removing `<<` causes `std::cout'w'`, `'w''o'`, etc.
3. You can't remove parameters from the macro definition or invocation, the only valid names for the definition would be `I(a)`,`I(b)` which never match and `I` which expands to before `(`; on the other hand using `I(,` causes `<<<<`, and `,)` drops the semi-colon (barring any other errors).
4. You can't remove part of all of `std::cout` without running into a leading `<<`, and therefore cannot remove any of `#include<iostream>` in the beginning without a compile error.
5. You can't remove any part of a single character, `''` has an empty character error and `'w,`, etc... try to making everything into one character.
6. You can't remove the left/right side of a macro without leaving too many `)` or `(` on the other side, e.g. you cannot do things like `I('w',I('r'`.
Compiles online using [Visual C++](http://webcompiler.cloudapp.net/).
Once again this not an exhaustive proof. If you think you can get it too work without section be sure to let me know.
*Previous versions used a considerably different approach and was proved to not be pristine so I've removed those scores.*
---
**Verification:**
The following program has confirmed this version is pristine using the `cl` compiler from Visual C++ 2010. Wished I had bothered to write this sooner:
```
#include <fstream>
#include <iostream>
char *S = "#include<iostream>\n#define I(a,b)a<<b\nint main()I({std::cout,I('w',I('o',I('r',I('l','d';)))))}";
//uncomment to print source code before compile
// #define prints
int main(){
   for(int i=0; i<95; i++)
      for(int j=i; j<95; j++){
         std::fstream fs;
         fs.open ("tmptst.cpp",std::fstream::out);
         for(int k=0; k<95; k++)
         if(k<i || k>j){
            fs << S[k];
            #ifdef prints
               std::cout<<S[k];
            #endif
         }
         fs.close();
         #ifdef prints
            std::cout<<'\n';
         #endif
         //Compile and surpress/pipe all output
         //if it doesn't compile we get a nonzero errorlevel (i.e.true) from system.
         if(!system("cl -nologo tmptst.cpp >x"))
            return 0;
      }
      std::cout<<"PRISTINE!";
}
```
[Answer]
# Python 3, ~~79~~ 33
```
if 5-open(1,'w').write('world'):a
```
`open(1,'w')` opens standard output, then we print the string. `write` returns the number of characters written. This is used to harden against substring removal: Removing part of the string causes something other than 5 to be returned, and 5 minus that value then evaluates to true. But that causes the `if`-body to be executed and `a` is undefined. 
This is based on Anders Kaseorg's clever pristine quine [here](https://codegolf.stackexchange.com/a/132990/36695).
As only a single statement needs to be verified this is much shorter than the old solution, but also less general.
### Old solution:
```
try:
 q="print('world');r=None"
 if exec('e=q')==eval(q[17:]):exec(e)
finally:r
```
To verify that it really is a pristine program:
```
w=r'''try:
 q="print('world');r=None"
 if exec('e=q')==eval(q[17:]):exec(e)
finally:r'''
exec(w)
for j in range(1,len(w)):
 for i in range(len(w)+1-j):
  e=w[:i]+w[i+j:]
  try:exec(e,{});print('WORKED',e)
  except:pass
```
Some key points:
* Every executed statement could be deleted. Verifying that `q` has been executed requires a statement outside of `q`. The `try` solves that nicely, by requiring at least two statements, neither of which can be deleted fully.
* Verifying that `q` has executed happens by evaluating `r` at the end.
* Verifying that `q` was not modified is achieved by `eval(q[17:])`, which has to evaluate to `None` for `q` to be executed.
* The `if` condition is a bit tricky to get right. To ensure that it was evaluated it has the nice side effect of setting `e`, which is needed to set `r`. (This is the reason I used Python 3, `expr` as a function does wonders for expression-level side effects.)
[Answer]
# Haskell, 61
```
x=uncurry(:)
main=putStr$x('w',x('o',x('r',x('l',x('d',[])))))
```
Any type of error is OK? In that case:
# Haskell, 39
```
main=putStr$take 5$(++)"world"undefined
```
[Answer]
# JavaScript, ~~74~~ ~~73~~ 35 bytes
```
if((alert(a="world")?x:a)[4]!="d")x
```
It turns out the answer was much simpler than I thought...
## Explanation
```
if(
  (
    alert(a="world") // throws a is not defined if '="world"' is removed
        ?x           // throws x is not defined if 'alert' or '(a="world")' is removed
        :a           // throws a is not defined if 'a="world"' or 'a=' is removed
  )
  [4]!="d"           // if "world" is altered fifth character will not be "d"
                     // if 'd' is removed it will compare "world"[4] ("d") with ""
                     // if '[4]' is removed it will compare "world" with "d"
                     // if '(alert(a="world")?x:a)' is removed it will compare [4] with "d"
                     // if '?x:a' is removed [4] on alert result (undefined[4]) will error
                     // if '[4]!="d"' is removed the if will evaluate "world" (true)
                     // if '!', '!="d"' or '(alert...[4]!=' is removed the if will
                     //     evaluate "d" (true)
)x                   // throws x is not defined if reached
// any other combination of removing substrings results in a syntax error
```
[Answer]
# [Funciton](http://esolangs.org/wiki/Funciton), ~~143~~ ~~142~~ 136 bytes
Score is in UTF-8 as usual, as UTF-16 would be two bytes larger (due to the BOM).
```
╔══════════╗
║1934282307║╔╗
║5080880373╟╚╝
║80718711  ║
╚══════════╝
```
So, I've been contemplating a Funciton answer for a while and I figured it would be impossible, because you could always remove a full line and the code would still form a valid block. Then I talked to Timwi about it, and [he figured out](https://codegolf.stackexchange.com/revisions/63537/1) that you can just put the entire number in a single line, such that removing it would break the program for lack of an output connector.
But literals on a single line are notoriously expensive, both because of the larger character count *and* because of the larger number of non-ASCII characters. And his mention of an "empty comment" block got me thinking...
So I came up with this more efficient solution which uses an additional empty comment block which breaks when you try removing anything which would leave the literal block in tact:
* We can't possibly remove the third line, because then we'd remove the output connector.
* If we remove the second line, the comment block loses its top edge and breaks.
That leaves two options (thanks to [Steve](https://codegolf.stackexchange.com/users/46698/steve) for pointing that out):
* Remove the fourth line. That leaves both boxes in tact. However, when the resulting integer `19342823075080880373` is decoded, the corresponding string would contain the code point `0x18D53B` which is not a valid Unicode character, `System.Char.ConvertFromUtf32` crashes with an `ArgumentOutOfRangeException`.
* Remove a full line starting after the top-right corner. Again, both boxes are left in tact, but the resulting integer `508088037380718711` would contain two invalid code points `0x1B0635` and `0x140077`, leading to the same exception.
Note that even without the empty comment block, removing the second line would lead to an invalid code point. But the comment block prevents that we're taking a line from *inside* the second line, to get an integer like `193428037380718711` for instance, which would not cause an error.
[Answer]
# Java 8, 301 bytes
Because every question needs a Java answer.
```
class C{static{System.out.print(((((w='w')))));System.out.print((((o='o'))));System.out.print(((r='r')));System.out.print((l='l'));System.out.print(d='d');e=(char)((f=1)/((g=8)-C.class.getDeclaredFields()[h=0].getModifiers()));}public static void main(String[]a){}static final char w,o,r,l,d,e,f,g,h;}
```
## Expanded
```
class C {
    static {
        System.out.print(((((w = 'w')))));
        System.out.print((((o = 'o'))));
        System.out.print(((r = 'r')));
        System.out.print((l = 'l'));
        System.out.print(d = 'd');
        e = (char) ((f = 1) / ((g = 8) - C.class.getDeclaredFields()[h = 0].getModifiers()));
    }
    public static void main(String[] a) { }
    static final char w, o, r, l, d, e, f, g, h;
}
```
## Explanation
* `public static main(String[]a){}` is required.
* If the field declarations are removed (or made non-static), the first static block can't find them.
* If the static block is removed (or made non-static), the fields aren't initialized.
### The hardest part:
* If the `final` keyword is removed, the second line evaluates to `1/(8-8)`, causing a `/ by zero` exception.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 17 bytes
```
e"ooooo7-c0pBhtra
```
[Try it online!](https://tio.run/##S8sszvj/P1UpHwTMdZMNCpwySooS//8HAA "><> – Try It Online")
Prints "earth".
The only way a `><>` program exits without an error is executing the `;` character, which is a problem as you can just remove all the characters before that, so that `;` is the first character executed. You can get around that by using the `p` command to modify the program to include `;` during execution instead. Removing any section of the code causes the `;` to never be produced causing errors via the invalid instructions `B`, `h` and `t`, stack underflow, and infinite loops making it eventually run out of memory. I only had to make sure that all the infinite loops kept filling up the stack.
All variants were tested using this python snippet:
```
code = 'e"ooooo7-c0pBhtra'
count = {"invalid":0, "underflow":0, "memory":0}
for l in range(1, len(code)):
    for x in range(0, len(code)-l+1):
        print(code[:x] + code[x+l:], "\t\t", end='')
        try:
            interp = Interpreter(code[:x]+code[x+l:])
            for _ in range(0,1000):
                interp.move()
            print(len(interp._stack), "< ", end='')
            interp2 = Interpreter(code[:x]+code[x+l:])
            for _ in range(0,2000):
                interp2.move()
            print(len(interp2._stack))
            count["memory"] += 1
        except Exception as e:
            print(e)
            if str(e) == "pop from empty list": count["underflow"] += 1
            else: count["invalid"] += 1
print(count) 
#don't judge me
```
added to (a slightly modified version of) the official [fish.py](https://gist.github.com/anonymous/6392418) interpreter by the creator of ><>. Out of 152 possible sub-programs, 92 errored from invalid instructions, 18 from stack underflow, and 42 from running out of memory.
Funny facts, the first version of this `e"ooooo6-c0pAhtra` had a couple of freak sub-programs that managed to use the put command to place a `[` which would clear the stack, in place of the invalid instruction `A`. Also, "earth" is the only one of the phrases that will work with this method, because the first letter, `e` is a valid instruction in `><>`. Otherwise the `"` command has to be placed at the front of the program, and a valid subprogram could be just `"` by itself.
[Answer]
# Ruby, 36
```
eval(*[(s="planet")[$>.write(s)^6]])
```
We assign `s="planet"`, then write that string to STDOUT. This returns the number of characters written. We xor that with 6, so that if anything other than 6 characters were written, we'll get a nonzero integer. Then we slice into `s` with that index. Only the 0th character of `s`, "p", is a valid code string (a no-op). We pass that to `eval`, using the `(*[argument])` syntax which is equivalent to just `(argument)` except that it's not valid outside of a method call.
Pristineness verified programmatically on Ruby 1.9.3 and 2.2
[Answer]
# C#, ~~128~~ ~~118~~ 101 bytes
Thought of abusing the contiguous substring rule.
**The Code**
```
class h{static void Main()=>System.Console.Write(new char[1
#if!i
*5]{'w','o','r','l','d'
#endif
});}
```
**Why It Works**
1. `class h` and `static void Main()` are required.
2. Removing any of the chars in `'w','o','r','l','d'` causes an error because the char array is initialized with length `1*5`.
3. You can't remove the contents inside Main() without violating the contiguous character rule as parts are separated by preprocs. (See below)
**Before Golfing and Separation**
```
class h
{
    static void Main() =>
        System.Console.Write(new char[1 * 5]{'w','o','r','l','d'});
}
```
**Verified With**
<https://ideone.com/wEdB54>
EDIT: 
* Saved some bytes by using `#if !x` instead of `#if x #else`.
* Used `=>` func syntax. `#if!x` instead of `#if !x`. Credits to @JohnBot.
* Due to `=>` func syntax, extra preproc condition can be removed.
[Answer]
## MATLAB, 37 36 33 bytes
```
feval(@disp,reshape('world',1,5))
```
Since I am not sure if we are allowed to also output *ans=*, I had to find some work-around to output in a proper way. Using *fprintf* by itself did not work, because no matter what I tried it simply refused to error. Using *disp* by itself was not an option, as it would only take 1 argument and that argument itself obviously would also execute without errors.
If it's no problem to also include *ans=* in the output, then MATLAB can be done with **20 bytes**:
```
reshape('world',1,5)
```
[Answer]
# Ruby, 34
```
eval(*[($>.write("world")-1).chr])
```
This has a few components:
`eval(*[` *expr* `])` is borrowed from [histocrat's answer](https://codegolf.stackexchange.com/a/63498/31388), and is pristine as well as verifying the return value of *expr* is a valid ruby program that doesn't error. `method(*arr)` is a ruby syntax that calls `method` with the values of `arr` as the arguments. The reason this is needed here is because it is *only* valid as parameters for a method, so that if `eval` is removed, `(*[expr])` is a syntax error. If *expr* is removed, `eval` complains about not having enough arguments
`$>.write("world")-1` cannot be mangled except for inside the string and the subtraction. `$>.write("world")` writes "world" to STDOUT and returns the number of characters written, then subtracts 1. Therefor if the program is un-mangled the value will be exactly **4**. If it is mangled (either the `-1` is removed or the string shortened) then it will return one of **-1,0,1,2,3, or 5**. Any other mangling results in a syntax error.
Calling `chr` on a number returns the character represented by that number. So, when called on the result of the above example, it errors on -1, and returns a single-character string otherwise.
I'm not actually sure why this is, but it seems that ruby interprets `\x04` as a whitespace character, which means the expression is valid (empty ruby programs do nothing). However, any of the other characters (`\x00` - `\x03` and `\x05`) result in `Invalid char '\x01' in expression`. I found this by simply iterating over possible math I could do to the number returned. Previously I had used 
```
$>.write("planet
")*16
```
where "planet" plus a newline was 7 chars, times 16 to get 112 for `p`, the only single-letter function in ruby defined by default. When given no arguments, it is effectively a no-op
---
Honorable mention: `$><<"%c"*5%%w(w o r l d)` is very close but not pristine. Removing `"%c"*5%` results in no errors. Mini-explanation:
`$>` is stdout, and `<<` is a function being called on it. `"%c"*5` generates the format string `"%c%c%c%c%c"`, which then then trys to be formatted (`%`) by an array: `%w(w o r l d)` which is a shorter version of `['w','o','r','l','d']`. If there are too few or too many elements in the array such that it does not match the format string, an error is thown. The achilles heel is that `"%c"*5`, and `%w(w o r l d)` can both exist independantly, and `$><<` only needs an argument of either. So there are a few different ways of mangling this program into non-erroring cousins.
---
Validated using this:
```
s = 'eval(*[($>.write("world")-1).chr])'
puts s.size
(1...s.length).each do |len| #how much to remove
  (0...len).each do |i| #where to remove from
    to_test = s.dup
    to_test.slice!(i,len)
    begin #Feels so backwards; I want it to error and I'm sad when it works.
      eval(to_test)
      puts to_test
      puts "WORKED :("
      exit
    rescue SyntaxError
      #Have to have a separate rescue since syntax errors
      #are not in the same category as most other errors
      #in ruby, and so are not caught by default with 
      #a plain rescue
    rescue
      #this is good
    end
  end
end
```
[Answer]
# [Python 3](https://docs.python.org/3/), 43 bytes
```
for[]in{5:[]}[open(1,"w").write("world")]:a
```
[Try it online!](https://tio.run/##K6gsycjPM/7/Py2/KDo2M6/a1Co6tjY6vyA1T8NQR6lcSVOvvCizJFVDqTy/KCdFSTPWKvH/fwA "Python 3 – Try It Online")
### How it works
To protect against substring deletions, we use `open(1,"w").write` instead of `print`. In Python 3, `write` returns the number of written characters, which we will verify is `5` to ensure that no part of the string was deleted. We do this by looking up the return value in the dictionary `{5:[]}`, and looping over the result with `for[]in…:a`, which will fail if we didn’t get an empty iterable or if the `for` statement is deleted.
[Answer]
# Perl 5.10+, ~~71~~ 63 bytes
```
(${open 0;@{\(read(0,$a,63)!=63?die:@_)};say"world"});{$a//die}
```
Prints `world` with a trailing newline. Run like this:
```
perl -M5.010 file
```
This relies on the byte count of the source code, so `file` must contain the above code and nothing else (no shebang, no trailing newline). Perl 5.10+ is required for `say` and the defined-or operator `//`.
---
It's incredibly difficult to make a pristine program with Perl, because:
* Any bareword identifier (e.g. `foo`, `a`, `_`) is a valid statement with `no strict 'subs';` (the default). This means the program can neither begin nor end with a letter, number, or underscore.
* As [tchrist explains](https://stackoverflow.com/a/4800711/176646), "Identifiers specified via symbolic dereferencing have **absolutely no restriction whatsoever** on their names." This means the program cannot begin with any of the sigils `$`, `@`, `%`, or `*`, since removing all but the first and last character would always leave a valid variable name.
* Many built-in functions (including most functions capable of producing output) work on `$_` by default, so calls will often work even if you remove the argument (e.g. `say"world"` vs. `say`).
## How it works
This solution was inspired by [Naouak's Node.js answer](https://codegolf.stackexchange.com/a/63525/31388), which checks its own length to make sure characters haven't been removed.
The program has two sections, one inside parentheses and the other inside a block:
```
(...);{...}
```
The first section reads the source file and dies if it is less than 63 characters long. The second section checks that the `read` executed successfully. If either section is removed (with or without the enclosing parentheses or curly braces), the other section will throw an exception.
Removing the middle or the left or right side of the program will unbalance the parentheses and/or curly braces, causing a syntax error.
If the first `die` is altered (to `d`, `e`, `di`, `de`, or `ie`, which are all valid identifiers), the length check becomes:
```
@{\(read(0,$a,63)!=63?di:@_)};
```
which evaluates to:
```
@{\'di'};
```
This takes a reference to a string and tries to dereference it as an array, producing an error:
```
Not an ARRAY reference
```
If any other statement is altered, the length check will fail and the program will die.
---
Verified pristine with the following program:
```
#!/usr/bin/perl
use strict;
use warnings;
use 5.010;
use File::Temp;
use List::MoreUtils qw(uniq);
sub delete_substr {
    my ($str, $offset, $len) = @_;
    my $tmp = $str;
    substr($tmp, $offset, $len) = '';
    return $tmp;
}
sub generate_subprograms {
    my ($source) = @_;
    my $tot_len = length $source;
    my @subprograms;                                             
    
    foreach my $len (1 .. $tot_len - 1) { 
        foreach my $offset (0 .. $tot_len - $len) {
            push @subprograms, delete_substr($source, $offset, $len);
        }                                                        
    }                                                            
                                                                 
    return uniq @subprograms;                                    
}                                                                
                                                                 
chomp(my $source = <DATA>);                                                                                                       
my $temp = File::Temp->new;                                                                                        
                                                                 
foreach my $subprogram ( generate_subprograms($source) ) {       
    print $temp $subprogram;
    my $ret = system(qq{/usr/bin/perl -M5.010 $temp > /dev/null 2>&1});
    say($subprogram), last if $ret == 0;
    truncate $temp, 0;
    seek $temp, 0, 0;
}
__DATA__
(${open 0;@{\(read(0,$a,63)!=63?die:@_)};say"world"});{$a//die}
```
[Answer]
# Ruby + coreutils, ~~33~~ ~~27~~ 26 bytes
```
`base#{$>.write"world
"}4`
```
[Try it online!](https://tio.run/##KypNqvz/PyEpsThVuVrFTq@8KLMkVak8vygnhUup1iTh/38A "Ruby – Try It Online")
Backticks in ruby execute the command inside them and return whatever the program put into STDOUT as a string. The `#{expr}` syntax allows embedding of expressions in strings and backticks. This program could be rewritten (non-pristinely) as:
```
system("base" + (STDOUT.write("world\n")).to_s + "4")
```
`IO#write` returns the number of bytes written, so if the string is shortened then it won't be the right number. `#{}` embedding automatically makes the number into a string. If some piece is removed, and it doesn't result in a syntax error, the wrong command will be run. If part of `"world"` is removed than one of `base04` through `base54` will try to run.
The newline, whether in or out of the string, is required. Otherwise the first 5 characters(``base`) can be removed, making the whole line a comment. Also there must be one or more characters between the first backtick and `#`, otherwise the `{` can get removed to make the whole thing a *shell* comment.
---
```
exec(*[(s="ec%co earth")%s[10]])
```
`exec` Replaces the current ruby process with the command specified. See [my other answer](https://codegolf.stackexchange.com/a/63625/46718) for an explanation of the `meth(*[])` syntax and the neccesity of it.
`(s="ec%co earth")` assigns the string "ec%co earth" to the variable `s`. Assignments return what was assigned, so the string is also returned.
`"format string %d" % 5` is syntactic sugar for `sprintf("format string %d",5)`, however spaces around the `%` are not neccesary.
`s[10]` gets the character in the string at index 10. When un-mangled, this character is "h", the last letter in the string. However, removing any characters in the string means the string is shorter, so there is no character at index 10, so `s[10]` returns `nil`, and `"%c" % nil` causes an error.
if `%s[10]` is removed, then ruby tries to run the command `ec%co earth` which doesn't work.
Changing `10` to `1` or `0` also results in an unknown command (either `eceo` or `ecco`). Removing it entirely is technically not a syntax error since it calls the method `#[]` on the string, but then it complains about not enough arguments.
---
A note on solving this in general: You must have some wrapper that verifies the code inside in an abstract sense while being pristine itself. For example, a program with division at the end (`blablabla/somevar`) will never work because a division can always be removed(`blablabla`). These are some such wrappers I've used so far:
* `eval(*[` code `])` used by histocrat and in my first answer. Validates that the output is a valid ruby program
* `exec(*[` code `])` used above, validates that the response is a valid command
* ``#{` code `}``
The backtick syntax also runs a command (and therefor validates that it's a valid one), however STDOUT is captured as a string instead of being output as the parent process' (Ruby's) STDOUT. ~~Due to this I was not able to use it for this answer,~~ EDIT: I made it work. Limitations outlined above.
Edit: Thanks to @histocrat for pointing out some flaws
[Answer]
# Javascript(Node.js), ~~93~~ 95 bytes
```
if(l=arguments.callee.toString().length,l!=158)throw l;console.log("world");if(g=l!=158)throw g
```
Check it's own size twice so if any chars is missing an error is thrown.
The length is 156 because Node.js prepends `function (exports, require, module, __filename, __dirname) {` to the code on runtime.
Thanks Martin Büttner for pointing out an error. Fixed now.
[Answer]
# [C (gcc)](https://gcc.gnu.org/) (Linux,`-Werror=undef`), 66 bytes
```
main(a){a
=
1
/
(puts("world")/
6);
#if(7^__LINE__)
#else
}
#endif
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPI1GzOpHLlsuQS59Lo6C0pFhDqTy/KCdFSVOfy0zTmks5M03DPC4@3sfTzzU@XpNLOTWnOJWrFkjnpWSm/f//LzktJzG9@L9ueGpRUX6RbWleSmoaAA "C (gcc) – Try It Online")
Great challenge! This was deceptively hard, but I'm pretty sure I have a valid program now!
Uses a preprocessor command so that no newlines can be removed, since the closing bracket to `main` is included only if `__LINE__==6`. It also keeps you from just clearing out `main` entirely, since that leaves `#endif` floating (so it is important that `#endif` is outside of `main`).
I used `#else` because I've become fairly convinced there's no version of `__LINE__==6` that can't have a substring removed and still be true, since both `6` and `__LINE__` by themselves are truthy. It also uses `-Werror=undef` so that something like `#ifdef(LINE__)` doesn't evaluate to false, but is an error.
With gcc (on Linux, at least), `puts` returns the number of characters printed (including the trailing newline), so removing any part of the string makes `puts("...")/6` return `0`, so that `1/0` causes a floating point exception. Note that this exception isn't caused unless `1/0` is assigned to something, so the `a=` is required.
No other part of any line can be removed without creating an error, usually a syntax error or a linking error.
As a bonus, this gives an 86 byte solution for C++ pretty trivially, just add `#include <cstdio>` and declare `a` as an `int`. [Try it online! (C++)](https://tio.run/##Sy4o0E1PTv7/XzkzLzmnNCVVwSa5uCQlM9@OKzcxM09Dszozr0QhkcuWy1CfS6OgtKRYQ6k8vygnRUlTn8tM05pLOTNNwzwuPt7H0881Pl6TSzk1pziVqxZI56Vkpv3/DwA)
[Answer]
## PowerShell, (97 bytes + 5 for program name) = 102 Bytes
```
"$(try{if(($a=(gc .\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a
```
Checks itself before it wrecks itself ... twice.
Expects to be saved as `c.ps1` and executed from the local directory as such:  
`PS C:\Tools\Scripts\Golfing\> .\c.ps1`.
The alias `gc` is short for `Get-Content` and is similar-ish to a `cat` reading a file (in this case, our execution path `.\c.ps1`). We get the `.Length` of the file, set it to `$a`, and check whether it's not equal to 97 with `-eq97`. If it is equal (i.e., the program has not been modified), we print with `"world"`, and execute invalid command `a`. This forces the `catch` to take effect, which allows us to check ourselves again. This time, if our code is not equal to 97, we throw an invalid command so our program has errored and printed error text to the output. We then `clear()` the error and `exit` normally.
It's obvious that if either `if` statement is tampered with, the other will have an error. If any portion of `"world";` is tampered with, the first `if` will cause an error. Since it has to be contiguous, we can't remove both `if` statements. Strings in the middle will result in mismatched parentheses, or will result in the second `{a}` getting executed. The `try`/`catch` is to catch the error from the first `if` statement so we can properly clear it. The outer `"$( )"` prevent strings from either end getting snipped. The final `;a` is to prevent portions of the middle getting snipped that would result in valid programs (e.g., `"it}a)";a`, which will print `it}a)` and then error).
There are several special circumstances:
* If the `gc`, `gc<space>` or `gc .\` are removed, the program will eventually error out with some flavor of an out of memory error (due to repeated self-execution calls) and likely crash the shell (and maybe the computer). Not tested.
* If the `<space>.\c.ps1` or `.\c.ps1` are removed, the program will stop and prompt for user input. No matter what the user enters, the program will still error since the size counts will be wrong.
* If a substring starting at the `$` and ending before the last `"` is snipped, the program will output whatever remains and then error because `a` is not valid.
Verified with the following:
```
$x='"$(try{if(($a=(gc .\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'
$yy='"$(try{if(($a=( .\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'
$yyy='"$(try{if(($a=(.\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'
$yyyy='"$(try{if(($a=(c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'
for($i=1;$i-lt$x.Length;$i++){
  for($j=0;$j-lt($x.Length-$i);$j++){
    $y=($x[0..$j]+$x[($i+$j+1)..$x.Length])-join''
    $y>.\c.ps1
    $error.clear()
    if(!($y-in($yy,$yyy,$yyyy))){try{.\c.ps1}catch{};if(!($error)){exit}}
    $q++;
    write-host -n "."
    if(!($q%150)){""}
  }
}
"No success."
```
(Thanks to Martin for his extensive assistance!)
[Answer]
# PHP, 73 bytes
```
<?=call_user_func(($p='ns')|(($f="u{$p}erialize"))?$f:'','s:5:"world"');
```
### Explination
I assume the default php.ini configuration. So short\_tags is disabled. This means you can't remove the `=` from the opening tag.
This is basically `<?=unserialize('s:5:"world"');`.
If you remove any part of the serialized string you'll get an error.
You can simply remove `unserialize` and the script will just output the serialized string. To overcome this I use `call_user_func`. Removing one of the params will result in an error.
```
'<?=call_user_func('unserialize','s:5:"world"');
```
However you can remove `un`, to call the `serialize` function. So we take out 'ns`. Removing any characters would no result in an incorrect function name.
```
<?=call_user_func(($p='ns')&&($f="u{$p}erialize")?$f:'','s:5:"world"');
```
We'll use an inline if to using variable assignment with the output tag.
Instead of using `&&` we use '|' to prevent removing a single `&` or removing the `$f` assignment 
You could remove `='ns')&&($f="u{$p}erialize"` and end up with `($p)?$f:''`. Therefor I add extra parenthesis around `$f="u{$p}erialize"`.
### Note
*Technically you can remove the opening tags without producing an error. This is than however no longer a PHP script but just a plain text file.*
[Answer]
# [A Pear Tree](https://esolangs.org/wiki/A_Pear_Tree), 17 bytes
This program contains bytes with the high bit set (that aren't valid UTF-8 and thus can't be posted on TIO), so here's an `xxd` reversible hexdump:
```
00000000: 7072 696e 7427 776f 726c 6427 23cd 4290  print'world'#.B.
00000010: bf                                       .
```
## Explanation
This is just `print'world'` with a checksum appended. I've verified by brute force that none of the possible deletions give a program with a valid checksum, so you get an error after any possible deletion.
Fairly boring, but ties the current leader, so I felt it was worth posting.
[Answer]
## Matlab(77)
```
bsxfun(@(c,b)arrayfun(@(x)getfield(c,{x}),conv(b,ismember(4,b))),'world',1:5)
```
## [try it](http://rextester.com/KJVXPB33733)
**Note:**
Following @Optimiser's advice of designing a CPR or something, I was faced to unforeseen substring which didnt lead to any compilation error when removed, example: removing `arrayfun(@(x)a(x),prod(b,ismember(4,1:5))),` from this previous edit `feval(@(a)arrayfun(@(x)a(x),prod(b,ismember(4,1:5))),'world')` doesnt generate any bug! also, for recent same edition, there were `bsxfun(@(a,b)arrayfun(@(x)(x),prod(b,ismember(4,b))),'world',1:5)` and `bsxfun(@(a,b)a,'world',1:5)`,if you asked about how was I when finding them out in my output console, I cried like a baby, so here is the program:
```
b=0;string='bsxfun(@(c,b)arrayfun(@(x)getfield(c,{x}),conv(b,ismember(4,b))),''world'',1:5)'
for u=1:numel(string),for j=u:numel(string)-2,try a=eval([string(1:u) string(j+2:end)]);catch(b); a=0;end; if a~=0, ['here is it : ' string(1:u) string(j+2:end)],end;end;end
```
[An example of a nonpristine program](http://ideone.com/1QrmNk)
**edit:**
> 
> Thanks to everyone beside @Martin for pointing my previous code's (not-errors) out .
> 
> 
> 
[Answer]
# SmileBASIC, 63 bytes
```
REPEAT
A=1/(PRGSIZE(0,1)==63)?"world
UNTIL 1/(PRGSIZE(0,1)==63)
```
]