Creando un lenguaje de programación, diseñemos el lenguaje | Blog #2

Software
1

Tras un tener un tiempo libre y algunas ideas, dejaré de intentar hacer un lenguaje genérico, y me enfocaré en un lenguaje específico.

La idea de hacer un lenguaje de programación en español para pelearse contra el inglés me agrada. Pero, ya hay varios. Con lo cuál, tendremos que pensar en algo un tanto innovador además de que esté en español.

Primero, no es buena idea traducir directamente las palabras reservadas, cómo:

while → mientras

for → por

return → retorna

Sino, abstraer más las ideas. Usar el concepto, y crear nuestras propias palabras reservadas en español. Sin copiar de otros lenguajes.

Cómo por ejemplo, se tienen los conceptos de control de flujo, condicionales, funciones…

Pues, ir creando palabras reservadas, y cómo podría ser el pseudo lenguaje con las mismas cómo muestra. Objetivos del mismo (yo pensaba darle algo con gráficos (juegos, 3D), matemática, física…).

Bueno, espero a ver que opinan y que quieren aportar.

El presente proyecto es software libre (una mezcla entre la GNU public y la zlib (fines académicos y prestigio)). No hay repositorio con el código fuente, porque no existe. Esto son conceptos para organizar cómo crearlo.

Aunque realmente si existe algo de código, publicado por completo en la primer parte del presente blog.

Esas funciones, qué me ayudaron a optimizar, se quedarían, al ser los “ladrillos”. Pero, ahora queda el diseño de que se va a querer construir con esos ladrillos.

Os espero!

1 me gusta
Quiero crear mi propio lenguaje de programación
2

propongo que se llame las flipantes aventuras de los coders, o abreviando FAC

2 Me gusta
3

Al proyecto ya le había dado el nombre de Hispa.

Pero, ya es es software libre…

  • Hispa
  • FAC
  • Otro
0 votantes

Hispa de hispánico, hispanidad…

Pero, lo principal es, ahora, la sintaxis, estructuras, palabras reservas, etc…

4
  • Lenguaje de uso general
  • Lenguaje integrado en un videojuego
  • Nuestra versión de javascript!
  • Otra… Comenta!
0 votantes

Como nexo con el hilo creado por @isf, me gustaría ver que opinan…

5

También, ahí vi que les gusta el nombre original de Hispa.

Ese también podría ser el nombre de nuestra versión de JS…

1 me gusta
6

como puedes crear tu propio lenguajeee? que herramientas usas?

1 me gusta
7

Puedes agarrar el lenguaje C (se puede con otro, ese utilizo yo), y me pongo a crearlo con su estándar…

Primero, quiero poder leer los archivos dónde va a estar el código (archivos de texto).

Luego tengo que interpretarlo para saber que va a hacer…

Para entender un poco mejor, podes leer el Blog #1 de esta serie. Dónde estuvimos programando algunas utilidades básicas para el inició del proyecto.

8

Siguiendo con el diseño, toca unas buenas palabras reservadas.

Lo mejor sería no traducirlas de otros lenguajes tal cual, sino, elegir palabras en español que se adapten al concepto.

// Por ejemplo, en C, está la función
printf("Hola Mundo!!!\n");
// Mientras que en Hispa, podría ser
imprimir("Hola Mundo!!!");
imp("Hola Mundo!!!");
mostrar("Hola Mundo!!!");
// Una palabra fácil de recordar, y qué suene bien, no simplemente
// traducir textualmente del inglés

Por lo cuál:

  • mostrar()
  • imprimir()
  • imp()
  • otra…
0 votantes

Y, así continuar…

Para importar dependencias

  • #importar
  • #incluir
  • #necesito
0 votantes

Bucles

  • por rango i entre num
  • mientras
  • otro
0 votantes

Variables…

Funciones…

Tipo datos…

1 me gusta
9

Ufff, buen progreso, ya voté :slight_smile:

1 me gusta
10

Me gusta la iniciativa, he ido votando y leyendo las dos entradas. Aún hay algo que todavía no me queda claro, ¿cuál es el propósito del lenguaje? únicamente usar palabras reservadas en español? porque de ser así, lo más práctico, para iniciar, sería tomar cualquier lenguaje ya existente, copiar todas sus estructuras y solamente tener una capa encima que use palabras reservadas en español. Algo así como un traductor del lenguaje en español al lenguaje base, y que luego use el interprete/compilador del lenguaje base. Con eso evitas el lexer, parser, etc

1 me gusta
11

No es solo ese, es crear una estructura y mecánicas propias para el lenguaje, con el condimento de ser en español. No simplemente traducir uno ya existente.

Dos, o tres, fines del proyecto pueden ser,

Crear mecánicas cómodas para matemáticas y física, incluyendo gráficos 2d y 3d.

Y, un “framework” para videojuegos 2d y 3d.

Ambas como dependencias oficiales del lenguaje.

Luego, la idea es primero centrarse en hacer el intérprete y analizador léxico. Incluyendo fines académicos.

Luego, hacer el compilador, que complicaría a código ensamblador.

Ya que ya intenté hacer un linker, mucho lío…

Si compilo al ensamblador, uso otro linker…

2 Me gusta
12

Bueno, las ideas del proyecto ya van tomando forma. Ahora, subo la rudimentaria estructura del proyecto, está bajo la GPL 3.

La estructura del proyecto es la siguiente:

tree
.
├── bin
├── CMakeLists.txt
├── hola.txt
├── inc
│   ├── lexer.h
│   └── utils.h
├── lib
├── LICENSE
├── Makefile
├── obj
│   ├── main.o
│   └── utils.o
├── README.md
└── src
    ├── lexer.c
    ├── main.c
    └── utils.c

6 directories, 12 files

Ahora, podemos terminar de definir los temas de variables y funciones.

Sobre el tema de variables, se me ocurrió, caminando, en vez de usar tipos de datos basados en la estructura de la RAM, usar algo un poco matemático, R, R², R³, …

Así se tendría:

r string = { "Hola Mundo!!!" }
mostrar(string);
r num = { 1,2,3,4,5 }
r2 vec = { (1,2),(2,3) }
// r -> conjunto de valores, las letras son numeros...
// r2 -> conjunto de vectores de dos dimensiones
// r -> reales
// numero después del r, dimensión
// luego el nombre de la variable
// = -> se la asigna valor. {} -> marcan un conjunto

$ ./hispa script.his
Hola Mundo!!!
# Ejemplo de cómo se ejecutaría

Si gustan, sino, opinen…

Para el tema de funciones, puede ser la palabra reservada ‘f’, ‘fn’, ‘funcion’, nada. Y, definirla con ‘{}’ o ‘:’

  • fn namefunction () {}
  • f namefunction () {}
  • funcion namefunction () {}
  • fn namefunction ():
  • f namefunction ():
  • funcion namefunction ():
  • namefunction ():
  • namefunction () {}
0 votantes
Resumen

Este texto estará oculto

13

Bueno, recomendaría, antes de hacer el interprete, el lexer, etc. o en paralelo definir cuáles serían esas características objetivo del lenguaje que lo harían indicado para gráficos 2d y 3d y el desarrollo de videojuegos. Por ejemplo, sería ideal que el lenguaje fuera vectorizado por defecto (con eso reduces la necesidad de iteraciones explícitas de tipo for). Eso además podría llevar a que algo del estilo a*b sea siempre el producto punto vectorial. Creo que eso ayudaría bastante al desarrollo en 2d y 3d. Pienso que establecer esas características ayuda a dar objetivos y entregables precisos. Además ayudan a priorizar las cosas vitales en el interprete, lexer, etc. Igual son solo sugerencias, seguiré de cerca el desarrollo y aportaré en lo que pueda :saluting_face:

2 Me gusta
14

Específicamente, ya había propuesto, más arriba, ese “vectorizado”. Y, aún más, no solo vectorizado, sino integrado al álgebra lineal.

Así propuse la creación de variables, r2 para vectores de R², r3 para R³.

Para conjunto de reales, para, entre otras cosas, guardar texto, sería “r1xn”. Guardar vectores unidimensionales en una cadena de tamaño n.

Para producto vectorial sería:

r3 namevec3_1 = { (2,3,5) }
r3 namevec3_2 = { (5,4,3) }
r3 namevec3_3 = namevec3_1 x namevec3_2 // producto cruz
r3 namevec3_4 = namevec3_1 * namevec3_2 // producto interno

Y, así…

2 Me gusta
15

Es verdad, lo pasé por alto. Me excuso. Ahí ví tu propuesta y me parece genial, aunque no encuentro necesario lo de definir antes la dimensión de los vectores. por ejemplo:

texto = {"Hola Mundo!!!}
mostrar(texto)
conjunto_escalares = {1, 2, 3, 4, 5}
conjunto_vector_r2 = {(1,2), (2, 3)}
// No sé si sea útil, pero un conjunto podría tener elementos de diferentes dimensiones
conjunto_vector = {1, (1,2)}
// Y sería necesario un objeto matriz...(?) que convierta conjuntos de vectores // en matrices.
matriz = mat(conjunto_vector_r2)

No sé si tenga sentido lo que digo :sweat_smile:

1 me gusta
16

El tema, si pido declarar la dimensión de los vectores (la matriz puede ser tanto un conjunto de vectores, como un vector en sí mismo), es porque es más fácil para armar la variable por detrás (desde C).

Guardar en un conjunto únicamente un tipo de dimensión, es más fácil para manipular en memoria (y más rápido), sino tenés que estar comprobando que tipo de variable es cada miembro del conjunto.

Por ejemplo, en caso de guardar un conjunto de variables, lo puedo guardar en una estructura, dónde sería:

#include <stdlib.h>

typedef struct{
    char *name;
    float vec3[3];
}vec3;

int main(int argc,char**argv){
    vec3 *conjuntoR3 = (vec*)malloc(sizeof(vec3));
    return 0;
}

Entonces, aunque este no sea hispa así se podría ver por detrás, por lo cual, cada vez que leo que se declara un nuevo conjunto, guardo el nombre del mismo, y su dato en un arreglo. De forma, que cuando se usé, solo tengo que buscar el nombre de la variable y que dato tiene asignado.

El logaritmo sería mucho más complejo, sí tengo que estar viendo que un conjunto puede ser de tipo de dato dinámico, además de poderse guardar varios tipos de dimensión. Además de que mi idea, quizá, no sea tan eficiente.

Si se te ocurre algo para implementar su idea, más que bienvenido en pensar el código para implementarlo. Después de todo, es un proyecto de Sofware Libre, bajo la licencia GNU Public v3, es decir, el código es de todos.