Ya en una oportunidad escribí sobre como iniciarse en el mundo de la programación. Además de sentido lógico y la matemática, es un requisito fundamental el sentido común. Escuchando a mis estudiantes revise varios contenidos disponibles en la red y me encontré en medium.com, un articulo escrito por Nishant Aanjaney, quien destaca la idea que mencioné, sobre principios de programación necesarios para salir de la universidad al campo laboral mejor preparado.
El principio de Programación KISS
La idea expresa este principio, proviene de las palabras en inglés Keep It Simple, Stupid!. Este se enfoca que situaciones que encontramos muchas veces en proyectos tecnológicos cuando se incorpora un nuevo integrante al equipo de desarrollo. En ocasiones, nos vamos a encontrar trabajando juntos en un grupo desarrolladores con visiones diferentes. Es normal que el grupo de desarrolladores trabajan en diferentes aspectos del proyecto. ¿Te gustaría ver un código desordenado sin comentarios o variables si tuvieras que cambiar y trabajar en el código de otra persona? O también, ¿te gustaría ver un código bien documentado que explica esa parte del proyecto? evidentemente prefieres la segunda situación.
Por ejemplo, también puedes estar escribiendo un programa muy complejo y dices que te enfermas. Cuando te recuperas después de una semana, repite tu proyecto. Naturalmente, perderías el flujo de programación, pero ¿querrías venir a ver un código que ya no comprendes? ¿O ves algo que puedes comprender un poco al principio? Indiscutiblemente prefiere lo último.
Imagina que estamos trabajando en un proyecto por nuestra cuenta y lo estamos trabajando todos los días. Se presentarán errores y será necesario corregirlos. ¿Qué tan sencillo sería depurar el código si tu código es más complejo de lo que debería ser? Todas las preguntas tiene un sola respuesta. ¡Mantén tu código simple, tonto!, Es mi traducción particular de Keep It Simple, Stupid!.
Todo tonto puede escribir código que un computadora puede entender. Los programadores competentes escriben código que los humanos pueden comprender.
Martin Fowler.
En definitiva, a la máquina no le importa si escribiste un código sencillo o complejo para realizar una tarea o función específica. Lo que si es de mucho valor e importante para las personas, comenzando contigo, es que quien trabaje en el proyecto van a leer y intentarán comprender el código.
class P {
private String n;
private int e;
private String d;
public P(String n, int e, String d) {
this.n = n;
this.e = e;
this.d = d;
}
public void i() {
System.out.println("N: " + n);
System.out.println("E: " + e);
System.out.println("D: " + d);
}
}
public class H {
private List<P> p;
public H() {
p = new ArrayList<>();
}
public void a(P x) {
p.add(x);
}
public void m() {
for (P i : p) {
i.i();
System.out.println();
}
}
public static void main(String[] args) {
H h = new H();
P p1 = new P("JP", 30, "CF123");
P p2 = new P("MG", 45, "ASV742");
h.a(p1);
h.a(p2);
h.m();
}
}Ahora, si queremos ser eficiente y mantener el código simple y entendible, podemos reescribir y tener uno como el siguiente, por ejemplo, que hace exactamente lo mismo.
// Clase Persona que almacena información personal de una persona
class Persona {
private String nombre;
private int edad;
private String direccion;
// Constructor de la clase Persona
public Persona(String nombre, int edad, String direccion) {
this.nombre = nombre;
this.edad = edad;
this.direccion = direccion;
}
// Getters para acceder a los atributos de la clase
public String getNombre() {
return nombre;
}
public int getEdad() {
return edad;
}
public String getDireccion() {
return direccion;
}
// Método para mostrar la información de la persona
public void mostrarInformacion() {
System.out.println("Nombre: " + nombre);
System.out.println("Edad: " + edad);
System.out.println("Dirección: " + direccion);
}
}
// Clase principal para gestionar la información del hospital
public class Hospital {
// Lista para almacenar objetos de tipo Persona
private List<Persona> pacientes;
// Constructor de la clase Hospital
public Hospital() {
pacientes = new ArrayList<>();
}
// Método para añadir una persona a la lista de pacientes
public void anadirPaciente(Persona persona) {
pacientes.add(persona);
}
// Método para mostrar la información de todos los pacientes
public void mostrarPacientes() {
for (Persona paciente : pacientes) {
paciente.mostrarInformacion();
System.out.println(); // Línea en blanco para separar pacientes
}
}
public static void main(String[] args) {
// Crear un objeto de la clase Hospital
Hospital hospital = new Hospital();
// Crear algunos objetos de la clase Persona
Persona paciente1 = new Persona("Juan Perez", 30, "Calle Falsa 123");
Persona paciente2 = new Persona("Maria Gomez", 45, "Avenida Siempre Viva 742");
// Añadir pacientes al hospital
hospital.anadirPaciente(paciente1);
hospital.anadirPaciente(paciente2);
// Mostrar información de todos los pacientes
hospital.mostrarPacientes();
}
}El segundo agrega mucha abstracción y variables al código. Pero lo más importante es que el código es más limpio y lee con mejor facilidad.
El Principio de Programación DRY
El principio DRY, proviene de las palabras en ingles Don’t Repeat Yourself, que hace referencia a la idea de los desarrolladores de no crear muchas funciones en su código. Pero al final, llega a descubrir tarde que esta ejecutando un mismo código repetidamente. Cuando te des cuenta de que te ocurre esto, simplemente crea una función y reutilizala cada vez que sea necesario.
Esto ocurre con mucha frecuencia en tareas de búsqueda y ordenamiento de datos u objetos. Así que busca realiza una función lo mas general o especifica, que te permita ahorrar repetir un código a cada momento. Además, la idea de las funciones te permite ahora tiempo, reutilizar el código y hacerlo mas simple su lectura.
import java.util.Arrays;
public class OrdenarArreglo {
// Función para ordenar un arreglo en orden ascendente
public static void ordenarAscendente(int[] arreglo) {
int n = arreglo.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arreglo[j] > arreglo[j + 1]) {
// Intercambiar arreglo[j] y arreglo[j + 1]
int temp = arreglo[j];
arreglo[j] = arreglo[j + 1];
arreglo[j + 1] = temp;
}
}
}
}
// Función para ordenar un arreglo en orden descendente
public static void ordenarDescendente(int[] arreglo) {
int n = arreglo.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arreglo[j] < arreglo[j + 1]) {
// Intercambiar arreglo[j] y arreglo[j + 1]
int temp = arreglo[j];
arreglo[j] = arreglo[j + 1];
arreglo[j + 1] = temp;
}
}
}
}
public static void main(String[] args) {
int[] arreglo = {5, 3, 8, 4, 2};
// Ordenar en orden ascendente
ordenarAscendente(arreglo);
System.out.println("Arreglo ordenado en forma ascendente: " + Arrays.toString(arreglo));
// Ordenar en orden descendente
ordenarDescendente(arreglo);
System.out.println("Arreglo ordenado en forma descendente: " + Arrays.toString(arreglo));
}
}Los principios de Programación
Como puedes ver, son solo dos principios, que parecen tontos o muy fácil de aplicar, pero que en la práctica muchos programadores o desarrolladores no aplican. Por varias razones, pero la principal, según mi experiencia es la falta de trabajo en equipo en el desarrollo de aplicaciones.
Si te pareció interesante el escrito, tienes alguna opinión particular sobre tu experiencia o deseas conocer mas sobre programacion, déjame tu comentarios y con gusto te respondere.
En próximos contenidos hablaré de otros principios y técnicas que son necesarias desarrollar para ser un programador eficiente.
