Programming languages lie on the "Rigid/Lax" spectrum. The components of your programs (functions, modules, classes, etc.) are like joints. They define how easy it is to evolve your program. Python is too lax. You can write whatever mess you want and you can easily change independent parts without affecting the rest of the code. But because of that you also don't know what refactoring needs to be performed when you want to ensure that the rest of the app works. Haskell, on the other hand, is too rigid. In Haskell, you have to write more things to make joints connect. For example, you have to specify in the type signature whether a function has side effects, and you can even go on a more granular level where you can select which side effects. Because of that, Haskell is great at providing high confidence in the system's correctness after refactoring. Moreover, you're carefully guided through the entire refactoring. However, it means that Haskell programs are less flexible. You can't easily change one thing (e.g. introduce a side-effect in some pure function) w/o having a ripple effect through your entire program. Haskell works great when you know from the start what you want to do (which is not how software always works). Or if you're an excellent developer who knows a lot of coding practices and has experience to design for loose decoupling and evolution from the start (which is not the majority of the devs). I believe the balance is somewhere in between. For now, I feel like OCaml hits the sweet spot here.