2020年Julia开发者 【问卷调查】
La anticipada liberación de la versión 1.0 de Julia es la culminación de casi una década de trabajo por programadores ambiciosos. JuliaCon2018 celebró la ocasión con un evento donde la comunidad oficialmente lanzó la versión 1.0.0 juntos..
El primer comunicado de Julia público con número de exigencias sobre el lenguaje:
Queremos un lenguaje que sea de licencia abierta, con licencia libera. Queremos la velocidad de C con el dinamismo de Ruby. Queremos un lenguaje que sea homoicónico, con macros verdaderos tipo Lisp, pero con notación matemática, obvia y familiar como Matlab. Queremos algo usable para programación general como Python, tan fácil para estadísticas como R, tan natural para procesamiento de cadenas como Perl, tan potente para álgebra lineal como Matlab, tan bueno uniendo programas juntos como un shell. Algo que sea sumamente sencillo para aprender, pero que mantenga a los hackers más serios felices. Queremos que sea interactivo y que sea compilado.
Una comunidad vibrante y fructífera ha crecido alrededor de este lenguaje, con gente de todo el mundo iterativamente refinando y reformulado Julia para cumplir su meta. Más de 700 personas han contribuido a Julia en sí y aún más gente han hecho miles de paquetes de código abierto asombrosos. En resumen, hemos construido un lenguaje que es:
Intenta Julia al bajar la versión 1.0 ahora. Si estás actualizando código de Julia 0.6 o versiones anteriroes, te recomendamos que primero uses 0.7 como transición. Una vez que tu código esté libre de warnings, puedes cambiarlo a 1.0 pérdida de funcionalidad. Los paquetes registrados están aprovechando esta etapa de transición y liberando sus actualizaciones compatibles con 1.0.
La ventaja más importante de Julia 1.0 es, por supuesto, es un compromiso de estabilidad de API: código que escribes para Julia 1.0 seguirá funcionando en 1.1, 1.2, etc. El lenguaje está “completo”. Los desarrolladores principales y la comunidad pueden enfocarse en paquetería, herramientas, y nuevas funcionalidades que construir sobre una base sólida.
Pero Julia 1.0 no es sólo sobre estabilidad, también introduce nuevas y poderosas inovaciones del lenguaje. Algunas de estas novedades desde 0.6 incluyen:
Un nuevo e incluido administrador de paquetes trae enormes mejoras de rendimiento y facilita más que nunca la instalación de paquetes y sus dependencias. También soporta ambientos particulares a cada proyecto y registros de estado exactos para una aplicación para poderla compartir con los demás - y tu futuro yo. Finalmente, el rediseño también introduce spoporte integrado para paquetes privados y repositorios. Tú puedes instalar y administrar paqueterías privadas con las mismas herramientas que el ecosistema de paquetería abierta. La presentación de JuliaCon resume el nuevo diseño y capacidades.
Julia tiene una nuueva representación canónica para valores faltantes.
Poder representar y trabajar con datos faltantes es fundamental para estadísticas y ciencias de datos. En estilo Juliano,
la nueva solución es general, componible, y rápida. Cualquier colección general puede eficientemente
soportar valores faltantes simplemente al permitir que elementos incluyan el valor predefinido missing.
El rendimiento de dadas colecciones “tipadas como uniones” hubieran sido demasiado lentas en versiones anteriores
de Julia, pero mejoras de compiladores permiten ahora que Julia sea comparables a la velocidad de valores faltantes
en C ó C++ en otros sistemas, mientras que sigue siendo más general y flexible.
El tipo String ahora puede contener datos arbitrarios. Tu programa no fallará después de horas ó días porque
un sólo byte de Unicode era inválido. Todos los datos de cadenas son preservados mientras que se indica cuáles caracteres
son válidos o inválidos, permitiendo que sus aplicaciones sean conveniente y seguramente usados en datos reales con todas sus
inevitables complicaciones.
“Broadcasting” ya es una ventaja clave con sintáxis conveniente – y ahora es más poderosa que nunca. En Julia 1.0 es fácil extender broadcasting a tipos de usuario e implementarlo en cálculos optimizados para GPUs y hardware vectorizado, pavimentando el camino para aún más mejoras en el futuro.
Las tuplas con nombre son rasgo nuevo que permiete representar y accesar datos por nombre y de manera eficiente. Puedes, por ejemplo,
representar una hilera de datos como row =
(name="Julia", version=v"1.0.0", releases=8) y accesar su columna version como
row.version con la misma velocidad que el inconveniente row[2].
el operador punto puede ser sobrecargado, permitiendo así que tipos usen la sintáxis obj.propiedad para
comportamientos que no sea accesar o fijar campos de structs. Esto es especialmente útil para facilitar
la interoperabilidad con lenguajes basados en clases como Python y Java. Esto también permite sobrecargar la
sintáxis para obtener una columna de datos y que empate con la de tuplas nombradas: puedes escribir
tabla.versión para accesar la columna versión de una tabla ó row.versión accesa el campo
versión de una sóla hilera.
El optimizador de Julia se ha vuelto mucho más listo en demasiadas maneras para aquí enlistarlas, pero algunas de ellas valen mencionar. El optimizador ahora nos permite propagar constantes a través de llamadas a funciones, permitiendo mucha mejor eliminación de código muerto y evaluación estática que antes. El compilador ahora también es mucho mejor evitando alocaciónes de wrappers efímeros alrededor de objetos longevos, permitiendo a los programadores a usar abstracciones de alto nivel sin costo de rendimiento.
Los constructores de tipos paramétricos ahora se llaman con la misma sintáxis con la que se declaran. Esto elimina una barrera rebuscada pero confusa de sintáxis.
El protocolo de iteración ha sido completamente rediseñado para facilitar implementar muchos tipos de
iterables. En vez de —start, next, done—uno ahora define métodos de uno y dos argumentos para la función
iterate. Esto frecuentemente permite que la iteración se defina con un sólo método y un valor por default para
el estado inicial. Aúnado a lo anterior, es posible implementar iteradores que sólo saben si han terminado
una vez que han intentado y fallado en producir un valor – justo el tipo de iteradores que son ubicuos en I/O,
producidores/consumidores, etc. Julia puede expresar estos iteradores directa y correctamente.
Las reglas de alcance han sido simplificadas. Construcciones que introducen alcances locales ahora lo hacen de manera consistente, sin importar los enlaces globales para nombre preexistentes o no. Esto elimina la distinción de alcances “duros/suaves” que previamente existía y significa que Julia siempre puede determinar estáticamente si variables son locales o globales.
El lenguaje en sí es significativamente más esbelto, con muchos componentes siendo escindidos a paquetes en la “biblioteca estándar” que es liberada con Julia pero que no es parte del lenguaje “base”. Si los necesitas, sólo necesitas importar (sin instalar) pero no estarás coaccionada a hacerlo. En el futuro, esto permitirá que las bibliotecas estándar sean versionadas y actualizadas independientemente de Julia, permitiendo que evolucionen y se mejoren más rápido.
Hemos revisado extensamente todas las APIs de Julia para mejorar la consistencia y usabilidad. Muchos nombres rebuscados tradicionales y patrones ineficientes han sido renombrados o refactorizados para empatar elegantemente con las capacidades de Julia. Esto ha promovido cambios para trabajar con colecciones de manera más consistente y coherente, y asegurar que el orden de los argumentos sea un estándar consistente a lo largo del lenguaje, y para incorporar los (ahora más rápidos) argumentos “keyword” en las APIs apropiadas.
Un gran número de paquetería externa ha sido específicamente construida alrededor de las ventajas de Julia 1.0, tales como:
El ecosistema de procesamiento y manipulación de manejo de datos fue reorganizado alrededor de los valores faltantes.
Cassette.jl provee un poderoso mecanismo para inyectar pases de transformación de código al compilador de Julia, permitiendo análisis post-hoc y extensión de código existente. Además de la instrumentación para programadores como un debugger y un profiler, esto también puede implementar diferenciación automática para tareas de machine learning.
Se ha incrementado enormemente el soporte para arquitecturas heterogéneas y se ha desacoplado aún más del funcionamiento interno del compilador. Intel KNLs funcionan en Julia. Los GPUs de Nvidia son programados usando CUDANative.jl y un port para los TPUs de Google está siendo elaborado.
Son sólo algunas mejoras. Para una lista completa de los cambios, lee el archivo 0.7 NEWS. En el post original “Why We Created Julia” blog post en 2012, escribimos
No está completo, pero es tiempo de liberar la versión 1.0 del lenguaje que creamos llamado Julia.
Tal vez nos adelantamos un poco con la versión 1.0, pero el tiempo finalmente ha llegado y es un release fantástico. Estamos verdaderamente orgullosos de lo que hemos logrado con los miles de programadores que han contribuido en tantas maneras a este lenguaje verdaderamente moderno para programación general y numérica.