Naturalmente, os programadores nao querem que seus programas caiam, desaparecam na frente do usuario. Contudo isto pode ser necessario na maior parte das vezes, para que o programa nao siga operando em um estado invalido, ou seja, frequentemente e melhor fazer o programa cair do que deixa-lo operando de forma incorreta, o que pode aumentar os danos.O principio de projeto que argumenta esta ideia e chamado de Fail-Fast, que significa Falhe-Rapido. Tanto o conceito como implementacao sao realmente simples: fazer o programa cair ao detectar uma operacao ilegal em vez de tentar contornar e seguir operando.Como um pequeno exemplo, considere um metodo (ou funcao) que realiza operacoes de soma sobre numeros. Poderia ser qualquer operacao, mas neste exemplo vou trazer a simples adicao de dois numeros:Metodo para somar dois numeros:class Numeros { public static int soma(int a, int b) { return a + b; }} // situacao de uso:int s = Numeros.soma(34, 23); // s == 57Esta implementacao parece funcionar bem, em varios testes ela da um resultado previsivel e correto, mas se somarmos quaisquer numeros que de como resposta um numero maior que 2147483647 (o valor maximo aceito pelo tipo INT) entao teremos uma surpresa.Quando a operacao esta incorreta:class Numeros { public static int soma(int a, int b) { return a + b; }} int s = Numeros.soma(1000000000, 2000000000); // deveria dar 3000000000 (3 bilhoes)System.out.println(s); // mas imprime -1294967296Este tipo de erro e chamado de Buffer Overflow. Quando a soma ultrapassar o limite do Inteiro, acontece a mudanca de sinal e a diferenca de valor. Note que esta operacao nao causa falha, ou seja, se o programa depende deste calculo entao ele recebe o valor incorreto e segue funcionando com base neste valor, provavelmente levando a mais operacoes incorretas e causando mais danos.Este exemplo e um candidato a aplicacao do Principio do Fail-Fast, onde tentaremos lancar uma excecao sempre que o valor transbordar (overflows).E bem simples, sempre que forem somados dois numeros positivos entao a resposta deve ser positiva e se forem somados dois numeros negativos entao a resposta deve ser negativa. O metodo seria implementado assim:Protegendo contra Buffer Overflow fazendo a aplicacao cair (Exception):class Numeros { public static int soma(int a, int b) { int r = a + b; if (a > 0 && b > 0 && r < 0) { throw new RuntimeException("BufferOverflow"); } if (a < 0 && b < 0 && r > 0) { throw new RuntimeException("BufferOverflow"); } return r; } } int s = Numeros.soma(1000000000, 2000000000);// deveria dar 3000000000 (3 bilhoes),// mas daria -1294967296, logo se o resultado nao e correto// entao o ideal e lancar uma excecao e deixar o programa cair:Exception in thread "main" java.lang.RuntimeException: BufferOverflow at javaapplication556.Numeros.soma(Main.java:58) at javaapplication556.Main.main(Main.java:17)Java Result: 1Existe um excelente artigo sobre Fail-Fast escrito por James Shore disponivel aqui: http://martinfowler.com/ieeeSoftware/failFast.pdf.James diz que algumas pessoas recomendam fazer um software robusto que contorna os problemas e resulta na falha gradativa. Isto e, o programa continua funcionando apos o erro mas acaba falhando mais adiante, entretanto de uma maneira estranha. Um sistema que falha rapido faz justamente o contrario. As