compiler construction - que - ¿Cómo se vería tu propio lenguaje de programación?
mejor lenguaje de programacion web (25)
Comenzaré con las características clave:
- Debe ser un lenguaje homoicónico con soporte poderoso para metaprogramación basada en macros. Esta es una gran ventaja para la productividad (ver Paul Graham superando los promedios )
- Debería ejecutarse en cualquier plataforma y tener un gran soporte para ejecutar código distribuido . Configurar una nube de máquinas debería ser una tarea simple.
- Debe ser de código abierto .
- Debería tener el mayor ecosistema posible de biblioteca y herramienta . Prácticamente, esto significa que debe tener acceso al ecosistema de Java, por lo que probablemente necesite ser un lenguaje de JVM por este motivo.
- Debería ser compatible con la inferencia de tipo . La vida es demasiado corta para que el compilador no solucione los detalles del tipo para ti .....
- Debe ser funcional con énfasis en la inmutablilidad de la estructura de datos. Este es el futuro de los lenguajes avanzados (no estoy disputando que los lenguajes funcionales son difíciles de dominar, pero este lenguaje no es para principiantes ...)
- Debería ser compatible con el desarrollo interactivo , preferiblemente en un entorno similar a REPL donde puede interactuar con el entorno de código en ejecución (potencialmente distribuido).
- Debe proporcionar un excelente soporte de concurrencia sin bloqueos . A medida que nos adentramos en el mundo multinúcleo masivo, los enfoques basados en bloqueo simplemente no van a escalar. La memoria transaccional de software es probablemente el camino a seguir.
- Debe admitir la codificación de bajo nivel cuando sea necesario para el rendimiento. La codificación de alto nivel es excelente el 95% del tiempo, pero a veces solo necesitas manipular los bytes directamente ...
Actualmente, lo más cerca que he encontrado de mi lista de deseos es Clojure , que cumple con la mayoría de estos requisitos.
Dado que el OP se refiere a la sintaxis, daré algunos ejemplos de código:
Funciones arity variables adecuadas, con soporte para grandes listas de argumentos:
(+ 1 2 3 4 5)
=> 15
(apply + (range 10000))
=> 49995000
Acceso interactivo al compilador en tiempo de ejecución:
(def function-string "+")
(def function (compile-string function-string))
(function 7 8 9)
=> 24
Ejecución de código distribuido (estilo MapReduce). Tenga en cuenta que esto implica que el lenguaje / biblioteca puede tomar la función localmente definida some-long-running-function y distribuirla de manera transparente a todos los nodos en el clúster para su ejecución en tiempo de ejecución .
(def my-cluster
(create-compute-cluster :nodes 100 :service "Amazon"))
(defn some-long-running-function [input]
....)
(def reduction-function
(fn [a b]
(do-something-to-reduce a b)))
(def lots-of-inputs (range 10000))
(distributed-map-reduce
my-cluster
some-long-running-function
inputs
reduction-function)
=> (whatever the result of the mapreduce is over the cluster)
Inferencia de tipo apropiada (es decir, el compilador determina que my-function siempre devuelve una cadena y realiza optimizaciones / inferencias en consecuencia:
(def my-function [name]
(str "Hello " name "!"))
(my-function "Bob")
=> "Hello Bob!"
(compile-time-type my-function)
=> [java.lang.String :not-null]
¿Cuál sería su propio lenguaje de programación (supongo que perfecto)? ¡Da un pequeño ejemplo y explica tus nuevas ideas!
Estoy realmente interesado en la sintaxis.
Imagino un lenguaje en el que se deben contar las restricciones precisas sobre la entrada y las variables y el orden de ejecución, y así se puede compilar en un software rápido multiproceso (o clúster).
Y aquí hay una idea interesante: imagine que todas las "declaraciones" dentro de una "función" podrían ejecutarse en cualquier orden. Si algo depende de otra cosa, debe "llamar" explícitamente a la dependencia. Esto haría que el diseño para el paralelismo sea un componente integral del lenguaje.
Lamentablemente, no he invertido suficiente imaginación para encontrar algo más específico.
Los lenguajes de programación perfectos tienden a encontrarse en las novelas de ciencia ficción. Por ejemplo:
- Serie Ender de Orson Scott Card - Para crear debes ir a una dimensión diferente y formar un pensamiento puro en tu mente. Cuando vuelves, lo es.
- Robbert A. Heinlein exploró el concepto de mundo como mito en Número de la bestia
- La Tierra de David Brin tiene programación a través de voces secundarias combinadas con movimientos de los ojos y los dedos.
Todo se reduce al mismo dilema básico. Cualquier lenguaje de programación que no obligue al ser humano a aprender una habilidad tiende a limitar la libertad de pensamiento. El lenguaje natural tampoco es bueno, ya que tiene muchas ambigüedades.
No me importaría uno que combine la libertad con el poder y la sintaxis mínima. Recientemente comencé a aprender lisp, y parece muy bueno hasta ahora.
Me gustaría un lenguaje de programación que haga que las herramientas sean realmente fáciles de escribir correctamente. Método de extracción, colorización, autocompletar, compilación, etc.
Quiero que esto suceda mientras sigo siendo fácil de escribir y fácil de leer.
Me imagino que el mío estaría en algún lugar entre Brainf * ck y LOLCODE, excepto con MÁS paréntesis .
Mi lenguaje óptimo se parecería mucho a Nemerle (sin las restricciones arbitrarias). Realmente se trata de instalaciones de metaprogramación; Debería poder extender o modificar arbitrariamente el idioma de la forma que considere adecuada (punto) para que se ajuste perfectamente al dominio.
Dame macros que me permitan trabajar en el AST de todo el código como desee y puedo construir mi lenguaje perfecto.
Mi lenguaje perfecto me permitiría aumentar la funcionalidad cuando la necesite. Si necesito escribir un pequeño y sencillo programa de utilidad sin clases, podría hacerlo. Si tuviera que usar clases, podría hacerlo también, y si quería escribir una solución completamente orientada a objetos, también podría hacerlo. El enlazador sería lo suficientemente inteligente como para permitirme crear pequeñas utilidades rápidas de línea de comandos (sin dependencias de tiempo de ejecución) o la aplicación de interfaz gráfica de usuario de OOP más grande que pueda imaginar.
El problema es que lo que me gusta tiene objetivos opuestos y, por lo tanto, siempre me han obligado a utilizar idiomas completamente diferentes. Actualmente utilizo PowerShell, VBScript, PowerBasic, Java y C # (y algunas veces VB .NET, VB 6, C ++, Python y Perl).
Ahora, si pudiera hacerlo todo con un lenguaje similar a C # que tuviera funciones globales sin dependencias de tiempo de ejecución al crear esas aplicaciones pequeñas, pero permítanme hacer un uso completo del poder de .NET Framework y Java SDK cuando lo necesite, '' ser feliz.
No estoy seguro de cómo se vería el lenguaje de mis sueños, pero tengo una pequeña mejora para los lenguajes de estilo C. ¿Cuántas veces he escrito algo como esto?
Node foundNode = null; // need stupid null value here to keep track if it was not found
foreach (Node testNode in nodes) {
if (testNode.YesItsMe) {
foundNode = testNode;
break;
}
}
if (foundNode == null) {
// create new instance
foundNode = new Node(blabla);
}
Sé que hay formas más elegantes y funcionales para esto, pero a veces terminas con un código como este. Una simple declaración de "guardia" ayudaría aquí:
Node foundNode; // no need to initialize anymore
foreach (Node testNode in nodes) {
if (testNode.YesItsMe) {
foundNode = testNode;
break;
}
} guard { // we get here if break was never called
// create new instance
foundNode = new Node(blabla);
}
No tengo el concepto de un lenguaje de programación "perfecto" porque no hay una sola tarea que realizar.
Las diferentes tareas se adaptan a diferentes lenguajes y paradigmas.
Paralelismo masivo potenciado por Amazon Mechanical Turk.
job = "Upvote this answer"
@price = "$0.01"
fork(10000, job, @price)
Se vería como C #. ¡Me encantaría tener a Microsoft!
Sería legible por máquina / grabable, y sería escrito por un software inteligente que toma instrucciones por voz.
Soy un gran admirador de las macros C, pero pensé que sería bueno si pudieras escribir macros o "meta-código" en el mismo idioma que estás usando. (C es un mal ejemplo, esto podría ser bueno en los lenguajes de scripting).
En estos ejemplos, estoy usando llaves para identificar el metacódigo. Sería capaz de ejecutar la fuente a través de un "preprocesador" para expandir el metacódigo. De lo contrario, simplemente se expandiría una vez en el tiempo de ejecución.
print "Your product ID is: ", { print ''"'', generateGUID(), ''"'' }
o
lookupTable[] = {
/* insert code to generate table here
*
* This lets you modify the algorithm easily
* but speeds up the final program.
*
* This would be especially appropriate in
* cases where you would otherwise type out
* the table as a literal (yuck)
*/
}
De vez en cuando tenemos que escribir varias líneas de código muy repetitivo; No puedo pensar en un buen ejemplo en este momento, pero este tipo de pensamiento también sería muy útil en tales situaciones.
Un lenguaje que no tiene estructura ni variables, solo una función.
doEverything (); // generación automática de todo el contenido basado en la entrada ya predicho
Clojure se está acercando bastante ...
Jon tiene razón al decir que "[d] las tareas diferentes se adaptan a diferentes lenguajes y paradigmas". Sin embargo, hay algunas consideraciones que son en gran medida independientes del dominio. En su mayoría se refieren a la sintaxis, pero dado que el código se lee con más frecuencia que el escrito, en realidad creo que la sintaxis importa.
Por un lado, y algo que muchos lenguajes hacen mal, es completamente arbitrario basar la sintaxis en C. C en realidad tiene una sintaxis excepcionalmente mala. Voy a elegir dos ejemplos.
El primero es bastante indiscutible: los puntos y comas son innecesarios. Toma el siguiente código; la gramática es completamente inequívoca y fácil de analizar para un compilador. Ni los puntos y comas ni las continuaciones de línea explícitas son necesarios.
answer = 42
fraction = answer * 2 /
(answer + 1)
Console.WriteLine(
"Some funny number: {0}",
fraction
)
Esto es realmente bastante similar a Python, pero aún más permisivo: la definición de fraction abarca múltiples líneas. Esto es lógico ya que la primera línea aún no está completa.
Otro hueso que tengo que elegir con sintaxis tipo C son sus declaraciones de variables en gran medida implícitas. En lugar de anunciar claramente "Estoy declarando una variable de tipo Foo ", todo lo que susurran tímidamente es " Foo var ". Como Foo ni siquiera es una palabra reservada en la mayoría de los casos, al programador no se le ofrece una sola pista visual aquí. Prefiero el Dim var As Foo explícito Dim var As Foo VB, incluso pensé que la palabra clave utilizada aquí es, bueno, bastante tenue.
(C ++ en realidad hace las cosas mucho, mucho peor al introducir una gran cantidad de sintaxis casi idénticas y a menudo ambiguas que significan cosas completamente diferentes, desde inicializaciones de variables a declaraciones de funciones).
Otra cosa que mi lenguaje debería tener es tipeo estático. Es cierto que la tipificación dinámica tiene sus usos, pero son sorprendentemente raros. Incluso la mayoría de los "lenguajes de scripting" realmente no los necesitarían. Creo que esto a menudo se confunde con tipeo implícito que tiene bastante más usos. Tome (nuevamente) el ejemplo de Python. ¿Por qué no ofrece tipeo estático? Ya está fuertemente tipado, la comprobación estática de tipos solo sería consecuente y reduciría un poco la depuración. Lo mismo vale para la declaración de variables explícitas. No veo las ventajas que ofrece la declaración variable.
Entonces, ya tenemos un esquema para un idioma:
- Limpie la sintaxis, evite el desorden histórico. En particular:
- Sin punto y coma
- No hay continuación de línea explícita a la VB
- Declaraciones de variables explícitas
- Tipado estático
Además, soy un gran admirador de ciertos conceptos de C ++, como plantillas de propósito general, RAII (es decir, evitar basura en lugar de recogerla), inmutabilidad y el concepto de rangos de valores definidos a través de iteradores. He afirmado en otro lugar que creo que los iteradores son una de las innovaciones más fundamentales de la historia. Déles un poco de lápiz labial y ni siquiera reconocerán la bestia fea que es C ++:
for i in MyVector:
print(i)
más bien que
for (typename vector<T>::const_iterator i = MyVector.begin();
i != MyVector.end();
++i)
cout << *i << endl;
Por supuesto, soy consciente de que la sintaxis anterior la ofrecen muchos idiomas. Pero todos ellos solo ofrecen versiones suavizadas del potente concepto de iterador de C ++ (para usar la terminología C ++, el único tipo de iteradores que la mayoría de los lenguajes saben que son iteradores de entrada, que son básicamente los iteradores menos poderosos).
En este punto, probablemente debería decir que el único derecho de autor para todas estas ideas es el mío, patentes pendientes (en particular para el operador MayOrMayNotBe que realmente no compara referencias de objetos).
Python es bastante ideal para mí ... Me gustaría deshacerme de algunas molestias como tener la palabra clave auto ... pero con un buen editor, Python puede hacer cosas increíbles muy rápido ...
Mi lenguaje de programación ideal, el código sería inteligente, me diría si tenía un problema con otro código, nos sentaríamos a conversar y me diría cuál era su problema para poder resolverlo ... Lo llamo "EmotionPeople ++"
No sería muy diferente de tomar las mejores ideas de Eiffel y C # (porque, evidentemente, no tengo el conocimiento para encontrar algo mejor, no he estudiado CS en primer lugar).
Sin embargo, mi principal preocupación práctica sería ir un paso más allá del enfoque clásico del "texto del código fuente" . Sé que esto es (o suena) algo IDE, pero ¿por qué no puedo tener una vista de código configurable con columnas como precondiciones / cuerpo / postcondiciones en lugar de una forma "lineal" (i):
function f
// f''s preconditions
// f''s body
// f''s postconditions
end
function g
// g''s preconditions
// g''s body
// g''s postconditions
end
¿Por qué no? (Ii) imagina que esta es una tabla (con bordes):
f f''s parameters f''s prec f''s body f''s postc f''s comments
g g''s parameters g''s prec g''s body g''s postc g''s comments
Y también, ¿por qué no puedo elegir cómo las funciones "comienzan" y "terminan" (llaves, palabras clave ...) en el estilo (i)? ¿Por qué no puedo mostrar u ocultar al instante a los miembros privados o protegidos? ¿Por qué no puedo ver instantáneamente la "versión plana" con todas las funciones heredadas dentro? etc.
El punto no sería tener un archivo de código sagrado en el que edite y luego múltiples "vistas geniales", sino que pueda editar y agregar código en ambos (i), (ii) y la forma que sea más útil para usted.
En cierto modo, hablar de "IDE" puede parecer fuera de tema aquí. Pero OTOH creo que esto va a cambiar la forma en que escribimos y leemos el código, tarde o temprano. Y esto finalmente influirá en la forma en que evolucionan los idiomas. Los objetivos futuros serían mejorar no solo la legibilidad sino también la "comprensibilidad" y la interactividad.
Se vería exactamente como Scheme. Solo compilaría tanto el bytecode de IL como el de Java, y el ensamblaje para poder usar todas esas bibliotecas.
Hmm. Esta es una pregunta difícil. Mis gustos se dirigen hacia los lenguajes fácilmente comprensibles y al estilo de scripting ligero (aunque creo que esto podría funcionar para aplicaciones más grandes). Ver fragmento de código:
function Foo takes x as string, y as boolean //can add returns [return type] if one wishes to be explicit
//explicit variable declaration
z as number
//explicit cast from boolean to number
z is y as number
//implicit variable declaration
bar is 3 * 5
//function call
print x
return z / bar //since we casted z to a number, it returns a number
Uno diseña idiomas para cumplir objetivos específicos. La sintaxis y la semántica deberían seguir la función deseada.
En mi caso, quería un lenguaje con paralelismo de grano fino, es decir, muy bajo sobrecarga por grano para permitir la paralelización de pequeños trozos de código.
Lo he diseñado e implementado en sistemas x86 SMP, y ha estado en uso durante aproximadamente 10 años como base para una herramienta de análisis de software a gran escala.
El punto principal era permitirme (nosotros) especificar el paralelismo fácilmente:
(|| A B)
hace A y B en paralelo, y permite que el compilador genere todo el crud que lo hace posible. No nos importó si la sintaxis era infija o no, así que usamos el estilo LISP para evitar los argumentos.
Puede encontrar un documento que describe el idioma y una serie de aplicaciones paralelas en http://www.semanticdesigns.com/Company/Publications/parallelism-in-symbolic-computation.pdf
El documento discute brevemente cómo no logramos evitar los argumentos sobre la sintaxis a pesar de nuestra decisión.
Multimedia.
Quiero poder garabatear algunos símbolos gráficos, bosquejar rápidamente las conexiones y luego cambiar a otros modos, como escribir donde se necesita precisión.
También creo que los lenguajes de programación deberían apoyar a las personas que no piensan en inglés (sí, incluso los estadounidenses ... ¡bromeando!). Estudié suficiente japonés y traté de aprender algo de indonesio. Me gustaría ver un lenguaje que respalde a las personas con diferentes construcciones y órdenes gramaticales.
Planteé una pregunta en un foro reciente al que asistí sobre el futuro de la web, preguntándole a un profesor chino visitante si pensaba que el lenguaje escrito chino sería más probable que permitiera una web semántica viable que el inglés. Estaba intrigado por la idea.
Una gran cantidad de SF que leo habla sobre UI futuras para la interacción de la computadora:
- varitas de datos en la serie Lt Leary de David Drake (algunas de las cuales están disponibles sin cargo en Baen )
- conjuntos de gestos y vocalizaciones favoritas multimodales en Matadora y otras menciones informales en la serie Matador de Perry
- interfaz de usuario basada en lápiz y gestos, incluida la firma para sellar el registro en Fool''s War
Me gustaría ver un recurso para que una función incluya un número arbitrario de parámetros de referencia y los transfiera a una llamada de función anidada. En .net, uno podría hacer esto para cualquier cantidad fija de parámetros genéricos, a través de algo así como (se muestra la versión de dos parámetros extra):
// I forget the C# syntax for delegates, since I normally code in vb delegate void RefAction<T1, T2, T3>(ref T1 p1, ref T2 t2, ref T3 p3); Point myPoints[]; void DoSomethingWithIndexedPoint<XT1, XT2>(int index, RefAction<Point, XT1, XT2) theAction, ref XT1 xp1, ref XT2 xp2) { theAction(myPoints[index], xp1, xp2); }
Mi sintaxis preferida sería algo así como:
delegate void RefAction<T1, T2, T3>(ref T1 p1, ref T2 t2, ref T3 p3); Point myPoints[]; void DoSomethingWithIndexedPoint<ref ...>(int index, RefAction<Point, ref ...>, ref ...) theAction, ref XT1 xp1, ref XT2 xp2) { theAction(myPoints[index], ...); }
donde el "..." se expandiría automáticamente por el compilador de la manera que sea apropiada. Tal instalación haría posible el uso de Lambdas en muchas situaciones sin tener que generar instancias de cierre, y también permitiría hacer código como:
Interlocked.CompareExchange(SomeObject["George"], SomeValue, SomeOtherValue);
que el compilador podría reescribir como algo similar a:
SomeObject.ActUponProperty("George", (ref dest, ref p1, ref p2) => {Interlocked.CompareExchange(dest, p1, p2);}, SomeValue, SomeOtherValue);
Tenga en cuenta que debido a que la expresión lambda no usaría ningún miembro de instancia o variables que no sean las pasadas como parámetros ref, podría implementarse como una función estática y no necesitaría generar un cierre.
Un poco críptico, pero esto es lo que me gustaría: