Seguramente eso fue un poco de ClickBait, pero presta atención, antes que puedas conocer la solución del billón de dólares debes conocer el Error del Billón de Dólares, no te parece?

El Problema del Billón de Dólares

En realidad es sencillo, pero aunque sencillo, se calcula que ha costado Mas de un Billón de Dólares. El Tema en cuestión al cual muchos lenguajes modernos quieren escapar es el NULL, sencillo verdad? Claro ahora existen lenguajes que son “Null-Safety”, pero ¿Por qué han tenido que volverse Null-Safety muchos lenguajes modernos de hoy en día?. La respuesta no es solo por comodidad, o mejor manipulación de tu código, la verdad es que simplemente un null causa demasiados problemas si no se lo ha contemplado.

Un poco de Historia

Tony Hoare, un Científico informático británico, introdujo las referencias nulas en ALGOL W en1965 "simplemente porque era muy fácil de implementar", según el mismo. Posteriormente hablaría de esa decisión considerándola "mi error de mil millones de dólares". Cuando se encontraba desarrollando un nuevo lenguaje, el Lenguaje Internacional ALGOL60, se encontraron con varios problemas pero el principal de ellos fue, que al agregar controles a las matrices aumento costo en memoria y tiempo de ejecución al programa. Por ende su solución fue sacrificar estabilidad a cambio de velocidad. Se incorporo el concepto de valor nulo, que representa una referencia que apunta, a un espacio de memoria inexistente(o no accesible) o un objeto inválido. Esto con el Fin de omitir dichos controles, así al momento de que es consultado un valor en un espacio de memoria no definido o se hace referencia a un índice fuera de la matriz esto ya no devuelve un error o una excepción inesperada, en su lugar devuelve un valor nulo, el cual puede ser manejado y manipulado fácilmente durante el proceso.

Una solución simple a un valor simple

La solución que propongo es sencilla, en este momento con el auge de los lenguajes de programación “Null-Safety” los valores “Null” son uno más dentro del rango de valores posibles que puede adoptar una variable u objeto, por lo tanto simplemente no debemos olvidarlos, y usarlos a nuestro favor. A Continuación presentare 3 ejemplos conceptuales apoyados en código en lenguaje C#.

Ejemplo A – Semáforos, existencia con sentido
Como es de sentido común la existencia teórica de un semáforo vehicular plantea que debe estar funcionando, es decir que en todo momento de su existencia debe presentar un valor. Una forma de aprovechar las nuevas características de Null-Safety, es que los valores Binarios pueden adoptar un valor null.

using System;               
public class Program
{
    public static void Main()
    {
        var miSemaforo = new Semaforo();
        miSemaforo.mostrarColor(); // AMARILLO
        miSemaforo.estado=true;
        miSemaforo.mostrarColor(); // VERDE
        miSemaforo.estado=false;
        miSemaforo.mostrarColor(); // ROJO
    }
}

public class Semaforo{ //Inicio Clase
    public bool? estado;  //valor inicial naturalemnte null
    public void mostrarColor(){ //inicio método
         if(!this.estado.HasValue){ //Si estado no tiene valor o es null
               Console.WriteLine("AMARILLO");
         }else if(this.estado.Value){
                          Console.WriteLine("VERDE");
                   }else{
                           Console.WriteLine("ROJO");
                    }
     }  //Fin metodo
}  //Fin clase

AMARILLO: este es el valor mostrado por un semáforo dado un estado null, representa simbólicamente indeterminación, es decir No detiene el transito Ni lo permite, pero es a la vez el estado mínimo de un semáforo, ya que como dijimos no tiene sentido un semáforo que no este en amarillo como mínimo. Por otra parte un valor true seria VERDE(Avanzar) y un valor false seria ROJO(Detenerse).
Para concluir este caso es sumamente recomendable donde poseemos estados o valores que en algún punto pueden representar indeterminación simbolizar este hecho ya que es información importante a usar en nuestro favor.

Ejemplo B – Billetera. Cero no es nulo
Muchas veces estaremos tentados a pensar que dentro del ámbito de los números(ya sean enteros o racionales) no importara si usamos un valor nulo para representar el cero o un numero infinitamente cercano a este, pero no debemos caer en esa tentación. Cero no es Nulo y Nulo no es Cero, así de simple, tratar de representar un valor Cero con Nulo nos puede acarrear muchísimos mas problemas que soluciones. Así que lo correcto es inicializar SIEMPRE nuestras variables o atributos numéricos en “0”.

using System;               
public class Program
{
    public static void Main()
    {
       var miBilletera = new Billetera();
           miBilletera.mostrarMonto();//expone el monto actual
    }
}

class Billetera{

    double? monto; //monto en divisa que contiene la billetera
    public Billetera(){   //Constructor de la clase
             this.monto=0;
    }

    public void mostrarMonto(){ //inicio metodo
        Console.WriteLine(this.monto.Value);
     }  //Fin metodo

}  //Fin clase

Si no se hubiere inicializado el valor del Monto en el constructor obtendríamos una Error al momento de consultar el valor del monto.
Para concluir este caso también debemos mencionar que el mismo caso se aplica a textos donde Null no es Nada. Es decir teniendo cualquier variable que almacene un String, este nunca debe ser Null si no es intencional. Un ejemplo es un cartel electrónico en un centro comercial, aunque el letrero no muestre texto alguno, este no es nulo, es Vacío (“”).

Ejemplo C – Todo o Cualquiera. ¿Qué representa un Null?
Para comprender y simplificar este caso debemos aceptar a fines prácticos que contra-intuitivamente Todo es Cualquiera. Decir que aceptamos “Todas las Posibilidades” es equivalente a decir que aceptamos “Cualquier Posibilidad”. Por lo tanto Null puede representar cómodamente Todo o Cualquiera. Por ejemplo, suponiendo que poseemos un sistema que posee almacenados una gran colección de videojuegos, debemos saber que cada videojuego solo corre en una plataforma especifica(PC,Xbox,PlayStation,etc.). Por lo tanto a la hora de requerir filtrar todas las plataformas puede ser apropiado usar un valor null para representar esa incertidumbre, ese desconocimiento de la plataforma especifica, o la posibilidad de que sea cualquier plataforma la que nos interesa.

Haciendo Uso de una Librería Externa que tiene los métodos para filtrar y una API que sirve de repositorio, podemos analizar el siguiente código

using System;               
public class Program
{
    public static void Main()
    {
        list<Videjuego> miColeccion = repositorioAPI.obtenerVideojuegos();
        libreriaExterna.mostrar(miColeccion); //Muestra toda la colección de Videojuegos Indistintamente, de todas las plataformas
        libreriaExterna.mostrarFiltrado(miColeccion, enumPlataforma.PC);  //Muestra la colección de Videojuegos que son compatibles con PC
        libreriaExterna.mostrarFiltrado(miColeccion, enumPlataforma.Xbox);  //Muestra la colección de Videojuegos que son compatibles con Xbox
        libreriaExterna.mostrarFiltrado(miColeccion, enumPlataforma.Otros);   //Muestra la colección de Videojuegos que son compatibles con Otros
        libreriaExterna.mostrarFiltrado(miColeccion, null);   //Muestra toda la colección de Videojuegos, lo mismo que “mostrar”
    }
}

enum enumPlataforma{
    Xbox,PlayStation,PC,Otros
}

class Videjuego{
    string nombre; //nombre del videojuego
    enumPlataforma? plataforma;  //plataforma compatible con nuestro videojuego.
    Videjuego(){   //Constructor de la clase
             this.nombre = "";
             this.plataforma = enumPlataforma.Otros;
            }
}  //Fin clase

Nótese que nuestro constructor no deja valores sin inicializar. Al Analizar la firma de los métodos Mostrar y MostrarFiltrado, podemos notar que a la hora de usar un valor null para referirnos al tipo de plataforma se hace innecesario el método mostrar, permitiéndonos más eficiencia, menos código, más control y flexibilidad en este.