Bit by Bit - Programación avanzada

🧠 Introducción

El siguiente paso luego de dominar los fundamentos es aprender conceptos más abstractos, técnicos y complejos que permiten escribir software más robusto, escalable y eficiente. Este artículo busca explorar las herramientas y principios que usan los desarrolladores experimentados para resolver problemas complejos con elegancia.

A lo largo de este artículo vamos a ver estructuras de datos más potentes, algoritmos fundamentales, paradigmas de programación, buenas prácticas y conceptos clave para llevar tu código a un nivel profesional.

📦 Estructuras de datos y algoritmos

Las estructuras de datos son formas organizadas de almacenar y manipular información. A medida que los problemas se vuelven más complejos, es necesario usar estructuras más especializadas.

Pilas y colas

Estas estructuras permiten almacenar datos de manera ordenada y acceder a ellos de forma eficiente, cada una con un propósito diferente.

Pila (Stack): Estructura LIFO (Last In First Out), donde el último elemento agregado es el primero en ser eliminado. Ideal para problemas de retroceso, como el recorrido de árboles o la evaluación de expresiones.
Cola (Queue): Estructura FIFO (First In First Out), donde el primer elemento agregado es el primero en ser eliminado. Útil para problemas de programación concurrente o procesamiento por lotes.
Cola de prioridad: Similar a una cola, pero cada elemento tiene una prioridad asociada. Los elementos con mayor prioridad son procesados primero. Ideal para algoritmos de búsqueda y planificación de tareas.

Arboles binarios y árboles de búsqueda

Los árboles son estructuras jerárquicas que permiten almacenar datos de manera ordenada y eficiente. Consisten en nodos conectados por aristas, donde cada nodo puede tener cero o más hijos.

Árbol binario: Cada nodo tiene como máximo dos hijos. Permite realizar búsquedas, inserciones y eliminaciones de manera eficiente.
Árbol de búsqueda binario (BST): Un árbol binario donde cada nodo tiene un valor mayor que todos los nodos en su subárbol izquierdo y menor que todos los nodos en su subárbol derecho.

Grafos

Los grafos son estructuras que representan relaciones entre objetos. Están compuestos por nodos (o vértices) y aristas (o bordes) que conectan los nodos. Son utilizados para modelar una amplia variedad de problemas, como redes sociales, rutas de transporte, y más.

Los grafos pueden ser:

Dirigidos: Las aristas tienen una dirección específica
No dirigidos: Las aristas no tienen dirección, es decir, la relación es bidireccional.
Ponderados: Las aristas tienen un peso o costo asociado, lo que permite representar distancias o costos entre nodos.
No ponderados: Las aristas no tienen peso, lo que significa que todas las conexiones son iguales.
Cíclicos: Contienen al menos un ciclo, es decir, un camino que comienza y termina en el mismo nodo.

Algoritmos clásicos

Búsqueda binaria: Algoritmo eficiente para encontrar un elemento en una lista ordenada. Divide la lista en dos mitades y descarta la mitad que no contiene el elemento buscado.
Ordenamiento rápido (Quicksort): Algoritmo de ordenamiento eficiente que utiliza la técnica de divide y vencerás. Selecciona un pivote y divide la lista en dos sublistas, ordenando cada una recursivamente.
Ordenamiento por mezcla (Mergesort): Otro algoritmo de ordenamiento eficiente que también utiliza la técnica de divide y vencerás. Divide la lista en dos mitades, las ordena y luego las combina.
Dijkstra: Algoritmo para encontrar el camino más corto en un grafo ponderado. Utiliza una cola de prioridad para explorar los nodos más cercanos primero.
BFS (Breadth-First Search): Algoritmo de búsqueda en grafos que explora todos los nodos a un nivel antes de pasar al siguiente. Ideal para encontrar el camino más corto en un grafo no ponderado.
DFS (Depth-First Search): Algoritmo de búsqueda en grafos que explora un camino completo antes de retroceder. Útil para problemas de recorrido y exploración de grafos.

Existen muchos más algoritmos y estructuras de datos, pero estos son algunos de los más comunes y útiles en la programación avanzada. Aprender a utilizarlos y combinarlos te permitirá resolver problemas complejos de manera eficiente.

🌀 Recursividad

La recursividad es una técnica donde una función se llama a sí misma para resolver subproblemas más pequeños. Es especialmente útil para problemas que pueden ser divididos en partes más simples, como el cálculo de factoriales, la serie de Fibonacci, y la exploración de estructuras de datos como árboles y grafos.

En un algoritmo recursivo, es importante definir:

Caso base: La condición que detiene la recursión. Sin un caso base, la función se llamará indefinidamente, causando un desbordamiento de pila.
Caso recursivo: La parte de la función que llama a sí misma con un subproblema más pequeño. Este caso debe acercarse al caso base en cada llamada recursiva.
División del problema: Cómo se divide el problema original en subproblemas más pequeños. Esto es crucial para que la recursión funcione correctamente.

Existen tecnicas para optimizar la recursión, como la memorización, que almacena los resultados de subproblemas ya resueltos para evitar cálculos redundantes. Esto es especialmente útil en problemas como la serie de Fibonacci, donde muchos subproblemas se repiten.

🛑 Manejo de errores y excepciones

El manejo de errores y excepciones es una parte fundamental de la programación avanzada. Permite a los desarrolladores anticipar y manejar situaciones inesperadas que pueden ocurrir durante la ejecución del programa, como errores de entrada/salida, problemas de red, o condiciones inesperadas.

Errores: Son problemas que ocurren durante la ejecución del programa y pueden ser causados por errores de programación, como divisiones por cero, acceso a índices fuera de rango, o referencias nulas.
Excepciones: Son eventos que interrumpen el flujo normal del programa y requieren un manejo especial.
Manejo de excepciones: Consiste en anticipar y manejar situaciones inesperadas utilizando bloques de código específicos. En muchos lenguajes de programación, esto se hace mediante el uso de bloques try, catch y finally.

try {
	// Código que puede causar una excepción
	let result = operacionRiesgosa()
} catch (error) {
	// Manejo de la excepción
	console.error('Ocurrió un error:', error)
} finally {
	// Código que se ejecuta siempre, independientemente de si ocurrió una excepción o no
	console.log('Operación finalizada.')
}

🧩 Paradigmas de programación

Los paradigmas de programación son enfoques o estilos de programación que definen cómo se estructuran y organizan los programas. Cada paradigma tiene sus propias características y ventajas, y es importante conocerlos para elegir el más adecuado según el problema a resolver.

Programación imperativa: Se basa en la idea de dar instrucciones al ordenador para que realice tareas específicas. Utiliza variables, estructuras de control y funciones para manipular el estado del programa. Ejemplos de lenguajes imperativos son C, Java y Python.
Programación orientada a objetos (OOP): Se basa en la idea de representar entidades del mundo real como objetos que tienen propiedades y comportamientos. Utiliza conceptos como clases, herencia, polimorfismo y encapsulamiento. Ejemplos de lenguajes OOP son Java, C++ y Python.
Programación funcional: Se basa en la idea de tratar la computación como la evaluación de funciones matemáticas. Promueve el uso de funciones puras, inmutabilidad y evita efectos secundarios. Ejemplos de lenguajes funcionales son Haskell, Scala, Elixir y algunas partes de JavaScript.
Programación declarativa: Se centra en describir el resultado deseado en lugar de cómo lograrlo. Utiliza expresiones y declaraciones para definir el comportamiento del programa. Ejemplos de lenguajes declarativos son SQL y HTML.

⚙️ Concurrencia y paralelismo

La concurrencia y el paralelismo son conceptos relacionados con la ejecución de múltiples tareas al mismo tiempo. Ambos son fundamentales para aprovechar al máximo los recursos del sistema y mejorar el rendimiento de las aplicaciones.

Concurrencia: Se refiere a la capacidad de un sistema para manejar múltiples tareas al mismo tiempo, pero no necesariamente ejecutarlas simultáneamente. En un entorno concurrente, las tareas pueden intercalarse y compartir recursos, lo que permite una mejor utilización del tiempo de CPU.
Paralelismo: Se refiere a la ejecución simultánea de múltiples tareas en diferentes núcleos de un procesador. En un entorno paralelo, las tareas se dividen en subtareas que se ejecutan al mismo tiempo, lo que puede mejorar significativamente el rendimiento.

Hilos y procesos

Proceso: Es una instancia de un programa en ejecución. Cada proceso tiene su propio espacio de memoria y recursos, lo que lo hace independiente de otros procesos.
Hilo (Thread): Es una unidad de ejecución dentro de un proceso. Los hilos comparten el mismo espacio de memoria y recursos del proceso, lo que permite una comunicación más rápida entre ellos.

Gestión de los recursos

La gestión de recursos es crucial en la programación concurrente y paralela. Los desarrolladores deben asegurarse de que los recursos compartidos sean accesibles de manera segura y eficiente, evitando condiciones de carrera y bloqueos.

🧪 Testing

El testing es una parte fundamental del desarrollo de software. Permite verificar que el código funcione correctamente y cumpla con los requisitos establecidos. Existen diferentes tipos de pruebas, cada una con su propio propósito y enfoque.

Tipos de pruebas

Pruebas unitarias: Se centran en probar unidades individuales de código, como funciones o métodos. Permiten verificar que cada unidad funcione correctamente de forma aislada.
Pruebas de integración: Se centran en probar la interacción entre diferentes unidades de código. Permiten verificar que las unidades funcionen correctamente juntas.
End-to-end: Se centran en probar el sistema completo, desde la interfaz de usuario hasta la base de datos. Permiten verificar que el sistema funcione correctamente en su totalidad.

Metodologías de testing

TDD (Test-Driven Development): Se basa en escribir pruebas antes de escribir el código. Permite garantizar que el código cumpla con los requisitos desde el principio.
BDD (Behavior-Driven Development): Se centra en el comportamiento del sistema y en cómo los usuarios interactúan con él. Permite definir pruebas en un lenguaje natural, lo que facilita la comunicación entre desarrolladores y partes interesadas.
ATDD (Acceptance Test-Driven Development): Se centra en definir pruebas de aceptación antes de escribir el código. Permite garantizar que el sistema cumpla con los requisitos del cliente.

📉 Rendimiento y complejidad algorítmica

La complejidad algorítmica es una medida de la eficiencia de un algoritmo en términos de tiempo y espacio. Es importante comprender la complejidad algorítmica para elegir el algoritmo más adecuado según el problema a resolver.

Complejidad temporal: Mide el tiempo que tarda un algoritmo en ejecutarse en función del tamaño de la entrada. Se expresa en notación Big O (O(n), O(log n), O(n^2), etc.).
Complejidad espacial: Mide la cantidad de memoria que utiliza un algoritmo en función del tamaño de la entrada. También se expresa en notación Big O.

Big O: es la notación utilizada para describir la complejidad algorítmica. “O” representa el orden de crecimiento del tiempo o espacio en función del tamaño de la entrada. Por ejemplo, O(n) significa que el tiempo o espacio crece linealmente con el tamaño de la entrada, mientras que O(n^2) significa que crece cuadráticamente.

Ejemplos

Busqueda lineal: en una lista de n elementos y queremos encontrar un elemento específico. La complejidad temporal es O(n) porque en el peor de los casos, debemos recorrer toda la lista.
Búsqueda binaria: en una lista ordenada de n elementos. La complejidad temporal es O(log n) porque en cada paso, la lista se divide a la mitad.
Quicksort: en una lista de n elementos. La complejidad temporal promedio es O(n log n), pero en el peor de los casos puede ser O(n^2) si la lista ya está ordenada.

🧱 Principios de diseño de software

Los principios de diseño de software son pautas que ayudan a los desarrolladores a crear software de alta calidad, mantenible y escalable. Estos principios son fundamentales para la programación avanzada y deben ser considerados en cada etapa del desarrollo.

Principios SOLID

Los principios SOLID son un conjunto de cinco principios de diseño orientado a objetos que ayudan a crear software más mantenible y escalable.

S: Single Responsibility Principle (SRP) - Un módulo o clase debe tener una única responsabilidad y no debe ser responsable de múltiples tareas.
O: Open/Closed Principle (OCP) - Un módulo o clase debe estar abierto a la extensión pero cerrado a la modificación. Esto significa que se pueden agregar nuevas funcionalidades sin modificar el código existente.
L: Liskov Substitution Principle (LSP) - Los objetos de una clase derivada deben poder reemplazar a los objetos de la clase base sin afectar el comportamiento del programa.
I: Interface Segregation Principle (ISP) - Un cliente no debe verse obligado a depender de interfaces que no utiliza. Esto significa que las interfaces deben ser específicas y no contener métodos innecesarios.
D: Dependency Inversion Principle (DIP) - Las dependencias deben ser abstraídas y no depender de implementaciones concretas. Esto significa que las clases de alto nivel no deben depender de clases de bajo nivel, sino de abstracciones.

DRY y KISS

DRY (Don’t Repeat Yourself): Este principio establece que la duplicación de código debe ser evitada. Cada pieza de conocimiento debe tener una representación única y no duplicada en el sistema. Esto facilita el mantenimiento y la evolución del software.
KISS (Keep It Simple, Stupid): Este principio establece que los sistemas deben ser lo más simples posible. La complejidad innecesaria debe ser evitada, ya que puede dificultar la comprensión y el mantenimiento del software.