There are many FE codes that are written in different programming languages, such as Java, C++, and Python. Each of these has its own advantages and disadvantages in terms of object-oriented programming. So, my question is: which one of these languages is better than the others for FEM OOP programming?
Thanks,
It is about which you are most familiar with. In my experience if you have to deal with high performance computing (HPC) by diving a big problem (ex. Analyzing an Image from Hubble Telescope) you shall send it to multiple computers in the cloud (for example using MPI), Python is much more easier to work with. Because Python is quite popular in HPC, it is easy to find support. Java is popular too. But I do not know about C++. Overall development depends on many things such as modularity, clarity, ease of maintenance and compatibility (among many other traits). As you may already know, OOP in Python is a choice unlike Java. So if it is highly necessary for me to use OOP and Java is my expertise I would use it, otherwise, Python is delicious. :)
As you say, each one has its own strength/weakness. Much of the answer will depend on what you want to do with this code, i.e.:
- Learn OO while doing FEM;
- Test your own algorithms within an existing OO FEM framework;
- Build a commercially robust application on top of a OO FEM framework;
- etc.
As FEM are computationally intensive, the core structures and algorithms of commercial packages are usually implemented in C++ rather Java, Python or other high-level language (we could argue that C++ is also a high level language but the difference is that you can go "as close to the metal" as you need with it). That allows them to extract every ounce of performance from the hardware be it CPU or GPU wit CUDA for example.
Also, if you want to look at this kind of code to get good OO programming models, be careful. Sometimes, the OO orthodoxy gets diluted within the pragmatism of hard-code optimization like in a game engine for example... It's not good or bad in itself as the goal is high performance but that's often what happens when "the rubber hits the road"!
My bias: Though i have used Java, I use C++ and Python way more.
Each of these can do OOP well. The main differences are:
Java:
- forces OOP
- your API can't be circumvented by client code
- support on supercomputers is not always given in my experience
C++:
- doesn't force OOP
- it's possible to write interfaces that are impossible to circumvent by client code but care has to be taken not to expose implementation details in some circumstances.
- your API can be exposed in Java and Python too, sacrificing little performance (takes a little effort in the Python case, for Java i don't know)
- supported on every supercomputer, typically highest performance of the three
Python:
- complete freedom
- there is always a way to circumvent everything (for someone sufficiently savvy)
- unparalleled possibility to write beautifully convenient APIs
- supported on every cluster i've used so far, sometimes old versions only though (2.4)
Assuming you are equally familiar with each:
For production code for large problems which has to be fast and/or run on supercomputers i would use C++ for obvious reasons. For an educational framework i would use Python, because it's easy to use interactively and code inspection is built in. If it's important to keep potentially stupid / malevolent users in line, use Java.
If scientists or engineers will use your code and want a convenient API but are not willing to sacrifice speed, use C++ with python bindings.
Just by itself, this simple question "What about their computational speed?" could trigger pages of replies...pretty useless for you.
Better meditate on:
- What kind of system are you trying to implement?
- Obviously, if you are posting this question, you are not trying to compete with High Performance commercial solutions.
- If performance is not "that important", chose the language of your choice and stick to software development best practices and your language of choice modern idioms.
- You can plan to have some modules used only through a facade interface if you plan to replace it later with a better performance implementation (maybe C++ or commercial).
- Badges
- Science topic
- Similar topics
- Computer Science and Engineering
- Programming Languages
- Python