these are all very valid pain points with Julia, except I disagree with calling Julia "way more dynamically typed than Python."<p>I think of Julia as <i>statically duck-typed</i>, which sounds cursed but is incredibly useful IMO. like if you have `foo(x,y,z)=x+y<i>cow(z)`, foo() will work for any x and y with compatible `+` operators, if there's a `cow()` that will accept whatever type `z` is. But it's still static - your code will throw a </i>compile error* if x and y can't be added, or if cow() won't take your z. And unlike Python, Julia can dispatch on types, so you can implement cow() for whatever you want. the type system is, in fact, absurdly powerful. the downside seems to be that it's formally undecidable sometimes, and that you fundamentally can't enforce output types for functions passed as arguments.<p>the speed is a drag, but it feels like getting a train up to speed - it's slow getting ready to do absurdly heavy lifting.