Software-update: Julia 1.8.0

Julia is de naam van een high-level, high-performance dynamische programmeertaal voor numerieke wiskunde. Het bevat onder andere een krachtige compiler, distributed parallel execution en een uitgebreide library van wiskundige functies. De kern van Julia wordt onder de MIT-licentie uitgegeven, terwijl verschillende libraries andere licenties gebruiken, zoals gpl, lgpl en bsd. Voor meer informatie verwijzen we naar deze pagina. Versie 1.8 is uitgekomen en uitgebreide informatie daarover is op deze pagina te vinden, dit zijn in het kort de hoogtepunten:

Julia 1.8 Highlights

After 3 betas and 4 release candidates, Julia version 1.8 has finally been released. We would like to thank all the contributors to this release and all the testers that helped with finding regressions and issues in the pre-releases. Without you, this release would not have been possible. The full list of changes can be found in the NEWS file, these are some of the release highlights.

• const on fields in mutable structs
• Call site @inline
• Typed globals
• New default scheduler for @threads
• Profiling
  • New allocation profiler
  • Updates to CPU profiling
• Packages
  • Package load timing
  • Pkg status update with upgradable package indicator
  • Pkg support for sysimages
• Improved precompilation
• Improved support for Apple Silicon

Versienummer	1.8.0
Releasestatus	Final
Besturingssystemen	Windows 7, Linux, macOS, Windows Server 2008, Windows Server 2012, Windows 8, Windows 10, Windows Server 2016, Windows Server 2019, Windows 11
Website	JuliaLang
Download	https://julialang.org/downloads/
Licentietype	Voorwaarden (GNU/BSD/etc.)

Reacties (16)

[Bulkzooi]

De taal is een soort kruising tussen Matlab en Pyhton maar draait zo snel als geoptimaliseerde c code.

Voor wie benieuwd is naar wat praktische voorbeelden over hoe je Julia kan gebruiken is de MIT course "computational thinking" wellicht interessant:
https://computationalthinking.mit.edu/Spring21/

Julia Docs v1/

Because Julia's compiler is different from the interpreters used for languages like Python or R, you may find that Julia's performance is unintuitive at first. If you find that something is slow, we highly recommend reading through the Performance Tips section before trying anything else. Once you understand how Julia works, it's easy to write code that's nearly as fast as C.

Meer info over Julia, Python & R op http://www.projecteuler.net 

[Reactie gewijzigd door Bulkzooi op 22 juli 2024 15:02]

[daandaanie]

Hoe komt het dat het zo snel draait? Wordt het omgezet naar machine code?

[GerhardBurger]

Was zelf wel onder de indruk van Figuur 2 + uitleg in deze preprint: https://arxiv.org/abs/2109.09973

Daar leggen ze bijvoorbeeld uit dat een element-wise operatie A*B+C in Python weliswaar wordt afgehandeld in C, maar dat dat in 2 stappen gebeurd, eentje voor A*B -> tmp en dan eentje voor tmp + C. In Julia kan je met een punt aangeven dat iets element-wise moet gebeuren dus A.*B.+C., dan wordt dit door de JIT compiler "gefused" naar 1 functie, en dan heb je dus niet alle overhead van functie calls en temp arrays.

Een ander voorbeeld wat ze bespreken is ODE modeling (een beetje mijn vakgebied), waar ze de vloer aanvegen met solvers uit deSolve (R), SciPy (Python), en zelfs Sundials (C) en Fortran. Wil het zeker nog een keer proberen bij mijn eigen modelen (als ik er ooit tijd voor heb )

[Reactie gewijzigd door GerhardBurger op 22 juli 2024 15:02]

[Thomas M]

Er zijn heel veel JIT gebaseerde programmeertalen of implementaties ervan. En ook heel veel nieuwe programmeertalen (e.g. Rust). En dat komt voor een deel, omdat de Clang(++) compiler modulair ontwikkeld is. Een groot deel van de compiler zit namelijk in wat LLVM heet.

En het is die LLVM die door meer tussenlagen, efficiente code meer mogelijk maakt.

Naast de gecompileerde talen die LLVM gebruiken (Clang(++), Rust, ...), zijn er dus ook JIT gebaseerde talen die LLVM gebruiken, en een daarvan is Julia.

Maar er is ook een andere, en dat is Numba. Dit is begonnen door de persoon die ook Numpy begonnen is, code waarmee bepaalde Python code sneller draait. En Numba/Python is ook zo slecht niet.

[GerhardBurger]

Ah kijk dat is interessant om te weten! Het artikel noemt inderdaad ook Numba in Figuur 2, en daar gebeurd inderdaad ook die operator fusing. Ze merken er wel bij op dat er dan nog steeds een context switch nodig is van Python naar compiled C, maar dat bij Julia alles native is, en dat daardoor het verschil in performance best kan aantikken omdat die functies heel vaak worden aangeroepen.

[Bulkzooi]

Naast de gecompileerde talen die LLVM gebruiken (Clang(++), Rust, ...), zijn er dus ook JIT gebaseerde talen die LLVM gebruiken, en een daarvan is Julia.

Qua talen moet je eerst een onderscheid maken tussen interpreteren en compileren en moderne code is portable. Verder betreft het vooral hoe data-types gedefinieerd zijn, maar bijna alle talen overlappen. Behalve de math functies en de grafische functies; die hebben een andere historie.

Verder is de vraag van belang of je bv. een SPA wil maken, of een GUI App of game voor een appstore. Rust is hierbij aan een opmars bezig, en php, Javascript en Python eindigen langzaam in het verdom-hoekje, hoewel Python wel veel academische support heeft en Javascript veel FOSS software (via NPM) vertegenwoordigd.

Het modulaire heeft veel van de license problematiek opgelost, maar dat geldt ondertussen voor elk sane project.

cc:
@GerhardBurger Wat bedoel je precies met native? Perl en Python zijn toch altijd min of meer native geweest? Alleen Javascript niet, maar tegenwoordig is er WASM.

[Reactie gewijzigd door Bulkzooi op 22 juli 2024 15:02]

[GerhardBurger]

Ik had het overgenomen van dat artikel, volgens mij bedoelen ze daar met "native Julia" dat er geen implementatie in een andere taal wordt gebruikt, en er dus geen context switch nodig is bij het aanroepen

[Bulkzooi]

Ik had het overgenomen van dat artikel, volgens mij bedoelen ze daar met "native Julia" dat er geen implementatie in een andere taal wordt gebruikt, en er dus geen context switch nodig is bij het aanroepen

Ik denk dat dat bare of on-the-metal is.

Dat heeft meer te maken met zero-copy.

[divvid]

Dank je voor de uitleg. Kun je aangeven waarom de andere talen op termijn niet dezelfde solvers zouden kunnen inzetten?

[GerhardBurger]

Durf ik niet helemaal te zeggen, https://sciml.ai/news/2021/05/24/QNDF/ geeft ook nog wel wat interessante informatie over hoe de ODE code van Julia werkt. Een van de voordelen is dat de code in pure Julia geschreven is en niet meer gebruik maakt van C. En omdat Julia een redelijk recente taal is hebben ze alle ervaring met eerdere solvers andere talen kunnen gebruiken voor een efficiente implementatie, en ze richten zich ook op moderne hardware. Zal waarschijnlijk wel ingezet kunnen worden in andere talen, maar op termijn misschien waarschijnlijker dat andere talen een brug zullen bouwen naar Julia (zoals ook nog steeds gebeurd met efficiente implementaties in Fortran)

[Hayamimi]

Het is zeker de moeite waard om het uit te proberen. We zetten Julia in om een (relatief simpel 1-dimensionaal) ODE stelsel op te lossen. (Gebruik het eco-systeem: https://diffeq.sciml.ai/stable/) Het omzetten van de differentiaal vergelijkingen in code was gedaan in 40 lines of code. In vergelijking met MatLab was de Julia code meer dan 10x sneller. Python hebben we maar niet meer uitgeprobeerd. Na de ODE 100x op te lossen, hebben we miljoenen maal 2x2 matrix vermenigvuldigingen. Op een doorsnee corporate notebook (i5, Windows) kost dat minder dan 1.5 seconden.
We hebben nu deze code lopen in een (Linux) Docker container bij AWS servers in Ierland (dus EU), net zo snel als een local notebook en de kosten zijn lager dan de lease van onze corporate notebooks. De gebruikers hebben toegang via een server-client app, ook compleet in Julia met het Genie Framework (https://genieframework.com). Collega's op drie continenten kunnen zonder problemen de app gebruiken over de corporate VPN.
Works like a charm.

[84hannes]

De website van Julia verklaart dit doordat de taal naar native code compiled. Dat scheelt natuurlijk een beetje, al kan goed geoptimaliseerde JVM-code ook heel snel zijn, bij gelijke optimalisatie zal machine-code zonder interpretatielaag altijd iets sneller zijn.

[Bulkzooi]

De website van Julia verklaart dit doordat de taal naar native code compiled. Dat scheelt natuurlijk een beetje, al kan goed geoptimaliseerde JVM-code ook heel snel zijn, bij gelijke optimalisatie zal machine-code zonder interpretatielaag altijd iets sneller zijn.

Je ziet bij moderne talen niet alleen verbeteringen qua snelheid maar ook is er een focus op veiligheid.

Dus het geoptimaliseerde heeft meerdere aspecten.

[Bulkzooi]

Snel is al een relatief begrip, waar de wetenschap een limiet aan gegeven heeft: de snelheid van licht.

Of iets snel is tov van jouw ervaring is iets waarbij ik je niet kan helpen. Probeer het gewoon ff.

[Reactie gewijzigd door Bulkzooi op 22 juli 2024 15:02]

[MotorLum]

Wellicht een domme vraag, kun je Julia ook als een library gebruiken voor Python? Ik zie de snelheidswinst als grootste troef van deze taal.

[keraton]

Dat kan, daar is een library voor: https://pyjulia.readthedocs.io/en/latest/. Ik weet niet hoe goed dit werkt, want ik heb het nog nooit gebruikt; het project noemt zichzelf "experimenteel", dus dat zegt misschien wat.

Julia aanroepen vanuit Python is natuurlijk niet het idee van de taal , omdat Julia bedoeld is als oplossing voor het "two language problem": het probleem dat talen zoals Python en R nogal traag zijn, en je voor sommige berekeningen nog een tweede taal nodig hebt (bijvoorbeeld C++).
Overigens zijn er wel tools in Julia ingebakken waarmee je redelijk eenvoudig Python en C code kunt aanroepen.