The issue, of course, is that most common languages people use have a type system based on C's (with minor improvements). Those are all mostly interchangeable. But languages like Haskell and OCaml have the capabilities to directly express notions with types that Python, Java, or C would deeply struggle with.
(All this is to say: I agree with your point that people would benefit from doing a bit of Haskell to experience this first-hand!)
At some point you have to admit to yourself that it's the wrong tool for the job, when is this going to be?
Dependency/environment management is poor as well given how popular the language is. I believe it's popularity is similar to that of PHP in the past; flooded with carefree users.
I would strongly advise against using python for anything other than PoC/experimental endeavours.
It's a scripting language, and should be used as such.
I agree with your points, but this seems to lean a bit too far the other way. Yes, Python has plenty of limitations and cases where there are better choices in programming language. But saying that it shouldn't be used in real production systems when there are so many examples of it being used effectively for precisely that seems a bit hyperbolic, no? It's like saying Javascript shouldn't be used in production.
I mean… is that such an unreasonable point of view?
Python continues to earn its reputation as the second-best option for most problems.
Never heard that line before but it resonates with me.
It's always a matter of choosing the least worst solution with Python, and additionally patching over shortcomings of the language with afterthought-tooling.
https://github.com/JuliaPy/PyCall.jl https://github.com/JuliaInterop/RCall.jl
It's a worse-is-better approach, to be sure, but it has a very appealing effort:result ratio.
[1] with the normal caveats -- every project is different, everybody's notion of a "backend" is different, etc. Haskell might be the sanest solution to some backend challenges.
If you want performance, or to apply more rigorous (read: enterprisey) development practices, you really are better off looking elsewhere.
However, you can get a Data Science python developer to front their code behind an API with minimal ceremony.
Type safety does not exist in Python. Type hinting does not solve this problem, neither does Pydantic. These are bandaids for huge shortcomings of using the wrong tool for the job.
Personally I find python-is-wrong arguments to be a bit naive. "It's a crappy language that's only good enough to build prototypes..." -- like YouTube, for example? :) Ultimately, smart developers are smart, and can get work done with whatever tools they have at hand.
Tools matter. However the community and ecosystem behind Python makes it extremely hard to beat at many games.
You could pick at every tool, every language. What's better than Python at (since you brought it up) data science? Julia? That's hardly any more type safe, if that's an issue for you. Haskell? Good luck getting non-CS types to buy in to the restrictions, and good luck porting everything you need. R? Slower than Python, even! I mean, I dunno, if you have something in mind that's better in every way than Python then I'd love to hear it.
And no environment really beats RStudio.
R is also hardly more terse in my experience, though perhaps that depends on style; I'm a tidyverse fan but it's not particularly concise.
Finally ... RStudio. It's just okay. If you're willing to use a language-specific editor that may not get keybindings right (I hope you're not an emacs user), it works fine. I like the RMarkdown integration. I don't use it, though, and I don't feel like I'm missing that much.
BTW, you don't mention what actually does make R better than Python: lazy evaluation allowing something close to syntactical macros. You'll never get a magrittr or a dplyr in Python.
I know Instagram was experimenting with something similar to this a couple years ago (“Python strict modules”).
It might be possible to implement function purity with a decorator. (Kind of like declaring something “safe” in Rust).
Definitely agree that Python is becoming more amenable to functional style programming over time. And it’s great!
Two parts to this. 1: Does it mutate variables. 2. Does the code have side effects.
1: def no_mut(func): @functools.wraps def new_func(args, *kwargs): new_args = tuple(copy.deepcopy(arg) for arg in args) new_kwargs = {k, copy.deepcopy(v) for k, v in *kwargs return func(new_args, *new_kwargs) return new_func
For the second point, gevent seemed to have a trick to identify side effecting code.
[1]: https://roscidus.com/blog/blog/2013/06/09/choosing-a-python-...
I suspect the author may be a bit removed from modern python, as the community is increasingly taking a similar stance. Python is not Haskell, but Python in 2021 with tools like type-hints, mypy, (frozen)dataclasses, Pydantic, etc. is trying to address at least the latter two points here (type-driven & illegal-states-unrepresentable). I'm not aware of ways to enforce function purity in python (do any linters complain about input modification or out-of-scope references?), but I try to make functions as pure as possible regardless of language or domain anyways.
I don't mean this as a flamewar, Haskell seems like the right choice for OP. I love how a language like python is making more of these benefits available to a wider audience and I wish more folks embraced these recent advances.