Just require a file, or check if_readable first? I'm writing a simple front controller, index.php is the main file.
In my index.php, first thing loaded is bootstrap.php via require_once().  

I'm deliberating over two ways to load bootstrap.php:

A)  

require_once 'bootstrap.php';


B)  

if ( is_readable('bootstrap.php') )
  {
    require_once 'bootstrap.php';
  }
else
  {
    exit( 'Sorry, we have a temporary issue. We are aware and it should hopefully be resolved soon. Please try again in 10 mins' );
  }


I see most well know frameworks (Codeigniter etc) just use A, which is neat and simple. If the file is not found, A provides:  


A means for the script to halt via the require_once() returning a
fatal error
Nothing else graceful or useful


However I'm tempted to use B as if the file is not found, B will:


Provides a basic message to the screen, no white screen
Avoids a fatal error which A will produce
B seems more frameworky and robust, controlling what happens via the
application rather than just relying upon PHP which falls back on a
fatal error


This (A or B) is only used a couple of times, once to load  bootstrap.php and then twice within bootstrap.php to load SPL autoloader and error management (etc). Thus dealing with require() and any errors/failures throughout the rest of the system are handled more gracefully (with SPL and error management) and so neither A or B are needed.  

However, I'm trying to make the entire system tight and well coded, rather than "it's only used a few times, meh that'll do".  



I'm personally drawn towards using B, but I don't want opinions on which you would use for personal reasons, there will be some logical reasons or rationale I have not considered which I'd be grateful for you to throw at me.  

Such as B has too much overhead (likely negligible but just an example), major frameworks use A because XYZ, etc.  

Questions:


Is A flimsy and a bit unprofessional by just allowing code within a framework to use PHP fall back to a fatal error? When a framework should manage things in the best possible way.
Is A acceptable just allowing a fatal error?
Is B over the top, too much code FWIW, and not really necessary?
Is B much better because it removes a stinky fatal error, and because it controls how the application degrades rather than relying on a PHP fatal error to halt?
I don't recommend B:


A file being readable does not guarantee that it can be successfully included.  The specified path could be a directory (weird and unlikely, but possible), or it might point to a file with a syntax error.
is_readable() does not check the include_path the way require_once would.


Supposing that you could write a function to ensure that it is a regular file, and that it does not contain syntax errors, and checked all directories in the search path, you would have written a significant amount of code that reimplements PHP's built-in functionality.  The built-in functionality isn't broken to begin with.  If you say that a file is required, and PHP is unable to include it, that's a fatal error.  What is the point of prettifying a fatal error and suppressing the error code?

If the file to be loaded is not entirely essential, or if you want your script to commit suicide on its own terms, a better strategy might be to check the return value of include_once.