Political correctness, politeness, non-inflammatory language, call it what you want. Here is the diff:
@@ -17,7 +17,7 @@ In 2021, I had to do some numerical calculations for my master thesis about theo
First I thought about using python. It is commonly used for scientific calculations, mainly because of its good ergonomics, i.e. python code is shorter than e.g. equivalent C code. Dynamic typing can lead to a horrible mess in larger projects, but I knew my code would stay small. The problem with python for my use case is its poor performance. Numpy is quite fast, definitely fast enough, but if I had to manually write a hot loop in python, it would be unacceptably slow.
-A faster alternative would be C/C++. While it is definitely fast enough, its poor ergonomics would inflate the time needed for writing the code. Also, I hate C++ with a passion, but this is a story for another post.
+A faster alternative would be C/C++. While it is definitely fast enough, its poor ergonomics would inflate the time needed for writing the code. Also, C++ has its own problems, but this is a story for another post.
Rust is essentially C/C++, but without their ugliness. But Rust is quite a verbose language, which is fine for large projects, but not what you want for short scientific calculations.
@@ -85,11 +85,11 @@ Julia made me realize how great `cargo doc` is.
### The problem with free functions
A tutorial alone is not enough, you need a chain of links from a starting point to the function/argument/datatype you want.
-The authors of Julia argued that member functions are a bad idea, because it connects a function to a specific datatype instead of multiple datatypes. But this is not without disadvantages: Let's say you want to know the methods to modify a `Dict`. In [a proper language](https://doc.rust-lang.org/std/collections/struct.HashMap.html) you can find those methods in the documentation of the `Dict` datatype. But if you execute `apropos("Dict")` in Julia you find both functions like `Base.mergewith`, but also stuff like `Base.setenv` or `Base.Cmd`.
+The authors of Julia argued that member functions are a bad idea, because it connects a function to a specific datatype instead of multiple datatypes. But this is not without disadvantages: Let's say you want to know the methods to modify a `Dict`. In e.g. [rust](https://doc.rust-lang.org/std/collections/struct.HashMap.html) you can find those methods in the documentation of the `Dict` datatype. But if you execute `apropos("Dict")` in Julia you find both functions like `Base.mergewith`, but also stuff like `Base.setenv` or `Base.Cmd`.
## Hard to debug due to bad error messages
-I would consider myself a semi-experienced programmer. Less experienced than people who worked in the industry for years or decades, but certainly more experienced than the average scientist programmer. Julia made me feel like an absolute beginner again. **Unlike other languages, even those I spent less time learning on, I hade trouble writing certain code or debugging certain errors that I would consider extremely basic.** And I don't mean that my solution looked unelegant, like the code of a beginner. No, I was literally not able to write certain *basic* things myself.
+I would consider myself a semi-experienced programmer. Less experienced than people who worked in the industry for years or decades, but certainly more experienced than the average scientist programmer. Julia made me feel like an absolute beginner again. **Unlike other languages, even those I spent less time learning on, I hade trouble writing certain code or debugging certain errors that I would consider very basic.** And I don't mean that my solution looked unelegant, like the code of a beginner. No, I was literally not able to write certain *basic* things myself.
An example can be found [here](https://github.com/SciML/SimpleDiffEq.jl/issues/48).
@@ -162,10 +162,10 @@ The idea of "You only need to start the interpreter once a day" failed for me.
## Conclusion
-Hot loops in Julia are quite fast, but you have to wait *forever* for your program to start up.
+Hot loops in Julia are quite fast, but you have to wait quite long for your program to start up.
The Julia ecosystem is quite immature and buggy, at least compared to rust or python.
-Julia has really nice, short syntax for mathematic equations. Compared to other languages, your numerics code will be much shorter. The problem is that this short code will take longer to write, because dynamic typing, bad reference documentation makes writing and debugging Julia code extremely hard.
+Julia has really nice, short syntax for mathematic equations. Compared to other languages, your numerics code will be much shorter. The problem is that this short code will take longer to write, because dynamic typing, bad reference documentation makes writing and debugging Julia code harder.
-After a while, I decided to rewrite parts of my code in Rust. Rust code is much more verbose and I had to implement basic numerical methods since rust has few numeric libraries, so the code was much longer. However, it was still faster to write, because rust has a proper type system, reference documentation, error messages and a mature ecosystem. My Rust code greatly outperformed the Julia code.
+After a while, I decided to rewrite parts of my code in Rust. Rust code is much more verbose and I had to implement basic numerical methods since rust has few numeric libraries, so the code was much longer. However, it was still faster to write, because rust has a better type system, reference documentation, error messages and a mature ecosystem. My Rust code greatly outperformed the Julia code.
