[stoppingin]

Does Fortran need to? Does Fortran still have any real advantage over Julia, MATLAB, etc.?

Please forgive my ignorance. I've never written any Fortran. I understand how and where it's used in modern computing though. I also understand why it's faster than C in some cases.

[dagw]

Does Fortran still have any real advantage over Julia, MATLAB, etc.?

Performance. Fortran is much still faster than Julia, MATLAB etc.

It's also much easier to write fast Fortran compared to fast C. While C code written by an HPC expert will almost always be as fast as Fortran written by an expert, C written by "mediocre" C programmer who is a domain expert solving a problem in the most obvious way, will basically always be slower than Fortran code written be an equally "mediocre" Fortran programmer.

[adgjlsfhk1]

Fortran isn't faster than Julia. most comparisons I've seen are ties or Julia wins as long as both implementations are somewhat competent.

Fortran actually makes it fairly hard to write fast code since it is missing some features. for example, I don't believe there is any way to write a fortran program using Bfloat16 numbers. you also don't have great ability to write programs with a mix of strict ieee semantics and fastmath semantics. you have to choose 1 as a compile time flag.

[cookieperson]

If you are ignoring the cost of the compiler, and a whole host of other things - sure. But the same can be said for most any modern programming language. A lot of Julia's public benchmarks are not idiomatic Julia or packages were created to elide how nonidiomatic they are. Julia isn't a slouch after precompilation, but the time to burn in code can be longer than the runtime and the compilation time of the code in other languages by orders of magnitude. It's great for academic benchmarks though! Huge pain for CI and development.

[ChrisRackauckas]

Are you not talking about Julia v1.9? Packages precompile to binaries (.so/.dll) in this release, and will support direct calls pretty soon. It sounds like you're talking about a much older Juila.

> A lot of Julia's public benchmarks are not idiomatic Julia or packages were created to elide how nonidiomatic they are.

??? https://docs.sciml.ai/SciMLBenchmarksOutput/stable/MultiLang... this is pretty standard code.

I do enjoy programming in Fortran but let's at least keep it concrete and to reality. The older Fortran versions do have a small amount of optimizations that are hard to perform in other languages because the lack of aliasing can make difficult to prove optimizations possible. But the newer Fortran versions don't optimize as well without forcing things like ivdep, which is similar to Julia, which is why you tend to get the same/similar machine code between LFortran and Julia (since both are using the same compiler, LLVM).

[cookieperson]

If by much older you mean the current stable Julia release than sure... As of today Julia 1.8.5 is the stable release. So this post is traditional Julia community stuff.. "it works and everything is perfect you're the problem. We didn't create our own message board and stop posting in other places to try to control the narrative". Gas light city.

I wasn't referring to package benchmarks, my apologies if that was unclear.

[nojonestownpls]

I'm glad I'm not the only one that feels this way. I love Julia as a language (not as an implementation, which is a pain-in-the-ass to work with), but there has long been a pattern of responses which in practice amount to gaslighting. Afaik it's only small set of people who do that, and charitably they're likely just being less-than-thoughtful about generalizing their "work for my project", "works on my 24 core computer", "works when I know half the people developing packages" experiences to everyone. But to an outsider, it looks like the answer is always "the problems are all fixed now, you're just out of date", and most of the time that turns out not to be true.

[TheRealKing]

Your benchmarks are not concrete and realistic. I have never seen any language but (unsurprisingly) Julia, to compare its performance with the performance of other languages by calling those languages from within the host language. Definitely 15000 times faster than MATLAB as claimed by JuliaComputing can be achieved with such seemingly concrete and realistic benchmarks. LLVM has benefited and learned so much from Fortran and its compilers. But free food and service are always undervalued.

[ChrisRackauckas]

> Definitely 15000 times faster than MATLAB as claimed by JuliaComputing can be achieved with such seemingly concrete and realistic benchmarks.

I believe you're talking about NASA Launch Services engineers claiming Julia's ModelingToolkit simulations outperformed Simulink by 15,000x? That claim was of course not made by Julia Computing or anyone affiliated by Julia Computing, which is pretty clear because the person who makes the claim very clearly describes his affiliation at the beginning of the video. The source is here: https://www.youtube.com/watch?v=tQpqsmwlfY0, at 12:55. You did watch the whole video to understand the application and the caveats etc. instead of just reading the headline and immediately coming to a conclusion, right?

[adgjlsfhk1]

The benchmarks on Julia's website are ones that take around 1 second. The couple nanoseconds of call overhead doesn't matter.

[adgjlsfhk1]

precompile costs are 1 time. if you want to deploy, you build a sysimage and ship that. startup time is then about .5 seconds.

[cookieperson]

They are one time per instance. Which isn't the same thing as one time. Julia sysimages are huge and take a long time to generate even on decent hardware. Last I checked that whole process was very janky, poorly documented, and under heavy revision(as it had been for years prior).

[adgjlsfhk1]

it's not. once you generate it somewhere you can just copy the files to anywhere that has the same architecture.

sysimages are huge (but they've gotten a decent bit smaller recently). notably, 1.8 added some features that let you make them a bunch smaller for deployment. you can now remove the metadata (i.e source code text) which saves about 20%, and you can also generate it from a Julia launched with -g0 to remove debug info (Julia unlike C includes debug info by default because stack traces are nice). we also recently fixed a really dumb bug that was causing libraries to be duplicated in sysimages, so that will sometimes save a few dozen mb. (who knew that tar duplicates symlinks?)

When did you last check? it's now pretty dejankified and has been for about a year. the docs aren't perfect, but I think they're relatively good.

[rightbyte]

What edge does Fortran really have over GCC C with GNU extensions? If you can use the restroct keyword, are there any speed differences left?

[p_l]

You're escaping the "mediocre programmer" level then.

[cookieperson]

Neither Julia nor Matlab are great production languages. They are both fine if you just have some math you want to run to get some results. But... Julia changes and breaks core functionality regularly in pretty much everything from the language itself to the packages you use. Matlab although is more stable, has other detriments. It's closed source, it's not really designed to be a systems language, sometimes it's not fast enough, etc.

In my mind, fortran will always be hard to replace especially if there is sizeable legacy code. A lot of people don't realize it, but fortran is kind of like sql. It's old, backed by a lot of theory, and delivered on it's promises for years. That makes challengers job really really hard.

[adgjlsfhk1]

At this point, Julia is being used on ASML's lithography machines. it's pretty deployable.

I'm not sure where you are getting the idea of frequent breaking releases. the language has been pretty stable since 1.0 in 2018 (as in almost all code that worked on 1.0 still works now). (there are some very minor breaking changes in minor releases, but Julia breaks a lot less things per release than python or C).

[cookieperson]

Cool I am glad there are more people using it in production these days, it will help the language become more stable. I've deployed Julia to production a few times now. In almost every case it was rewritten in another language within a year for one reason or another... This is sad, but, for being a v1 language, it never lost it's "early adopter" experience for myself or my colleagues.

I've seen minor releases in Julia break essential packages. Not like it was one time either. So where did I get the idea, personal hands on experience.

Again it's great if you have a script and want to run it, anything beyond that, in my experience, results in a lot of turmoil and erosion. Almost wonder if it's a flaw in the language itself or, the maintenance model of the packages. Oh well not my problem

[sundarurfriend]

> I've seen minor releases in Julia break essential packages.

Any specific examples of this happening in Julia 1.0 or later?

[cookieperson]

Absolutely, a minor change to Julia base broke the CSV package for weeks. But that's like 1 of hundreds of examples. I don't think non package developers realize how much effort package maintainers and drive-by contributors do to keep that language alive.

[sundarurfriend]

Would you happen to remember the specific version, or links to any of the other examples? I ask because I've repeatedly heard that every release is tested against the entirety of the (public) package ecosystem, so I'm curious how these snuck through - whether it was before such a system was put in place (maybe because of these breakages), or whether things still sneak through the tests to such a degree.

[kryptiskt]

MATLAB is basically a REPL over a collection of old-school Fortran libraries. So it is far from an alternative to Fortran.

See the HOPL history for the background of MATLAB: https://dl.acm.org/doi/10.1145/3386331

EDIT: fixed paper link

[tannhaeuser]

> Does Fortran still have any real advantage over Julia, MATLAB, etc.?

These are incomparable since Fortran is a standardized programming language with multiple implementations, whereas the other two you mentioned are products having single implementations.

[wirrbel]

The new revisions of Fortran are actually quite nice to work with. I had a month of using fortran in a company I worked in and reworked some Fortran 70 code into a more recent version (Fortran 2000?). It overall felt more high level than plain C. Eventually I also ported the code to Python and Cython and while the cython implementation actually was more performant (arrays were always allocated with fixed sizes in Fortran and in python it was easy to pick just the right sizes), the Fortran implementation was fairly readable