Answers will probably be very opinionated and it also depends on what kind of research (and possible adoption of that research) you are targeting.
I did not use Julia for a long time (and it's obvious, that i prefer Python). This is probably no fair comparison and i don't want to talk down julia. Also consider that my background is CS, not Math and i never did academic research but only did work in the industrial context.
So from the top of my head:
- It actually is a (well-)supported language in all commercial sovers while Julia might not be
- See Gurobi and co.
- Yes... There are lots of good community-provided libs, but official support is (sometimes) hard to beat
- The ecosystem is much bigger:
- Lots of great software to make use of
- Even software not related to optimization but extremely helpful in research anyways like matplotlib or pandas; why use 2 languages at work if 1 can be enough
- The community is much bigger
- This might also be the case in your local colleague-community
- (If there is a lingua-franca in programming: it's probably C for system-languages and Python for interpreted-languages)
- Better foreing-language tooling (i guess; see disclaimer)
- e.g. pybind11 / cython
- Python/C++-Hybrids are imho the perfect combination
- Performance can be optimized where it matters (e.g real computational work needed within some cutting-plane callback)
- State of the art libraries can be used when needed
- Example: I frequently make use of Eigen / boost::graph which i consider both state of the art in their respective domains
- There are no JIT(Julia!)-related performance surprises (which are hard to predict)
- e.g. multi-second pause in your program because that function hasn't be compiled/optimized yet
- no fun at all when doing benchmarking
- 0-indexing if you like it (and you will if you touch any other programming-language; i'm ignoring matlab)
- Python will definitely stay relevant for many years to come
- Good (advanced) research community
- From the top of my head: decomposition-methods; (specialized) interior-point solvers; first-order solvers (although at some point people consider porting them; e.g. Googles PDLP which was POCed in Julia and then ported to C++ based on Eigen)
- Better performance on tight loops
- No personal experience with it; but Python's GIL can really by annoying
- At that point hybrids help again (as you can acquire/release the GIL in your native-code)
- (Better languaged-provided tooling for abstraction from what i heard)
- 1-indexing if you like it
No clue but maybe important
- Type-system (i believe in type-systems catching hard-to-debug bugs early)
- Both seem to make use of optional type-hints but i don't know how powerful / accurate it's used
- This is relatively new in Python and there sure are limitations
Personal Opinion: Missing tooling
If they ask about Python/Julia without some C/C++ knowledge, it's probably very research- or modelling-focused as i don't see these two languages providing what's needed to really exploit all those available features of existing software has to offer. (All the commercial solvers are C/C++-based)
So maybe all points related to performance or getting access to all the solver-features might be unimportant.
Skimming over your linked answer, it seems, that this low-level access is irrelevant for lots of people (which get the work done using Python alone for example). So maybe i'm the outlier here. Although... SCIP always seemed to be the dominating research-focused solver (when going into depth of such technology; so more low-lvl then modelling) and it's probably hard to make use of it without C/C++.
Additional remark: I consider Python relatively easy to learn and i don't consider it a year-long task to get working. This might be nearly the same for Julia (but won't be for C++).