Programadores

Un programador es una persona que no solo teclea código. Es un profesional, certificado o no, que tiene ciertas peculiaridades.

Este ente salido de alguna parte posee una especie de singularidad, un poder especial que le permite comunicarse con las máquinas.

Para ello emplea cierta jerga que puede variar. A veces habla Java, otras C#, incluso Python u Go. Se le dificulta C++ o Rust... y otros más.

Quien quiere pertenecer a ese mundillo deberá abandonar su vida personal, si es que tiene una. Deberá aprender constantemente todo lo referente a tecnología informática y volverse un geek de la programación.

Habilidades que debería tener un programador (o quien quiera serlo)

Hablemos de sus habilidades blandas y/o técnicas.

Habilidades blandas (Soft Skills)

• Curiosidad Autodidacta: La tecnología cambia rápido; saber buscar, leer documentación e investigar por cuenta propia es imprescindible. 
• Tolerancia a la Frustración: El código raras veces funciona al primer intento; la paciencia para encontrar un error (debugging) es clave. 
• Comunicación y Trabajo en Equipo: Saber explicar conceptos complejos de forma clara y colaborar en proyectos grupales.

En teoría, el programador es alguien que le gusta aprender por sí mismo y a su propio ritmo. Quien le gusta programar por hobby o curiosidad.

Pero también hay quienes lo ven como una profesión lucrativa. Obtener un buen empleo y dinero.

Habilidades técnicas

• Pensamiento Lógico y Algorítmico: Capacidad para desglosar problemas complejos en pasos sencillos y estructurados. 
• Dominio de Fundamentos: Comprensión sólida de estructuras de datos, algoritmos y control de versiones (Git). 
• Atención al Detalle: Habilidad para identificar fallas en la sintaxis o la lógica que pueden detener todo un sistema.

Hay quienes se les da mejor la lógica y las matemáticas. Hay quienes mejor la creatividad y los retos. Hay quienes odian la documentación y prefieren poner manos a la obra. Hay quienes "se ahorran 1 hora de lectura de la documentación" y prefieren gastar 4 o 5 horas en prueba y error.

Tipos de programadores

• Junior: necesita apoyo y supervisión constante, en fase de aprendizaje.
• Mid-level: requiere supervisión mínima, puede auto gestionarse.
• Senior: capaz de gestionar proyectos y dirigir personas, con mayores habilidades técnicas.
• Architect: quien tiene a cargo el proyecto y mayores responsabilidades.

Junior

Mid-level

Senior

Architect

Observemos la siguiente tabla que resume los tipos de programadores.

Rol	Enfoque Principal	Nivel de Autonomía	Responsabilidad Clave
Junior	Aprender y ejecutar tareas específicas.	Baja (requiere supervisión).	Escribir código limpio para tareas pequeñas y entender la base del sistema.
Mid-Level	Construir funcionalidades completas.	Media-Alta (independiente en el día a día).	Entregar tareas de extremo a extremo y aportar en las decisiones de diseño del equipo.
Senior	Resolver problemas ambiguos y optimizar.	Alta (lidera técnica y estratégicamente).	Diseñar sistemas escalables, mentorizar al equipo y prever fallos técnicos.
Architect	Diseñar la estructura global del sistema.	Total (define la visión técnica global).	Alineación tecnológica con el negocio, estándares de seguridad y escalabilidad a largo plazo.

Los niveles o tipos de programador muchas veces son superficiales. Nada tiene que ver con la edad o los años de experiencia. Muchas veces es la capacidad nata o hasta innata.

Enlaces:

https://blog.codinghorror.com/the-two-types-of-programmers/

Pattern Matching en sencillas palabras (o no tanto)

El pattern matching es una técnica para comparar estructuras de datos contra un patrón y, si coincide, extraer valores o ejecutar lógica específica. Es más expresivo que simples condicionales (if/else o switch) porque permite desestructurar objetos, listas, tuplas, enums, etc., directamente en la condición.

Digamos que es como un switch evolucionado que no solo compara valores, sino que entiende la forma y contenido de los datos.

¿Para qué sirve?

• Simplificar código: menos if anidados y menos boilerplate. 
• Mayor expresividad: describe qué esperas de los datos, no cómo acceder a ellos. 
• Seguridad en tiempo de compilación: muchos lenguajes obligan a cubrir todos los casos (ej. sealed classes en Kotlin, enum en Rust). 
• Desestructuración directa: extraer valores sin escribir getters o índices.

En teoría el pattern matching nos obligará a escribir un código más limpio y fácil de leer, evitar errores y extraer datos directamente.

Usando otras palabras, el pattern matching (coincidencia de patrones) es como una súper versión del famoso if / else o del switch que usan muchos lenguajes de programación, pero con "esteroides".

En lugar de solo preguntar ¿Esta variable es igual a 5?, el Pattern Matching te permite preguntar:

"¿Esta información tiene la estructura o la forma que estoy buscando? Y si es así, extrae los datos que me interesan de una vez."

Pattern Matching

Observemos un ejemplo:

// Using Pattern Matching:

switch(response) {
case Success(data):
display("Todo salió bien, los datos son: " + data)

case Error(code, message):
display("Error con el código " + code+ ": " + message)

case Loading:
display("Espere por favor...")
}

Originalmente nació dentro del paradigma de programación funcional.

Actualmente está técnica se puede usar en lenguaje de programación modernos como Go, Rust, Scala, Java, Kotlin, y C#.

En Java:

switch (obj) {
case String s -> System.out.println("Texto: " + s);
case Integer i -> System.out.println("Número: " + i);
default -> System.out.println("Otro tipo");
}

En C#:

object o = 42;
if (o is int x) Console.WriteLine(x);
switch (o) {
case string s: Console.WriteLine($"Texto {s}"); break;
case int i when i > 0: Console.WriteLine($"Positivo {i}"); break;
}

En Kotlin:

sealed class Expr class Num(val value: Int): Expr()

class Sum(val left: Expr, val right: Expr): Expr()

fun eval(e: Expr): Int = when(e) { is Num -> e.value is Sum -> eval(e.left) + eval(e.right)}

En Go:

switch v := anyVal.(type) {
case string:
fmt.Println("Texto", v)
case int: fmt.Println("Número", v)
}

Un ejemplo sencillo de entender

Tomemos este pseudo código que verifica si la edad de una persona es igual 18. Si lo es, puede votar. Si no es el caso, no puede votar.

var edad: int = 45

if edad -equals 18 then
  display 'Puedes votar'.
else 
  display 'No puedes votar'.
end if

Aplicando la lógica del patter matching tenemos este código en Haskell, un lenguaje puramente funcional.

votar.hs

edad :: Int
edad = 45

mensaje :: String
mensaje = case edad of
    18 -> "Puedes votar"
    _  -> "No puedes votar"

main :: IO ()
main = putStrLn mensaje

Si lo ejecutamos:

$ runghc votar.hs

La salida será:

No puedes votar

¿Acaso es un error de código? No y sí. No porque el código está haciendo lo correcto, si la edad no es 18 el usuario no podrá votar. Sí es error en cuanto a que el valor es 45 y es obvio que es mayor a 18. Debería poder votar. Modifiquemos el programa.

votar.hs

puedeVotar :: Int -> String
puedeVotar edad
    | edad >= 18 = "Puedes votar"
    | otherwise  = "No puedes votar"

main :: IO ()
main = putStrLn (puedeVotar 45)

Si lo volvemos a ejecutar:

$ runghc votar.hs

La salida será:

 Puedes votar

Podríamos continuar con más ejemplo, pero creo que es mejor detenernos.

El pattern matching se ha popularizado así como la programación funcional. Lenguajes como Java y C# lo implementan en sus versiones más actuales.

Es una forma que nos obliga a escribir mejor código y olvidarnos de los if anidados y complejos switch.

Enlaces:

https://en.wikipedia.org/wiki/Pattern_matching
https://emanuelpeg.blogspot.com/search?q=pattern+matching

LLVM: una herramienta para crear compiladores

LLVM (Low Level Virtual Machine) es una infraestructura de compiladores que permite transformar y optimizar código de distintos lenguajes de programación. No es un compilador único, sino un conjunto de herramientas que sirven para crear compiladores, analizadores y optimizadores de código.

En este blog ya hemos hablado, burdamente, de lo que conforma un lenguaje de programación. Sin embargo, sería importante recordar algunos detalles.

Un compilador es un programa que traduce el código que escribes (por ejemplo en C, Rust o Java) a un lenguaje que la computadora entiende directamente: el código máquina. Ejemplo, tú escribes una receta en español, el compilador la traduce al "idioma" de la computadora para que pueda cocinarla.

Un analizador de código es la parte del compilador que lee y entiende tu código fuente. Verifica que lo que escribiste tenga sentido (sintaxis correcta, variables bien usadas, etc.). Es como un profesor que revisa tu redacción y te dice si las frases están bien construidas antes de publicarlas.

Un optimizador de código es una herramienta que mejora el código para que sea más rápido o consuma menos recursos. Reorganiza instrucciones, elimina pasos innecesarios y aprovecha mejor el hardware. Llanamente, el optimizador busca el camino más corto y rápido para llegar a algo.

Estos tres se relacionan de esta manera:

• Analizador: entiende tu código y lo valida. 
• Compilador: traduce ese código a instrucciones que la máquina entiende. 
• Optimizador: pule esas instrucciones para que se ejecuten de la mejor manera posible.

LLVM al ser un conjunto de bibliotecas y herramientas que permiten construir compiladores y optimizadores no está limitado a un lenguaje específico; se usa en C, C++, Rust, Swift, Julia, Haskell, entre otros. Está diseñado como bloques reutilizables (frontends, optimizadores, backends).

¿Para qué sirve LLVM?

• Compilación: Convierte código fuente en código máquina optimizado. 
• Optimización: Mejora el rendimiento del código en tiempo de compilación y ejecución. 
• Portabilidad: Permite que un mismo lenguaje se ejecute en múltiples plataformas. 
• Experimentación: Ideal para investigadores y desarrolladores que quieren crear nuevos lenguajes o probar técnicas de optimización.
• Ejemplo real: El compilador Clang (para C/C++/Objective-C) está construido sobre LLVM.

¿Qué hace LLVM?

1. Traduce código a un lenguaje intermedio (LLVM IR) que es más fácil de analizar y optimizar. 
2. Optimiza ese código para que sea más rápido y eficiente. 
3. Genera código máquina para distintas arquitecturas (x86, ARM, etc.), lo que permite que tu programa corra en diferentes dispositivos.

LLVM es como el motor universal que hace funcionar muchos lenguajes modernos (Rust, Swift, Julia, Haskell).

Como desarrollador, puedes usarlo para compilar, optimizar y experimentar con lenguajes modernos o incluso crear el tuyo propio.

Probando LLVM

Vamos a comenzar instalandolo:

Linux:

$ sudo apt update
$ sudo apt install llvm clang

Windows:

$ choco install llvm

Vamos a crear un sencillo programa que verifique si un número entero es mayor a 100.

mayor.c

#include <stdio.h>

int main() {
    printf("\t Determinar si un número es mayor a 100 \n");

    int numero = 120;
    if (numero > 100) {
        printf("El número es mayor que 100\n");
    } else {
        printf("El número es menor o igual a 100\n");
    }

    return 0;
}

Compilams con la herramienta ``clang``:

$ clang mayor.c -o mayor

Creará un ejecutable:

$ ./mayor

Salida:

El número es mayor que 100

Ahora usaremos LLVM para ver el código intermedio (LLVM IR):

$ clang -S -emit-llvm mayor.c -o mayor.ll

Esto genera un archivo ``mayor.ll`` con el Intermediate Representation (IR). En ese archivo verás instrucciones más “básicas” que LLVM entiende, por ejemplo:

define i32 @main() {
entry:
  %numero = alloca i32, align 4
  store i32 120, i32* %numero, align 4
  %0 = load i32, i32* %numero, align 4
  %cmp = icmp sgt i32 %0, 100
  br i1 %cmp, label %if.then, label %if.else
  ...
}

Optimizamos el código:

$ clang -S -emit-llvm mayor.c -o mayor.ll

Esto genera una versión optimizada del IR, eliminando redundancias y mejorando el rendimiento.

Enlaces:

https://llvm.org/
https://codemonkeyjunior.blogspot.com/2024/02/lo-que-conforma-un-lenguaje-de.html
https://clang.llvm.org/
https://es.wikipedia.org/wiki/LLVM
https://www.reddit.com/r/ProgrammingLanguages/comments/kl7n03/what_is_meant_by_llvm_and_a_language_frontend/
https://aosabook.org/en/index.html

Las leyes (no escritas) de la programación (4ta parte)

En un mundo donde la I.A. ha dejado de ser un sueño o fantasía y es usada por la mayoría de las empresas de tecnología e IT el programador deberá saber adaptarse o morir.

Sin embargo, ¿La I.A. supone la muerte de la programación? No, ¡claro que no!

Quien quiera programar deberá saber programar. Así como quien quiera ser escritor deberá saber escribir.

Muchos creen que usar ChatGPT, Copilot, DeepSeek o cualquier otra inteligencia artificial automáticamente los convertirá en programadores. Se equivocan. Quien crea eso terminará dándose de topes en la pared cuando se enfrente a problemas de programación reales. No sabrá como resolverlos cuando la I.A. arroje resultados erróneos o inútiles.

He visto personas que creen que ChatGPT les resolverá todos sus bugs o creará de la nada sus proyectos. Y es por qué no conocen cómo funciona la I.A.

La I.A. no piensa, imita la forma de pensar. Carece de conciencia aunque nos quieran decir lo contrario. No es un Skynet, pero sus creadores lo harán parecer que sí.

Y tampoco es "gratis", ya que el producto final es quien la usa: nosotros.

Y nosotros somos quien la alimentamos, quien le damos retroalimentación, la "entrenamos" de acuerdo a lo que le pedimos, a lo que se le solicita.

ChatGPT, DeepSeek, Grok, etc. accede a sitios web, repositorios de código, base de datos propias para "crear" las respuestas a las solicitudes del usuario.

Lo cual es muy sospechoso. Es como si se hubiesen puesto de acuerdo para que funcionara así. Pues es capaz de recolectar datos de casi cualquier lado en la Internet.

Y también es sospechoso que antes del auge de las I.A. la malévola empresa Microsoft compró Github.😱

Pero, ¿Qué significa adaptarse? Significa que:

• Recordar que los fundamentos nunca deben dejarse en saco roto. 
• Mantener el código lo más simple y claro posible.
• Actualizarse constantemente.  
• No dejar de practicar y conocer nuevos temas. 
• Usar la I.A. a favor y no en contra.
• Saber qué solicitar y saber qué no es útil.

Esperemos que pasa en el futuro.

Enlaces:

https://codemonkeyjunior.blogspot.com/2025/01/las-leyes-no-escritas-de-la.html
https://codemonkeyjunior.blogspot.com/2025/06/vibe-coding-la-programacion-via-ia-el.html

¿Cómo ser un mejor programador (en un mundo con I.A.)?

Hace décadas la Inteligencia Artificial era tan solo un mito futurista, un sueño salido de alguna película o libro de ficción.

Pensar que algún día la podríamos usar para preguntar cómo hallar la salida de un laberinto, calcular una operación muy compleja o tan solo hacer cuestionamientos sin importancia era como imaginar viajar en una nave espacial.

Hoy existe y no solo se emplea para muchas cosas como análisis estadístico, inversiones financieras, programación y cómputo sino también para cosas insulsas como recrear una batalla entre miles de pollos enfrentando a un mítico TRex o hasta crear imágenes de cualquier tipo.

Corregir o hasta mejorar guiones de películas, hacer tareas de estudiantes flojos, responder preguntas médicas, políticas, sociales o hasta psicológicas.

Aprender un idioma. Aprender matemáticas sin maestro. Crear estrategias o esquemas de trabajo. Sugerencias de proyectos, etc.

Eso plantea nuevas preguntas:

• ¿Se acabará los profesionales médicos? 
• ¿Ya no habrá necesidad de un programador? 
• ¿Para que se necesitarán abogados si la I.A. podrá ayudar a resolver asuntos legales? 
• Etc.

Los más pesimistas imagina un mundo caótico. Un mundo donde la I.A. reemplazará a las personas por máquinas.

Los más optimistas podrán vislumbrar un mundo lleno de posibilidades. Un mundo donde la I.A. podrá ser usada para el bien.

Imaginemos que estamos en esa posición de optimismo, de esperanza.

Imaginemos que todo será para bien.

En un mundo con I.A. el programador deberá ser más cauteloso, mejor preparado, no dormirse en sus laureles.

1. Siempre habrá algo que aprender, siempre. 
2. Crear una comunidad de personas a las que podrá acudir o ayudar.
3. Aprender constantemente, aprender de sus errores, aprender de otros.
4. Comprender que su verdadera herramienta de trabajo es su mente.
5. Debe llenar su mente de cosas buenas, cosas positivas.

El programador de está época deberá adaptarse a los cambios.

Deberá usar lo que hay a su favor, usar la I.A. a su favor y no en contra.

Ninguna empresa es tan banal para depender de una I.A. programada por externos, todo lo "gratuito" tiene un costo.

Con el advenimiento de herramientas como DeepSeek, ChatGPT y Grok el programador deberá mantenerse actualizado.

En un futuro quizás el mundo cambie o se mantenga como está. Todo está en el mañana.

Enlaces:

https://codemonkeyjunior.wordpress.com/2019/05/28/how-can-i-programmer/

Las leyes (no escritas) de la programación (3ra parte)

Cuando empezamos en este mundo de la programación vamos sin rumbo definido, a ciegas muchas veces. No sabemos qué lenguaje de programación escoger, y por qué.

Nos dirán que Java es el mejor lenguaje. Otros dirán que mejor C#, Python o Javascript. Los más vetustos gritarán a los mil vientos que no hay mejor opción que C.

"En ese aprendes los tipos, las constantes, el control de flujo de un programa y las estructuras de datos. Anda, leé el libro de C".

Lenguajes como Fortran,Oberon, Modula, Lisp, Pascal, Smalltalk, Perl, etc. muy raras veces serán nombrados.

"Si quieres trabajar como programador, aprende COBOL".

"Si quieres trabajar como programador, aprende Java".

"Si quieres trabajar como programador, aprende PHP".

"Si quieres trabajar como programador, aprende Javascript".

El programador que ya trabaja como programador (sic) recordará esos consejos esbozando una sonrisa. Horas y horas practicando la programación en lenguajes que quizás ahora ya no usa. Es más, ya ni se acuerda de como hacer un "Hola, mundo". Consultando foros que ahora ya no existen o que están en desuso. Posteando preguntas en Stackoverflow, y quizás respondiendo algunas para probarse así mismo.

Encontrando tutoriales y libros PDF en sitios donde nadie más ha entrado. Libros de hace más de 5 o 10 años. Tutoriales que pueden o no estar completos.

Consultando Youtube para encontrar información valiosa que vale más que el oro. Frustrándose al tratar de replicar los programas que Hindues hacen en segundos. Tratándo de hallar el código del vídeo tutorial de Java de hace más de 5 o 6 años.

Al final, siempre volverá al principio de todo: a las bases de la programación.

"Si eres capaz de crear un buen algoritmo, entonces su conversión a cualquier lenguaje de programación será más sencillo".

Las bases, siempre fueron las bases. No aprender los 109181818 frameworks que abundan en el mundo de la programación.

"Si conoces las estructuras de control, siempre serás capaz de crear un orden lógico a tu programa".

"Si entiendes las estructuras de datos, te ahorrarás un montón de horas para ordenar tu información".

En conclusión, nunca olvidarse de las bases:

1. El algoritmo antes que el programa.
2. Estructuras de control. 
3. Estructuras de datos.

Enlaces:

https://codemonkeyjunior.blogspot.com/2013/04/las-leyes-no-escritas-de-la-programacion.html

Un programa en varios lenguajes de programación (2da parte)

En una entrega anterior vimos como resolver un ejercicio de programación (determina si una cadena de caracteres tiene una longitud distinta de 0) usando diversos lenguajes de programación.

Para probar estos ejemplos puedes ir a este sitio:

https://codapi.org/

En está ocasión resolveremos el siguiente problema:

Si enumeramos todos los números naturales menores de 10 que sean múltiplos de 3 o 5, obtenemos 3, 5, 6 y 9. La suma de estos múltiplos es 23. Halla la suma de todos los múltiplos de 3 o 5 menores de 1000.

Un ejercicio propuesto en la página de Project Euler: https://projecteuler.net/

En Dlang:

multipos3o5.d

void main()
{
    import std.stdio : writefln;
    const MAX = 1000;
    int counter = 1;
    int suma = 0;
    while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           writefln("Suma = %d, Counter: %d",suma,counter);
        }
        ++counter;
    }
    writefln("Suma final= %d",suma);
}

En C:

multiplos3o5.c

#include <stdio.h>
const int MAX = 1000;

int main() {
    int counter = 1;
	int suma = 0;
    
	 while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           printf("Suma = %d, Counter: %d\n",suma,counter);
        }
        ++counter;
    }
	printf("Suma final = %d\n",suma);
    return 0;
}

En Python:

multiplos3o5.py

MAX = 1000;
counter = 1
suma = 0
while counter < MAX:
    if counter%3== 0 or counter%5==0:
        print(f"Suma: {suma}, Counter: {counter}")
        suma = suma + counter
    counter = counter + 1   
print(f"Suma final: {suma}")

En Java:

Multiplos3o5.java

package com.test.main;

public class Main {
    public static final int MAX = 1000;
    public static void main(String[] args) {
        int counter = 1;
        int suma = 0;
        while(counter < MAX){
            if(counter%3==0 ||counter%5==0){
                suma+=counter;
                System.out.printf("Suma: %d, Counter: %d\n",counter,suma);
            }
            ++counter;
        }
        System.out.printf("Suma final: %d\n",suma);
    }
}

En Javascript:

multiplos3o5.js

const MAX = 1000;
let counter = 1;
let suma = 0;
    
	while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           console.log(`Suma = ${suma}, Counter: ${counter}`);
        }
        ++counter;
    }
	console.log(`Suma final = ${suma}`);

En Clojure:

multiplos3o5.clj

(def MAX 1000)

(defn calcular-suma []
  (loop [counter 1 suma 0]
    (if (< counter MAX)
      (if (or (zero? (mod counter 3)) (zero? (mod counter 5)))
        (do
          (println "Suma:" suma ", Counter:" counter)
          (recur (inc counter) (+ suma counter)))
        (recur (inc counter) suma))
      (do
        (println "Suma final:" suma)
        suma))))

(calcular-suma)

Clojure es un lenguaje muy distinto a la mayoría. Como emplea la misma sintaxis de LISP, el cual es un lenguaje orientado a expresiones.

En Ada Language Programming:

multiplos3o5.adb

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

procedure Suma_Multiplos is
   MAX     : constant Integer := 1000;
   Counter : Integer := 1;
   Suma    : Integer := 0;
begin
   while Counter < MAX loop
      if (Counter mod 3 = 0) or (Counter mod 5 = 0) then
         Put_Line("Suma: " & Integer'Image(Suma) & ", Counter: " & Integer'Image(Counter));
         Suma := Suma + Counter;
      end if;
      Counter := Counter + 1;
   end loop;

   Put_Line("Suma final: " & Integer'Image(Suma));
end Suma_Multiplos;

En Rust:

multiplos3o5.rs

fn main() {
    const MAX: i32 = 1000;
    let mut counter = 1;
    let mut suma = 0;

    while counter < MAX {
        if counter % 3 == 0 || counter % 5 == 0 {
            suma += counter;
            println!("Suma = {}, Counter: {}", suma, counter);
        }
        counter += 1;
    }

    println!("Suma final = {}", suma);
}

En Odin:

multiplos3o5.odin

package main

import "core:fmt"

MAX :: 1000;

main :: proc() {
    counter: int = 1;
    suma: int = 0;

    for counter < MAX {
        if counter % 3 == 0 || counter % 5 == 0 {
            suma += counter;
            fmt.printf("Suma = %d, Counter: %d\n", suma, counter);
        }
        counter += 1;
    }

    fmt.printf("Suma final = %d\n", suma);
}

En Go:

multiplos3o5.go

package main

import "fmt"

func main() {
    const MAX = 1000
    counter := 1
    suma := 0

    for counter < MAX {
        if counter%3 == 0 || counter%5 == 0 {
            suma += counter
            fmt.Printf("Suma = %d, Counter = %d\n", suma, counter)
        }
        counter++
    }

    fmt.Printf("Suma final = %d\n", suma)
}

Continuaremos ampliando la lista de ejemplos.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/02/un-programa-en-varios-lenguajes.html
https://projecteuler.net/

Lo que conforma a un lenguaje de programación

 

De la Wikipedia:

Los lenguajes de programación están formados por un conjunto de símbolos (llamado alfabeto), reglas gramaticales (léxico/morfológicas y sintácticas) y semánticas, que en conjunto definen las estructuras válidas del lenguaje y su significado.

Es un sistema de notación para escribir programas de computadora; se describe por su sintaxis (forma) y semántica (significado), además de tener al menos una implementación en forma de compilador o intérprete, lo que permite ejecutar programas escritos en ese lenguaje.

La explicación simplista sería: es un lenguaje para hacer que la computadora obedezca nuestras instrucciones previamente creadas.

¿Pero qué diantres es lo que conforma a un lenguaje de programación?

Lo que conforma a un lenguaje de programación es:

• Reglas sintácticas: Conjunto de reglas que definen las secuencias correctas de los elementos.
• Reglas semánticas: Es el significado de las instrucciones en un lenguaje de programación y determina cómo se deben interpretar y ejecutar las acciones.
• Un intérprete o compilador.

La sintaxis describe cómo se ve, mientras que la semántica describe lo que debe hacer. Para mayor información ver esto: https://gus.chat/blog/semantica-en-programacion-tipos-y-usos-mas-comunes/

Ejemplos de sintaxis:

def var nombreVar as type no-undo.

function nameFunction returns type(param1 as type, param2 as type, paramN as type):
   /*  do stuff */
end.

Como podemos ver, la sintaxis nos indica cómo debemos escribir las instrucciones, ya sea declaración de variables, operaciones aritméticas y/o lógicas y la definición de funciones o procedimientos. En este caso vemos la forma en que debemos definir variables y crear una función (para el ejemplo usamos OpenEdge ABL, en otros lenguajes la sintaxis cambia).

Ejemplo de semántica:

Si tomamos los ejemplos de arriba. En primer lugar vemos la declaración de variables. Una variable debe ser definida, tener un valor y ser implementada. En el caso de una función deberá tener un propósito definido, realizar alguna operación y ser invocada. La semántica nos dice el signififcado, el por qué de una instrucción.

Intérprete: es un traductor. Verificará las reglas sintácticas (como se escribe la instrucción) y semánticas (el significado de la instrucción) y traducirá a un lenguaje que la máquina (computadora) podrá ejecutar. Python y Perl usan intérpretes que ejecutan el código.

Compilador: es un conversor. No solo verificará las reglas sintácticas y semánticas sino que además creará un código ejecutable para que la computadorá lo ejecute. Relativamente más lento que un intérprete, pero más seguro. Esto porque no solo se conforma con interpretar sino en verificar el tipo de datos que se definen a la hora de escribir las instrucciones. C, C++ y Java usan compiladores que crean un ejecutable (ver la imagen de arriba).

Si te interesa crear un compilador podrías checar este sitio:

https://www.antlr.org/

Pepepepero ¿eso es todo?

No. Cualquier lenguaje de programación que se digne llamar así tendrá su propia sintaxis y semántica, así como paradigma (funcional, orientado a objetos, etc.). Como definir tipos de datos (en el caso de los lenguajes de tipado estático), estructuras de control (top-down, secuenciales e iterativas). Manejo de errores o excepciones. Aserciones. Estructuras de control (vectores, listas, nodos, mapas, árboles) . Manipulación de archivos. Acceso a bases de datos. Entre otras cosas más.

Enlaces:

https://www.antlr.org/

https://www.compilers.iecc.com/crenshaw/