As for the chosen unfortunate few who somehow enjoy scientific computing, there are the even more select few that actually want to achieve good performance and good maintainability. It is one thing to make highly specialized mathematical code easy to write, but it is a completely different story to make it easy to read later.
In that pursuit of nice to maintain domain specific code; in absolutely many respects- it is another league of hurt to make it performant. Julia is the only language I see tackle this in such a way that it leads to a language of many balances where it counts. Some of those of course do lead to tradeoffs, but I do think it is important to note. Julia is a language where many of what makes it unique may be perceived as intentional design decisions, but are rather just side effects of the core tennants of the design. I promise this will be elaborated further eventually.
Is it too good to be true? A language like that has to be both simple but also complex enough to express the complexities of a code base. Not bloated, but expressive enough to make it clear of what everything is doing through specification alone. I will say, in my experience using it for over a year extensively in many different contexts, it does have some sharp edges, but it truly has what you may need in spades. It is certainly what I needed.
A lot about a language to begin with can be inferred by who made it, and for why. Standard, spoken languages are usually propagated by some measure of colonialism. Programming, not so much. The intentions behind a given language give insight into what the language will be built for. Generally in software, when you do not think about a given case, it will be a miracle if it works well if you try adding it later.
The main developers Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and Alan Edelman [1] are all computer scientists- many of them specifically have done work in the area of high performance computing, as is one of the first things they introduce to begin with in their oddly emotionally gripping detail of how they came to the same conclusion I came to a decade later.
“We are power Matlab users. Some of us are Lisp hackers. Some are Pythonistas, others Rubyists, still others Perl hackers. There are those of us who used Mathematica before we could grow facial hair. There are those who still can’t grow facial hair. We’ve generated more R plots than any sane person should. C is our desert island programming language.
We love all of these languages; they are wonderful and powerful. For the work we do — scientific computing, machine learning, data mining, large-scale linear algebra, distributed and parallel computing — each one is perfect for some aspects of the work and terrible for others. Each one is a trade-off.” - Why We Created Julia
The predicate fact here is this not as a result of a lack of trying. Notice that most of these languages are basically shackled to C libraries and C/C++/Fortran vectorization for any modicum of performance, or we have the culprit right here in our midst. C. C was made to be just a much nicer version of Assembly.
R, Python, and MATLAB for scientific applications are good if they have a use case that is well supported. And that itself is a true gamble depending on the flavor of dynamic, interpreted language you desire. If they are not, the code that you will often see is out of a good Steven King novel. Truly horrifying. The core issue, is what if it doesn’t exist? Sometimes, that’s your job.
Someone had to go through the pain of not only making the library, but making an interface for your language to deal with it. Why is that the accepted order of programming languages? The problem is, the more bleeding edge you go into research, the more you will find the diminishing support of your niche. You will have to fufill your niche with very little in the way of the crutches that keep that language afloat.
As for the C inclusion and mention, its native support for any number of things, whether memory safety, math concepts other than your most fundamental ones are not there. Can you make code out of that? Yes. Are there good libraries for computation in applied areas made in C? Sure. But if you want to make something more novel, which requires a lot of experimentation, in a language that gives you nothing, how does that work?
Well, in the usual order of business, you prototype in one language, and then you write the final implementation in the other. Why? That’s stupid. Why do I have to try to scotch tape sub-optimal solutions all the time to simply make something? Why do I have to use package managers that suck at versioning just to try to find some obscure library that does not work, and start at square one enumerably ad nauseum.
In either case, I am bottlenecked by having to worry about unnecessary levels of pain. CMake is only beating out Make and NPM. To make a joke about diseases would be in poor taste, but the taste that CMake leaves in my mouth is disgusting.
Even with a package manager (VCPKG, Chocolatey, COnan) and my hand on CTRL, X, C, and V- or any particular combinations of those keys of my standard CMake, it still takes a long ass time that I could have been doing something else.
Or I have to dance around the language. Using Numpy because your loops are too slow and you have to dance around using the language you are currently in like Antoñita Singla is stupid. MATLAB is still less stupid about vectorization, but it is still way harder to read than just a simple damn loop in anything other than trivial cases. The fact that you often have to resort to horrifically syntaxed vectorization to not get abominable performance is ridiculous.
I would rather just write could that works, thank you. Imagine some grad student- the average chemist trying to code. I know you may have shuddered. But hear me out for a second. Do you think they know what vectorization is or does? No, they want to know why their code performs like complete trash. If you think an easy language requires learning otherwise freakish computer science concepts like SIMD with abhorrent readability to just do something with slightly high data volume, you are out of your mind.
You would sound like you need a chloroform excorcism to the average chemist trying to process their data. And honestly, they have a point. Why do you need to contort like the exorcist to just do anything? For a perfectly reasonable program, this is insanity. If you don’t teach them what is actually going on, they won’t make proper optimizations. Extreme optimization is already finicky as it is- and you are not going to convince anybody with a “trust me bro” or a barrage of what is jibberish to 99% of people who just want to process something. Why do I have to break out the CPU instruction knowledge to just do a basic addition between 2 decently sized arrays?
People want to focus on chemistry, not everything else. But if people want to focus on the architecture, performance, and maintanence of your code, why does this have to come at the cost of the relative ease of writing the underlying logic naively in a more purpose-built language. Julia is a language that proves that you can do both!
TL;DR: I believe it is a problem of concerns. Either way, I am constantly concerned about performance, or I am constantly concerned about C. Neither are mutually exclusive. That is why Julia exists.
If you watched the Firebase video (like I did), or read the Wikipedia article (like I also did), you will hear the description of a dynamic, high-level, general purpose, multi-paradigm language.