3 ms·
> How do you deal with arbitrary objects being passed around and not know what's potentially coming from where? Honestly, by trusting that those objects confor
by jofer 7y ago
> How do you deal with arbitrary objects being passed around and not know what's potentially coming from where?
Honestly, by trusting that those objects conform to what things are documented to expect and using operations that will naturally raise an error for unexpected cases.
Basically, you don't depend on compile-time or IDE-time checks, you depend more heavily on tests.
It allows for much more of a direct approach. E.g. if something's documented to accept a sequence, I don't care whether it's a list, tuple, some custom object, etc, I just need it to have certain properties like iteration and ability to index.
You write things to expect certain abstract categories of types and do things that will raise errors if they're not in the category you expect. The downside is that nothing is enforcing that in an IDE or at compile time. As a result, you need more integration tests.
In some ways, yes, you're more at the mercy of other developers behaving well. The flip side to that is more flexibility and less duplication.
- SketchySeaBeast 7y agoAh, OK, so you build the "checking" in via process and practice. It requires more discipline, but you end up evolving to kind of a similar place, but with more flexibility. Thanks!
- weberc2 7y ago> Honestly, by trusting that those objects conform to what things are documented to expect and using operations that will naturally raise an error for unexpected cases. Which is really hit or miss in the wild. Even the standard library documentation doesn't reliably document types. There are abundant references to "file-like objects" as though that is a type. It is (or at least was) totally unclear if a "file-like object" supports seek() or just read() and write(). Our internal Python code is a mess as well; we can't keep documentation up to date with function signatures (even though it's part of our code review process). As someone who develops primarily in Python, I think you're missing out on quite a lot if you think C++ is a good characterization of the state of static typing. Having used Python and Go and a few other languages, I'm convinced that static typing is more productive when it's done well.