¿A qué desea que presten atención los diseñadores de idiomas? [cerrado]

El propósito de esta pregunta no es reunir una lista exhaustiva de características del lenguaje de programación sin las cuales no puede vivir o que desearía estar en su idioma principal de elección. El propósito de esta pregunta es sacar a la luz los rincones del diseño en lenguaje que la mayoría de los diseñadores de idiomas podrían no pensar. Entonces, en lugar de pensar en la característica X del lenguaje, piense un poco más filosóficamente.

Uno de mis prejuicios, y quizás podría ser controvertido, es que el lado más suave de la ingeniería, los por qué y para qué, son muchas veces más importantes que el lado más concreto. Por ejemplo, Ruby fue diseñado con el objetivo declarado de mejorar la felicidad del desarrollador. Si bien sus opiniones pueden ser mixtas sobre si se cumplió o no, el hecho de que fuera un objetivo significa que algunas de las opciones en el diseño del lenguaje fueron influenciadas por esa filosofía.

Por favor no publiques:

• La sintaxis llama guerras. Seamos realistas, tenemos nuestras preferencias, y la sintaxis es importante en lo que respecta al diseño del lenguaje. Solo quiero evitar batallas épicas de la naturaleza de emacs vs. VI (de las cuales una gran cantidad de personas en la actualidad no saben nada).
• Los comentarios de tipo "Cualquier lenguaje que no tenga la característica X no merece existir". Hay al menos una razón para que existan todos los lenguajes de programación: buenos o malos.

Por favor, haga mensaje:

• Ideas filisóficas que los diseñadores de idiomas parecen perder.
• Conceptos técnicos que parecen estar mal implementados la mayoría de las veces. Proporcione un ejemplo del dolor que causa y si tiene alguna idea de cómo preferiría que funcionara.
• Las cosas que deseas estar en la biblioteca común de la plataforma, pero rara vez lo están. De la misma manera, las cosas que generalmente están en una biblioteca común que desearías no estaban.
• Las características conceptuales, como la compatibilidad integrada con el manejo de prueba / afirmación / contrato / error que desea que todos los lenguajes de programación se implementen correctamente y definan correctamente.

Espero que este sea un tema divertido y estimulante.

Editar: se aclaró lo que quiero decir con Syntax Flame Wars. No estoy tratando de evitar toda discusión sobre la sintaxis, particularmente porque la sintaxis es una parte fundamental del diseño del lenguaje del programa.

Soporte Unicode por defecto

Hoy en día, los programas se están desarrollando para ser utilizados internacionalmente, o bajo el supuesto de que podrían usarse internacionalmente. Ellos deben proporcionar soporte para sus conjuntos de caracteres o hacer que los programas escritos en esa lengua inútil.

Tengo un par:

• Genéricos / plantillas. Por ejemplo, los genéricos de Java son potentes, pero no necesariamente flexibles. Además, debido a que usan borrado de tipo, he visto problemas para implementarlos de manera abstracta, especialmente en las interfaces. Y el compilador no debería advertir cuando se usa un genérico no específico (Me gusta en Hashmaplugar de Hashmap<String, int>). Creo que podrían mejorarse significativamente. Una buena plantilla es muy útil, pero a menudo se descuida.

• Buena fecha de soporte en la biblioteca estándar. Me refiero a poder sumar y restar fechas, horas y minutos, y no tener que lidiar con la cantidad de milisegundos desde el 1 de enero de 1970.

Haga que su idioma sea analizable / auditable para las personas de seguridad informática.

La gente de seguridad necesita poder encontrar vulnerabilidades en un programa antes de que se envíe. Idealmente, nos llaman temprano y podemos comentar sobre la base de código a medida que se desarrolla, pero a menudo no.

Cuando sale una nueva versión del idioma o las bibliotecas principales, las cosas que antes eran seguras pueden dejar de ser:

1. las bibliotecas pueden volverse más potentes: por ejemplo, la biblioteca de URL ahora admite javascript:
2. puede haber nuevas formas de convertir cadenas o bytes en código: por ejemplo, evalbibliotecas de deserialización
3. las técnicas de reflexión del lenguaje pueden volverse más poderosas: por ejemplo, exponer variables locales

Cualquiera de estos cambios puede aumentar la cantidad de autoridad abusiva que tiene un programa, pero dado que la cantidad de autoridad que usa el programa (cuando se trata con clientes no maliciosos) no ha cambiado, es difícil presionar a la gente de seguridad sin que sea intensiva volver a auditar.

Por lo tanto, piense en nosotros al diseñar y versionar el idioma. A continuación hay algunos consejos:

Defina algunas primitivas en las que se puede descomponer un programa.

HTML5 es particularmente malo de esta manera. Tienen obviamente poner un montón de pensamiento en la seguridad y tienen algunas personas muy inteligentes, pero en lugar de especificar nuevos elementos del programa como <video>en términos de los antiguos, o la creación de una abstracción comunes que los nuevos <video>y viejos <img>tanto se puede especificar en términos de, <video>es todavía otro elemento único del programa con sus propias consecuencias de seguridad.

Haga que su lenguaje sea susceptible al análisis estático (incluso si no está estáticamente escrito).

La gente de seguridad a menudo usa el análisis estático para encontrar patrones y para tratar de descartar partes de un programa para que puedan enfocarse en las partes realmente difíciles.

Debería ser obvio qué identificadores son variables locales y cuáles no.

Por ejemplo, no cometa el mismo error que las versiones anteriores de JavaScript, lo que hizo imposible saber si se xtrata de una referencia de variable local en el siguiente (según una lectura literal de una versión anterior de la especificación):

if (Math.random() > 0.5) {
  Object.prototype.x = 0;
}

function f() {
  var x = 1;
  (function () {
    alert(x);  // Might alert 0, might alert 1.
  })();
}

Permitir seguridad descomponible

Muchos sistemas seguros están diseñados en torno a un núcleo seguro que conserva las propiedades de seguridad, de modo que la gente de seguridad pueda centrar sus esfuerzos en analizar una pequeña cantidad de código y liberar a la mayoría de los programadores de tener que lidiar con gente de seguridad {molesta, pedante, paranoica} .

Debería ser posible escribir dicho núcleo en su idioma. Si una de las propiedades de seguridad de su idioma es que solo se recuperará un cierto subconjunto de URL, ¿pueden los escritores del kernel hacer algo para canalizar todas las recuperaciones de URL a través de su código? O las comprobaciones de compilación estáticas (como mirar las importaciones) cumplen la misma función.

Algunos lenguajes como Newspeak usan un modelo de capacidades de objeto. Eso es increíble y una excelente manera de obtener seguridad descomponible.

Pero si no puede hacer eso, hacer que el gráfico del módulo sea un artefacto analizable estáticamente puede brindarle un gran beneficio. Si puedo demostrar que un módulo no puede alcanzar el módulo de E / S de archivo (excepto llamando al código en un módulo en el TCB), entonces puedo descartar clases completas de problemas de ese módulo.

Limite la autoridad de los lenguajes de script incrustados

Muchos sistemas útiles están organizados como un núcleo estático que inicia una gran cantidad de código escrito en lenguajes dinámicos (incluso funcionales).

Y la incorporación de lenguajes de secuencias de comandos puede hacer que un sistema sea mucho más extensible.

Pero un lenguaje de secuencias de comandos no debería tener toda la autoridad de la VM.

Si elige permitir los lenguajes de secuencias de comandos incrustados, facilite al invocador limitar lo que puede hacer. Un modelo de capacidades de objeto (ver comentario en Newspeak arriba) es muy apropiado aquí; entonces, al evaluar el código en un lenguaje de scripting, la persona que llama debe pasar el código para ejecutar y todas las variables globales para ese código.

Tratar evalcomo un lenguaje incrustado como un lenguaje de script

Si su idioma puede invocar su propio compilador para convertir una cadena en código, entonces permita que esté en modo sandbox de la misma manera que lo haría con cualquier lenguaje de script incorporado.

Use un modelo de concurrencia simple

A las personas de seguridad no nos gusta tener que preocuparnos por las condiciones de carrera cuando intentamos averiguar si se mantiene una propiedad de seguridad.

Considere alternativas al subproceso antes de establecer subprocesos como una opción predeterminada casi imposible de proteger.

Una simple es la concurrencia de bucles de eventos como la que se encuentra en E, Verilog y JavaScript.

No aliente la confusión de citas

Algunos idiomas son idiomas de pegamento y terminan tratando con cadenas en muchos idiomas diferentes.

Por ejemplo, JavaScript a menudo compone cadenas de HTML, CSS, XML, JSON e incluso JavaScript. Es muy difícil para los programadores recordar codificar correctamente cadenas de texto sin formato cuando se combinan para crear cadenas en otros idiomas, por lo que los programas JS, como era de esperar, tienen todo tipo de problemas de confusión: XSS es el peor.

Si desea incluir características de composición de cadenas, intente reducir la carga de seguridad del programador. Las DSL, las macros higiénicas y los lenguajes de plantillas integrados pueden ser una excelente manera de hacerlo al trasladar la carga de escapar adecuadamente a los desarrolladores de bibliotecas o idiomas y alejarlos del desarrollador final.

Algunos de los mejores idiomas fueron diseñados por personas que querían hacer un idioma por sí mismos.

Así que creo que los diseñadores de idiomas deberían prestar menos atención a sus usuarios. No puedes complacer a todos, tampoco deberías intentarlo.

Solo se pasa del 5 al 10% del tiempo escribiendo código. Los diseñadores de idiomas deben prestar atención a las dificultades de hacer que el software funcione, lo que significa corregir errores y errores.

Eso significa que desde el principio debería haber un buen depurador. No es una herramienta con sintaxis arcana y comandos de teclado que sea solo un poco mejor que toneladas de declaraciones de impresión.

Creo que deberían prestar atención a Python, que hace más cosas bien que cualquier otro lenguaje que haya encontrado (y eso incluso si no le gustan algunas de las características). Eso no significa que deberían emular Python, pero es importante saber qué hizo Python correctamente, incluso si no desea crear un lenguaje como Python.

En cuanto a las ideas filosóficas que son relevantes allí, estas son las más importantes del Zen de Python:

• Explícito es mejor que implícito.
• La legibilidad cuenta.
• Los casos especiales no son lo suficientemente especiales como para romper las reglas.
• Aunque la practicidad supera la pureza.
• Debe haber una, y preferiblemente solo una, forma obvia de hacerlo.
• Si la implementación es difícil de explicar, es una mala idea.
• Los espacios de nombres son una gran idea, ¡hagamos más de eso!

Creo que un lenguaje que sigue estas reglas necesariamente debe estar bastante bien, pero solo conozco uno que haga esto, y ese es Python. Para todas las similitudes con, por ejemplo, Ruby en la implementación, Ruby se pierde en cosas como la legibilidad y lo invita a hacer golf en código, lo cual es divertido, pero no es útil en un entorno profesional.

La única característica técnica que extraño en Python es una declaración "hasta" (como while, pero no prueba la expresión la primera vez). Luego, hay muchas cosas en Python y en otras bibliotecas estándar de idiomas que podrían mejorarse, pero eso no es estrictamente idiomas , por lo que esa es una pregunta diferente. :-)

La capacidad de modificar el idioma para satisfacer sus necesidades es muy importante para mí. Para Lisp que se hace con macros, para Tcl con nivel superior. En menor medida, Ruby usa lambdas y similares. Solo quiero la capacidad de agregar nuevas estructuras de control que se adapten al problema en lugar de moldear mis problemas en torno a las estructuras de control disponibles. Como ejemplo simple, la construcción "hacer ... hasta" que existe en algunos idiomas pero no en otro es una forma más limpia de manejar algunos casos que "while", es extremadamente útil poder agregar nuevas estructuras para resolver otros casos.

En el sentido más general, esto es metaprogramación ... pero la uso principalmente para construir nuevas estructuras de control.

Lo más importante es que su idioma debe tener un "estilo". Por ejemplo, llamaría a C un lenguaje de programación de sistemas basado en punteros. Llamaría a Erlang un lenguaje de programación funcional altamente concurrente. Algunos otros lenguajes (como C ++ y posiblemente Java) son lo que Allan Kay llamó lenguajes "aglutinantes": los lenguajes de Frankenstein consistían en un conjunto de características unidas entre sí.

El siguiente punto más importante es que los cambios en el lenguaje en sí deberían ser el último recurso. Incluso el sonido más benigno puede volverse complejo cuando se combina con las otras características del lenguaje. Diría que para poner una nueva función en un idioma, debe:

1. Demuestre que es realmente necesario.
2. Probar que no se puede hacer en una biblioteca.
3. Demuestra que pertenece al idioma.

Gracias por una gran pregunta Estás obteniendo algunas respuestas bastante buenas.

No es un esmalte sobre tus ojos, pero veo a un programador como un canal de información. Las ideas / conceptos / requisitos van en un extremo y el código sale en el otro.

Si toma un conjunto de requisitos (no importa cómo se establezcan) y el conjunto de código en una enorme pizarra, y dibuja líneas que mapean cada requisito al código que lo implementa, la complejidad de ese gráfico dependerá de qué tan bien el código expresa los requisitos Idealmente, debería ser bastante directo y uno a uno, pero eso es difícil de practicar.

Mido la especificidad de dominio de un lenguaje como la medida en que simplifica ese gráfico. Esa es una propiedad extremadamente deseable, y puede abordarse de muchas maneras, desde definir las clases / rutinas correctas (sustantivos / verbos), hasta macros, hasta escribir su propio analizador e intérprete / compilador.

Permítanme dar un ejemplo de lo que quiero decir. Para el problema de crear interfaces de usuario de diálogo flexibles, esta técnica elimina la necesidad de escribir controladores de eventos, movimiento de datos, la mayoría de las cosas que normalmente se hacen en las IU. También da como resultado una reducción del código fuente de aproximadamente un orden de magnitud. El metalenguaje es realmente solo unas pocas rutinas y macros en C / C ++ / Lisp, y también lo he hecho en lenguajes sin macros.

Si la implementación de un requisito se puede hacer con ediciones de 5 puntos en el código, o con 10, hacerlo con 5 no solo es menos código, sino menos posibilidades de perder un paso y poner un error. Por lo tanto, cuanto más específico es el dominio de un idioma, más pequeño, más fácil de mantener y más libre de errores es el código. Creo que necesitamos saber cómo conducir hacia eso. Lo hace , no significa que el código es más legible, a no ser que el lector ha invertido en la curva de aprendizaje para entender la técnica.

Tipos enteros delimitados y distintos como en Pascal y Ada. Honestamente: ¿con qué frecuencia necesita el rango completo de cualquier número entero? Creo que hay mucho que mejorar en los tipos primitivos para representar mejor el mundo real.

Hay características que hacen que los lenguajes de programación sean fáciles de usar una vez que los aprende, y hay características que los hacen fáciles de aprender a usar. Dado que los usuarios de un idioma idealmente tienen una relación a largo plazo con él, la optimización para facilitar su uso es mejor que la optimización para facilitar el aprendizaje. No haga las cosas más difíciles de lo necesario, pero no sacrifique la expresividad (poder escribir un pequeño código que haga mucho) para facilitar la lectura a aquellos que no están familiarizados con el idioma. Por otro lado, el lenguaje no debería leerse como ruido de línea para las personas que han estado trabajando con él durante años; eso no sería fácil de usar o aprender.

Convenciones de nomenclatura (te estoy mirando PHP)

Integración de primera clase con entornos de desarrollo.

Hoy en día, la codificación se realiza en un entorno rico. Para HTML / CSS / JS, tenemos Firebug y otras herramientas interactivas. Para Java, Eclipse e IDEA y otros IDEs verdaderos. Etcétera. Existe una ecología de herramientas, que comienza con el editor pero no termina allí:

• Organización del código dentro y entre archivos
• Resaltado inteligente
• Finalización inteligente / mecanografía predictiva
• Depuración estática (sintaxis de marcado, errores semánticos y estilísticos)
• Creación y uso de plantillas y macros.
• Control de versiones (versionado, fusión, ramificación, ...)
• Desarrollo distribuido con múltiples autores (comentarios, documentos en línea, anotaciones, ...)
• Depuración en tiempo de ejecución (seguimientos de pila, pasos, relojes, ...)
• Depuración interactiva "en vivo" (como Firebug: comportamiento de edición de un sistema en vivo)
• ... Ni siquiera sé qué sigue.

Los idiomas deben construirse para brindar apoyo a estas actividades. Se han realizado algunos progresos: anotaciones en Java para ayudar a otros desarrolladores a comprender la intención del código, por ejemplo.

Pero en su mayoría son cosas pirateadas, como usar $ Id $ en un comentario para que la fuente controlada por CVS pueda contener un número de versión. ¿Por qué no puedo hacer algo así desde el lenguaje mismo?

Computación Distribuida

El almuerzo gratis ha terminado. Hoy en día uno necesita programas que se ejecuten en múltiples núcleos / procesadores múltiples (y en circunstancias especiales múltiples computadoras).

Desafortunadamente, escribir código multiproceso es difícil desde el punto de vista conceptual, por lo que realmente no hay necesidad de agregar el idioma como barrera.

C ++ 0x uso del futuro es ciertamente interesante, por todo lo que trae como biblioteca y no lo libera de los problemas de sincronización reales (ya sabe, aquellos que son tan fáciles de resolver ...)

Me gusta mucho ir el enfoque de sobre el problema: el subprocesamiento múltiple está incorporado, y el enfoque adoptado (canales y gorutinas) establece una mentalidad mucho más fácil que los enfoques tradicionales de semáforo / mutex / bloqueo. Sin embargo, todavía es fácil acceder a una estructura no sincronizada simultáneamente (Go tiene punteros) o al punto muerto (ciclo de espera en los canales ...)

Creo que los idiomas que favorecen la inmutabilidad de los datos, como los lenguajes funcionales, pueden tener el derecho de hacerlo (aunque me gusta la experiencia allí).

Además, el modelo de actor puede ser nuestro próximo objetivo. También estaba destinado a la informática distribuida.

Llámame loco, pero una de las características del lenguaje más importantes para mí es la disponibilidad de una buena referencia en línea, junto con ejemplos. Sé que puedo encontrar buenos resultados de búsqueda para cualquier idioma, pero realmente me gusta el sitio de MSDN y API de Java. Hacen la programación mucho más fácil para una persona que no tiene mucha experiencia en el lenguaje específico.

Más capacidad para ayudar al compilador a verificar su código.

Al ser un programador de sistemas embebidos, siempre uso C. Pero siempre deseo tener más / mejores formas de decirle al compilador qué espero de mi código para que pueda verificarlo.

Por ejemplo, puedo tener una función

f(int x)

pero preferiría

f(int range[-5..25] x)

Por ejemplo, me gustaría poder escribir aserciones sobre funciones utilizando algún tipo de lenguaje funcional de nivel superior como Lisp o Haskell. Estos no se compilarían en código, pero podrían usarse para análisis estáticos o dinámicos.

Sintaxis pequeña con la menor cantidad de palabras clave posible porque la sintaxis detallada es difícil de aprender y no ayuda a la legibilidad.

El peor ejemplo es Ada:

procedure Hello is
begin
  Put_Line("Hello World!");
end Hello;

Las palabras de relleno como is, as, .. no tienen sentido para los lenguajes de programación.

Me gustaría ver más idiomas de aprendizaje . No solo idiomas para principiantes absolutos con restricciones más santas que tú, como requerir un espacio entre cada token , sino idiomas para personas que ya conocen la programación y quieren aprender nuevos conceptos o mejorar la programación en general.

Para mí, Haskell es un gran ejemplo de lo que quiero decir con un "lenguaje de aprendizaje" (aunque también ha crecido en popularidad y utilidad general a lo largo de los años). Al abandonar la sintaxis familiar de C y tener operadores de composición de funciones hacia atrás (por ejemplo, (+2) . (*3)es una función que se multiplica por 3, luego agrega 2), Haskell me enseñó a escribir funciones más cortas. Su despiadado verificador de tipos me ayudó a aprender el idioma más rápido y mejoró mi capacidad de pensar lógicamente sobre el código. Ambos beneficios se han extendido a otros idiomas, incluso el ensamblaje.

Los objetivos de aprender idiomas y los de los idiomas de uso general a menudo están en conflicto. Un lenguaje de aprendizaje debe ser desafiante y gratificante de aprender, y debe imponer un estilo particular, incluso si ese estilo no es el mejor para muchas aplicaciones. Un lenguaje de propósito general debe ser bueno para hacer cosas, y el uso de abstracciones debe medirse cuidadosamente y "tener sentido". Por ejemplo, al arreglar un sitio web, aprender sobre mónadas sería lo último en la mente de un programador. En el otro lado de la moneda, cuando alguien está aprendiendo a programar, no debería tener que meterse en tonterías de "vacío público estático" si aún no se han enterado de las funciones.

Si es diseñador de idiomas, decida si su idioma es un idioma de aprendizaje o un idioma aplicado. Esto determinará en qué medida querrá emplear la pureza en su diseño.

Desde que estamos en 2011,

• Una especificación absolutamente completa. sin agujeros dependientes de la arquitectura como en C

• soporte multihilo; no solo funciones de sincronización (bloqueos), sino también funciones de lenguaje que hacen que el subprocesamiento múltiple sea tan fácil como escribir un bucle:

  all (o en myCollection) {o.someMethod ()}

• multi-paradigma; permítame, el programador, decidir si quiero la seguridad en tiempo de compilación de un lenguaje estático o la brevedad de un lenguaje dinámico, caso por caso; dame características orientadas a objetos, características funcionales, etc.

• consistencia (sé que está pidiendo un poco tanto por consistencia como por paradigma múltiple ...)

Procesos ligeros

Me gustaría tener procesos ligeros como en Erlang. Es principalmente un problema para el tiempo de ejecución. Esto falta en JVM y .NET CLR. LWP ayuda a crear software masivamente concurrente. Idealmente, no debería ser más costoso crear un proceso, ya que es crear un objeto en un lenguaje. Me gustaría crear millones de procesos en mis aplicaciones.

Se implementa como un grupo de subprocesos con programación preventiva, por lo que una sola tarea no bloquea la otra tarea, y las tareas se pueden programar en cualquier cpu-core disponible.

Soporte para la recursividad de la cola.

Me gustaría tener soporte para la recursividad de cola. Esto también puede ser un problema para el entorno de tiempo de ejecución. Por ejemplo, JVM no tiene soporte para la recursión de cola.

Programación distribuida fácil

Me gustaría tener soporte para enviar ( ! ) Y recibir primitivas a partes de la aplicación que se ejecutan en otras máquinas en la misma red que en Erlang. Esto facilita la creación de aplicaciones escalables, por ejemplo, almacenes de datos distribuidos. Además de esa serialización incorporada en el lenguaje, también es muy útil como en erlang. Y no como en Java, tengo que hacerlo manualmente.

Facilitar la metaprogramación.

limitar formas especiales

En Python no hay una buena razón por la cual imprimirlo no sea una función integrada. Se ve y actúa como una función, excepto por no querer tener nada que ver con los padres.

¿Es realmente necesario for, foreach,while y similares cada uno como su propia forma especial. ¿Qué tal una construcción de bucle y algunas macros predeterminadas para proporcionar el azúcar sintáctico de las formas de bucle variantes?

metaprogramación para formas especiales

form['if'](test-fn, body-fn)

Capacidades de red

Un lenguaje que se envía sin algún soporte de red es bastante aburrido en el mundo de hoy.

La mayoría de las aplicaciones del mundo real necesitan comunicarse a través de algún tipo de red:

• Actualización automática
• acceso a la base de datos
• servicios web

También es una piedra angular del soporte de computación distribuida / en la nube, por supuesto.

Me gusta un lenguaje de programación que sea fácil de aprender y fácil de combinar para crear cosas nuevas.

Por ejemplo, si bien es atractivo tener muchas formas de escribir algo, creo que es mejor tener solo una o dos formas de escribirlo. De esa manera, el programa es más fácil de mantener.

Un lenguaje cuyos conceptos pueden aplicarse a todos los elementos es muy útil (creo que esto se llama ortogonalidad). Por lo tanto, la próxima vez que se enfrente a una nueva característica del lenguaje, puede deducir cómo usarla.

Entiendo que a veces la sintaxis del lenguaje debe interponerse para lograr un mejor desempeño en la fase de compilación / interpretación, pero a veces siento que el diseñador del lenguaje difiere este trabajo al desarrollador. Por ejemplo, cadenas multilínea en Java o Javascript.

Finalmente, la sintaxis del lenguaje es su interfaz de usuario y, como tal, debe ser clara, concisa, intuitiva, fácil de usar y debe respetar sus hábitos.

• Legibilidad : cuanto menor / menor sean los símbolos utilizados en la gramática, más limpio y mejor.
• Tipos orientados a objetos : métodos, no funciones.
• Comprensibilidad : interfaces fluidas incorporadas, nombres completos y cortos para clases / interfaces de biblioteca y otros.

Agregar una función a un lenguaje de programación existente. Entonces, el nuevo idioma B es el antiguo lenguaje A más la función X.

Ejemplos existentes:

1. C agregando clases => C ++
2. Java agregando algunas cosas => C #

Cuando se trata de tecnología / plataforma / idioma / base de datos, etc., la mayoría de las veces se trata de rendimiento. En el futuro, muchos softwares actuales pueden diseñarse utilizando un lenguaje gráfico, ya que tenemos más poder computacional.

Espero el día en que tengamos poder computacional y un lenguaje en el que diseñe su aplicación y no tenga que preocuparse por los detalles del idioma .

Actualización: envío un enlace a dicho lenguaje LabView

Actualización: debería explicar más lo que quiero decir con "poder computacional". El rendimiento del software compilado puede no ser tan potente como el software compilado basado en el lenguaje de sintaxis. Estoy pensando en la programación gráfica como un mayor nivel de programación y puede haber más sobrecarga. Las computadoras de hoy pueden ejecutar y lo hacen fácilmente lenguajes de programación gráficos.