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.
You realize how absurd the discussion of array start index is when you learn Fortran arrays have naturally had arbitrary-start-index for over three decades: a(-9:0), a(0:9), and a(1:10) are all valid declarations of a vector of size 10.
Where is it mentioned that it's Fortran? and what do you mean by "It’s Fortran so fixed array sizes might be to blame". Who says one cannot have dynamic array sizes in Fortran? You can have fixed array size in any language.
Yes, Fortran has `pure` and `impure` attributes for functions/subroutines (with and without side-effects).
```
pure recursive function factorial(n)
integer, intent(in) :: n
...
end
```
Fortran is better than Julia and interoperable with Julia and any language. Any language as of today is better than Julia.
Currently, Julia is a collection of nerd lies and false promises. Look at the recent Julia Discourse post "What is the status of AutoDiff in Julia"? Then read how gloriously the top response describes the situation. Read a few lines more, and you realize there is yet to be a single AutoDiff tool that works effectively and flawlessly in Julia.
"Deny the weakness until we fix it" is a typical speaking pattern among JuliaComputing leaders. There is a good reason for it. JuliaComputing is a for-profit company. They have to find a way to return the stakeholders' million-dollar investments. The easiest way for them is to take a Machiavellian approach rather than being realistic, honest, and fair. I know the nerd culture very well. I am familiar with their denial of their weaknesses and flaws, and their nightmares of being the runner-up. I work with them daily. And JuliaComputing staff is a nerd community from head to tail. For a longer list of Julia's flaws that JuliaComputing pushes under the rug, see https://yuri.is/not-julia/
Regarding fairness and honesty, JuliaComputing staff are responsible for >99% of web posts (including HackerNews) that speak highly of Julia and bash any other language, particularly C++, Fortran, MATLAB, Python, R, Rust.
Actually, it is the other way around. Pandas/NumPy were inspired by the Fortran syntax. Fortran's treatment of optional arguments are also great. Arbitrary array indexing (0-based, 1-based, negative-based) is a bliss.
not necessarily. But at least one of the major Coarray implementations (Intel Fortran compiler) translates the Coarray syntax to MPI so that the Intel MPI library can be used underneath.
As a counter-example, the NAG Fortran compiler implements Coarrays for shared-memory architecture, and apparently has nothing to do with MPI.
"often 10X faster" is just plain exaggeration looking at it positively, and plain falsehood spread by the for-profit JuliaComputing, looking at it realistically. The statement does not even reflect the numbers posted on the project's page, which has, by the way, nothing to do with Fortran directly.
how do you find it ugly? Can you provide specifics? Have you ever used it? Have you checked out the latest standards 2018 and 2023? By the way, it is still pretty much alive and well: fortran-lang.discourse.group/
Fortran 2018 already has modern features. What modern feature are you specifically talking about that Fortran lacks? There is more to arrive in Fortran by 2023 and 2027.
The statement "I do work for JuliaComputing" (which I predicted solely based on your writing style, generic to all JuliaComputing payees) fully explains the nature of your comments and arguments.
Regarding your argument: Counting GitHub repositories is the silliest way of gauging a language growth or decline. The C++ language has nearly 7000 C++11 repositories, only 1600 C++14, far fewer C++20 repositories. According to your flawed logic, C++ is now on life support. A thorough knowledge of a topic is essential before commenting on it or criticizing it as an expert in a public forum. Learn about the minor and major standard releases.
If you have not done a survey, then please do not make generic claims in a public forum about a whole ecosystem based on your limited personal observations. I understand you like Julia very much and that you are possibly paid by JuliaComputing to bash other languages in online forums, specifically Fortran here, but please keep your discussions factual.
Julia currently has specific weaknesses that make it unsuitable for a large category of problems that a language like Fortran (or C) has handled seamlessly for decades.
On the contrary, these are, in my opinion, excellent examples, although not a comprehensive list, of where Fortran shines compared to other languages that do not have such advantages or new languages that desperately try to copy, mimic, and rebrand the decades-long existing features of Fortran under their names.
Can you elaborate further, with an example, how this is different from static polymorphism? I don't fully understand your argument where you say "it will dispatch to the method optimized for that" and then "you don't have to write a separate copy of your function for each new datatype". The two do not seem consistent with each other.
It turns out the claim is even is worse than what I remembered. It claims to be the fastest high-performance language. What a shameful Machiavellian act by JuliaComputing for lacking intellectual honesty.
https://www.linkedin.com/events/juliacon2021-freeandvirtual6...
Start with the false claim of JuliaCon21 banner, "Julia is the fastest high-level programming language", then go to the Julia Discourse and read all the false reports on the internet claiming 3X, 300X, 3000X faster than Fortran/C/Python/... Having a business to run does not justify making false claims.
You see, this kind of response is precisely the problem with the Julia community and the performance fallacies they present. What does this post have to do with Python? You claim to be the fastest language, and if someone questions it, you only mention how fast it can be compared to pure looping Python. It's a Machiavellian promotion strategy that has so far worked for Julia, but it isn't going to work any longer.
Again, twisting facts by some Julia novice about a topic they have no familiarity with. Fortran does not require features to be built-in. Look at all the intrinsic Fortran modules. But array-based indexing IS built-in to the language. Unlike Julia, you do not have to rely on an external package for it. Perhaps the Julia community's relatively young age has made it so arrogant, Machiavellian, and fact-twisting about other languages to prove their presence here and there. Other programming communities are old enough to put decency and honesty in their core values.
The comment above states: "...Julia that have arbitrary array indexing as a core feature...". Is an external package written in Julia considered a "core" feature of the Julia language? Why does the Julia community always twist the facts? Why cannot they accept the facts as they are? It would not reduce the value of their efforts, I guarantee you—decency and honesty always prevail.