Interesting discussion. But I am sorry to say that, unfortunately, it will be just opinions on a discord group read by very few people.
I don’t see Julia language any better than Modern Fortran, but I do know where Julia people are very good at: marketing.
There are plenty of articles and videos over the web that creates a huge hype on Julia. Of course, new learners will become interested and resources will be directed to the development of Julia projects.
We are terrible at it. I would love to see the Fortran language leveraged by a strong marketing initiative, getting resources from funds, or even donations, lots of articles praising all the good projects we have and the new initiatives. Why not sell the processing power of Fortran to fund marketing initiatives? We have to put away the vision of an old language. We have to have people working on ML and AI libraries and the hot topics of today.
Think about it: why not have a article such: “[Good Fortran Model’s name] model is the foundation of [area]”?
And, of course, we need to convince university teachers to adopt Modern Fortran in their courses. The success of Fortran depends directly on new adopters.
This is only an opinion, like the others above. Is there anyone willing to move on this direction?
And just to add to what @certik said, I think this is exactly the direction that the Fortran community is currently heading.
I think that all of the things you mention, like good marketing and teachers adopting Fortran, come through having a strong community (which Julia seems to have been very successful in creating). Fortran Lang is absolutely building that and from my humble viewpoint as a relative outsider here, there is noticably more excitement and buzz around Fortran in the past year or so than ever before. This community is gradually building the reputation of Fortran as a modern and exciting language to work with, it just takes time (and lots of peoples’ considerable efforts). But I’m optimistic that in a few years the “Fortran is old and outdated” opinion will itself be obsolete.
Completely agree, but from my own experience I see teachers explaining what they know: Fortran77 or a mixture of f77+ (more or less) modern fortran.
From my point of view, the first marketing task to do is to use (and try to stick to) modern fortran, while being ready to explain some deprecated fortran features to the newbies in case they find them. Otherwise fortran will keep being seen as an old fashion computing language, instead what it really is: a powerful language.
On top of that I would like some preprocessing and more built-in parallelization. That would keep some mouths closed.
Thanks for the comments and for getting the point from my “provocative” post.
I agree that we need more people working on Fortran tools and libraries to create a rich ecosystem, that’s essential.
However, Julia’s marketing keeps feeding the “proud” on working with Julia. New learners must have this feeling when working with Fortran.
I am tired of seeing many immature Julia packages, created mainly by academic students for a single course with a specific purpose. But they are there. The package’s name is “fancy,” They have logos, reasonable documentation, etc. In the end, they are not more than unfinished work. However, this allows any programmer, regardless of their skill to cooperate with others. I understand the idea of this community is to move on this direction, but we need to make more people proud of it.
For researchers, marketing Fortran can be talking of the modern Fortran features they use in their research papers. You can read papers just saying their numerical algorithms are coded in Fortran (or FORTRAN…), and it’s not rare to read papers where the language used for computation is not even cited.
We present the Fluid Transport Accelerated Solver, FluTAS, a scalable GPU code for multiphase flows with thermal effects. The code solves the incompressible Navier-Stokes equation for two-fluid systems, with a direct FFT-based Poisson solver for the pressure equation. The interface between the two fluids is represented with the Volume of Fluid (VoF) method, which is mass conserving and well suited for complex flows thanks to its capacity of handling topological changes. The energy equation is explicitly solved and coupled with the momentum equation through the Boussinesq approximation. The code is conceived in a modular fashion so that different numerical methods can be used independently, the existing routines can be modified, and new ones can be included in a straightforward and sustainable manner. FluTAS is written in modern Fortran and parallelized using hybrid MPI/OpenMP in the CPU-only version and accelerated with OpenACC directives in the GPU implementation. We present different benchmarks to validate the code, and two large-scale simulations of fundamental interest in turbulent multiphase flows: isothermal emulsions in HIT and two-layer Rayleigh-Bénard convection. FluTAS is distributed through a MIT license and arises from a collaborative effort of several scientists, aiming to become a flexible tool to study complex multiphase flows.
Even though I am a newbie in Fortran, I’d like to give my two cents.
I discovered Fortran, whilst looking for a programming language to give me an edge in mechanical engineering. I started out with C++ in high school. Years later I dabbled in Python by doing an online course, and subsequently started using Sagemath (CAS software with a Python backend) for most of my computational needs. I found Fortran by accident whilst watching a Youtube video on racing different programing languages against each other, and Fortran came out on top.
I was then intrigued, so I purchased some books, and looked at the tutorials on the Fortran-lang website, and started to work away at the exercises in the books.
I genuinely liked Fortran, I liked the simple and rigid syntax and the speed. Let’s not even forget the capabilities of parallelization.
As I delved deeper I found one glaring problem when using Fortran, the lack of a way to process symbolic problems. I found myself either using SymPy or Sagemath for Symbolics and then porting the equations to Fortran in a two language solution.
I for one was excited at Julia-lang’s progress, because of the capabilities of doing symbolics and calculations in one place. I especially like the makie graphing package to visualize data.
However, I grew disappointed at the lack of good and structured documentation aimed at beginners. I was also disappointed at the immature libraries, but maybe in a few years they will get better ?
I feel like if Fortran wants to compete with Julia and other popular languages, maybe it needs to somehow incorporate processing symbolic computation (either by using SymPy or something else)
The weird thing about Fortran is this: some of the largest corporations in the world produce Fortran compilers (Intel, IBM, Nvidia, HPE), and yet it doesn’t seem like any of them do much of anything for the larger Fortran community or ecosystem that would make people want to use Fortran.
Julia’s marketing is very aggressive - and clearly targeting Fortran. Although I see no reason to use Julia anyway, I wouldn’t do it even if I had a reason - just because of their marketing, which in some cases would make even M$ or systemd developers blushing in shame that someone managed to do it even worse than them.
How can we compete with such a marketing? Hard to say. Videos would definitely help. However, I doubt too many Fortraners would do that. Most of them aren’t “Youtubers”, not to mention they use Fortran to get the job done, not to advertise their preferable language. On the other hand, Julia’s developers and fans seem to be more interested on advertising than programming. Add to that they sell Julia as the “new” and “fresh”, while many people think of Fortran as the “old” and “obsolete”, and you have a situation.
I believe one thing must be done: Let people know Fortran is not what they think it is. Most people hear “Fortan” and they immedately think of Fortran 77, just because they had such an outdated class in the college, or just because they heard so by another misinformed programmer. I am sure I am not the only one every time I mention Fortran to new programmers I have to explain why it is not what they think it is. I have seen many eyes wide open when I mentioned Fortran is module- or object-oriented, whichever you prefer. And many jaws dropped when I add that basically all numerically-oriented environments like Matlab, Scilab, and Octave use features directly copied from Fortran or they use Fortran code in the background to solve problems numerically. People just don’t know all that.
I think the same and I have experienced the same situations.
The problem with videos at youtube is, as you say, most fortran users just are committed to get the job done, and that fortran is a mature language which is not in the position to get promoted, at least in principle.
Personally, I am terrible at marketing and all that, but I consider, as mentioned here that keeping fortran up to date (preprocessing, parallelism, etc) is important, but we, as users, have to show off how well fortran performes at hard problems. I never lose the opportunity to mention to the students that fortran is around whenever performance is required.
We can correct any specific misstatements by the Julia community and improve Fortran codes they use in comparative benchmarks, but I I think such general criticisms are too subjective and should be avoided. The more options for scientific computing there are, the better. There are many Fortran videos – some of the more substantial ones are listed at the Fortran Wiki.
I’m sorry, but if the Fortran community really thought that those were the reasons for the recent hype around Julia, it would be very hard to believe that Fortran would have any future at all. Happily enough, I don’t believe that is the case, and, most importantly, the most important developer that is moving Fortran forward doesn’t think that either.
Julia is not a perfect language, and there are good reasons for choosing Fortran, as type declarations, debugging messages, very-long-term stability, etc, are objective qualities in which Fortran is better. But to make Fortran move forward and gain traction, something has to be learnt from the languages that did important progress in another aspects of programming.
By the way, I think in the field of good coding practices, error messages, debugging, error correction, and stability, Rust is the language that is setting up the new paradigm. AFAIK, the tooling around it is fantastic as well. I am more concerned about Rust taking the place of Fortran for new programmers searching for those qualities, than what I would be relative to Julia.
I’m not a Rust programmer, so you probably can get a better idea by searching about it on the web. But it is a language designed around memory safety and performance. The memory safety side makes debugging it very easy, with more errors caught on compilation than other languages. The tooling seems to be very, very good (package manager, incremental compilation, builtin compilation modes for development and production).
And the syntax is not scary, much better than that of C++, which is being a contender on the high-performance scientific field for many years.