As you can see, the ongoing debate is between compilers and interpreters. Think of it like this, compiler makes your code do what you tell it to do by creating an "exe" file that remembers what needs to be done, while interpreter tries to "interpret" what is the best way for you code to do what you want it to do.
A direct example is simply solving a linear system A X = B. To solve this in C/C++/Python you need to know how your matrix A looks like and what numerical math method is most suitable to solve it. On top of that you need to find a good library that has those math methods available and you need to handle the data types, You cannot write
X = inv(A) * B or
X = solve(A,B) or
X = A \ B
as in MATLAB (you probably could the second one). The solution in C++ would most likely look something like
array_data_type X = library_name::method_name(A,B,'very_specific_solver_type','option1','option2'...)
and you would need to take great care to match data type of A and B with the function call and understand some of the options. Of course, if you don't know what solver to use, you can always call the general one and that may cost you some time even in Fortran/C++.
Advantage of MATLAB is that it is trying to do a lot of "nasty" work for you in terms of syntax. You don't have to worry about data types or optimal methods, however that is also its biggest issue, because every time you run a script MATLAB needs to figure out what method and what data type to use that would solve your problem the best way.
For example, you are solving a differential equation by finite difference method given by matrix A in multiple time steps in array t, so you write a code in MATLAB:
A=make_fdm_system_matrix(parameters);
for i=1:length(t)
X(i,:) = solve(A,B)
end
It looks very simple right? You have some function that creates matrix A, and now you iterate through time and solve in each step and place the solution in X as two dimensional array.
Now think about how will MATLAB actually interpret this code. Matrix A is made however you wrote the function, loop starts and MATLAB sees that it needs to solve something by calling its own solve method. Bare in mind MATLAB now needs to check its path to locate the library and the code for solve function. Then as someone mentioned, 120000 lines of code need to be looked up by MATLAB to determine what is the best method to invert matrix A and multiply by B. On top of that, each variable you have needs to have the appropriate data type, so if you have 5000 x 5000 matrix there will be additonal time that MATLAB needs to figure out what to use. And you say ok, it took some amount of time s to solve it in the first iteration, what happens in the next? The same bloody thing. So if you have 1000 time steps, the execution time will be 1000 times s.
This is why MATLAB is so slow. You cannot have simplicity and efficiency at the same time. MATLAB uses horrible generalizations to simplify its syntax. Try typing isinteger(5) in MATLAB. It's a function to check if number is integer, the result of this function will be false, because MATLAB thinks every single number you write is double data type, simply because it's more general and easier to use. On top of that, MATLAB interpreter is not all powerfull. Say that your differential equation by finite difference method is tridiagonal and you are solving a 5000 x 5000 problem. The interpreter will not bother to check if your matrix is tridiagonal and will solve you system by some LU factorisation method that would take a lot of time for matrix of that size. On the other hand, everyone with some algorithm and numerical math knowledge knows of Thomas algorithm where instead of inverting 5000 x 5000 matrix, you can store its three diagonals in three arrays, write one for loop and apply direct formula to get a solution (note that general methods for inverting a matrix can never be done by writing just one for loop).
You cannot escape the more serious coding from different languages. You really need to know what method solves your problem best for more serious stuff. I for instance was having a minimization algorithm in which I was solving iteratievely a system of differential equations in which I was inverting several 3000x3000 matrices and one 1000x1000 using some eigenvalue solvers. In simpler terms, I had a system of differential equations, solved by finite difference method in a loop because I needed the solution to converge, then this loop was nested in minimization algortihm which is again another loop, so code was something like
while (minimization_converge!=1)
while (iterative_solver_converge!=1)
solve_3000x3000_system();
solve_3000x3000_system();
solve_1000x1000_system();
end
end
I did this by using armadillo library in C++. How much time do you think it takes to do this there? Less than 1 minute! MATLAB will never ever achieve such speed. Why? Well think of the previous example, everytime you write solve_system, MATLAB needs to look it up and this takes time and more loops you nest, the slower your code is. In any language, you have to choose the best solver straigth away. Note that nesting is just one of the issues MATLAB has. Another terrible thing that MATLAB does is its workspace. It is great that you can look up any variable your code makes and you can easily debug your code, however no one has infinite amount of memory and if you ever checked in task manager how much MATLAB is using, then you know how bad it is and this slows done both your code and your own machine. You can make your MATLAB code run faster by knowing exactly the options in functions that you are using (to spare the interpreter the trouble), but the memory use and the data type conversion that needs to happen in the background of your code will significantly affect your code performance.
Don't get me wrong, I use MATLAB all the time. It is amazing in visualising simulation results, running simple codes as the MATLAB syntax is basically a psedo code and I would not need time to think about code construction and compilation as in C++.
However, overall advice, if you are nesting a lot for or while loops in MATLAB and using some of its functions within, your code will be slower and slower and you should consider switching to other language.
EDIT: The only problem with different language is, to implement the code above, you pretty much can write exactly something like the above and it would work in MATLAB. In C++ however, I needed to write a separate class that will deal with LAPACK and BLAS routines to solve differential equations and those 3000x3000 systems, than a seperate class to deal with how Armadillo solves 1000x1000 systems and all this was happening in the class that was running that inner while loop. The outer while loop is done by using GSL Brent minimization algorithm, and if you google it, you'd find out that GSL needs very specific way of formulating a problem before you use some solvers - you need to provide the function of the problem in this form: function(double x, pointer parameters) and than use the solvers. What you won't find easily online is how to make pointer for your parameters, most people do it as a structure. I made a class and parameters were its fields, put GSL function as the static method, and then made a method in that class that is using the static method and as pointer parameters sent "this" to it and than used GSL instrucitons and appropriate solver. It is a very elegant solution, but the code I needed to write needed advanced knowledge of C++ and it looks very complicated in comparison by equivalent solution in MATLAB.
So to conclude, estimate complexcity of your algorithm first, if it's not too complicated, implement it in MATLAB, if you're not sure, implement it in MATLAB and check how long it runs. If you're lucky, it will give you results in decent time, if you aren't, you simply have to learn another language, the essence of the algorithm you wish to implement would not be much different than approach in MATLAB, however the syntax and use of different specific libraries and their functions will force you to get much much more into those languages, but with great effort, there will be a great reward in terms of performance.
