As someone who moved from Python to Scala, I have to disagree. Python is a perfectly adequate language for most problems, and has a wonderful community: friendly people, excellent documentation, lots of beginner tutorials. Where disagreement does happen it’s almost always positive and constructive; I don’t always agree with e.g. the PEP decisions, but I can see why they make sense.
In comparison, the Scala community is awful. It’s the worst aspect of the language. I don’t even want to know what’s going on with control of scalaz right now, I’ve left a couple of IRC channels and am liberally wielding /ignore (which I’d never even touched in the ten years that came before) in the one where I remain, to preserve my sanity. When I look up how to do something I expect to find maybe one decent but out-of-date tutorial, a library that thinks a type signature is an adequate substitute for documentation, and paragraphs of invective deployed rather than answer a well-meant (if admittedly naive) question. Beginners arrive and are flamed, and I dread to think how many leave. It’s downright toxic.
So why do I use it? Because “good enough” isn’t. Because no, the “problems in the large” are actually mostly technical - mostly exactly the same problems you see in the small, plus new, technical problems if the language design doesn’t allow high-enough level abstractions. The only difference is that they’re harder to debug, so the things that were irritating in a small project become problematic in a medium-sized one, and destructive in a large one.
A language may attract a community, but it is, first and foremost, a tool for solving real problems, for enhancing lives. If I were building a bridge or sewer I’d want the machines that were best at digging, not the machines whose users formed a community with the best emotional flavour. The harder the problem, the better the tools you need, and the best problems are simply impossible without good enough tools (cf Joel’s “Hitting the High Notes” analogy).
If you have a moment to explain, what is your problem domain and what did you find lacking in Python? Thanks!
I’ve worked in several industries; currently it’s finance (but not the milliseconds-matter kind). Before that it was advertising, before that a contract-management platform. While I love doing web UIs in Wicket, these days I spend most of my time doing pure backend stuff - systems that actually implement business processes, and offer up a “REST” API to the frontend. There’s a little bit of “big data” stuff in my current job, but it’s mostly just conventional systems.
I loved Python for its expressiveness and clarity, particularly in comparison to Java; things that were dozens of lines in Java became two or three in Python. But I’ve found Scala is if anything more concise, and can be just as clear. And the type system is really helpful; you have to work with it, but as you push more and more of your business constraints into the type level, whole classes of possible errors just become impossible. Better, you can explicitly track effects (e.g. have a separation between functions that access the database and functions that don’t - or look at ReaderWriterState), which allows you to handle cross-cutting concerns (the kind of thing you’d use aspects, or in Python decorators, for) in a principled, readable, refactor-safe way - which means that if there’s a problem with e.g. database access, you immediately know (not just think, but provably know - many times I was “sure” a bug was in a certain piece of Python when it was actually elsewhere) the small number of places that problem could be. And with the typeclass pattern your code becomes more dynamic and flexible - you could achieve the same effect in Python by having a dictionary like the builtin __ methods, and monkeypatching the methods you wanted onto library objects, but it would be a recipe for unreadability and undebuggability.
It’s not so much about what’s lacking in Python (though I’d point to a few irritations - the way Python (like most languages, but not Scala) draws a distinction between methods and operators, and the lack of the “_” syntax for lambdas) as what Scala has in addition: the powerful type system. I think in it now, and couldn’t stand to use a language without one.
I’d like to make counter-point. Rust is a language that solves no ones needs, currently (it is far to unfinished and volatile).
Yet, we run one of largest language user groups in Berlin, with weekly learners meetings. There’s usergroups around the world and people are writing a lot of libraries and software in it. Why? Because the community is great and exactly the reverse you describe. Even if your question is answered by 5 minutes on Google, the worst you will get on IRC is “<link>, btw, that’s the second result on google for <query>”.
The Rust language will not succeed for its technical benefits, but because they got community building right.
That behavior will bite Scala on the way to widespread adoption, because the only way to keep this up is
a) either market the language where “community” is not a selling point (enterprise)
b) every team has to make their own effort in teaching Scala and providing a safe feedback space
3D-Printers are also just a tool, but the people stay in that space because of community and hacking together.