On Wednesday, 10 June 2015 at 17:04:20 UTC, Binarydepth wrote:
I think that it could be useful to declare variables as Python
does and statically too in the same language. Just make it's
type when a value is assigned to the variable. This could allow
a program to adjust it's data types accordingly to input when
data is received from another program or an user.
Please kill me now. Dynamic typing is almost always a _horrible_
idea. Sure, it may _look_ like it makes things easier up front,
but it requires far more testing in order to ensure that you're
getting it right (you're basically forced to have unit tests for
all the sorts of things that a static type system automatically
finds for you), and it's far less maintainable, because it's far
easier to misunderstand what's going on and screw up the types
when you're working on someone else's code or coming back to code
that you haven't worked on in a while.
And honestly, the fact that you can do the equivalent of
if(condition)
myVar = "foo";
else
myVar = 42;
in languages like python just plain horrifies me. How on earth is
that a _good_ idea? Sure, it can work if you're careful, and good
code won't have if statements like this, but why not just use
static typing and avoid all of the bugs and pain that allowing
that sort of thing causes? I truly see nothing good about
supporting dynamic types as the normal way of doing things.
And maybe I'm being too brusque with this post, but I truly do
not understand how anyone can think that dynamic typing was ever
a good idea outside of a few cases where you have no choice, and
it's a big pet peeve of mine. Dynamic typing is just begging for
problems and forces you to manually do checking that a static
type system would have done for you on its own. It seems to me
that using dynamic typing is like not having stoplights. Sure, it
may _seem_ like you'll be able to get there faster, because you
want have to stop at those pesky lights, but in reality, every
intersection then becomes a potential disaster zone, since you no
longer know that no one is going to enter the intersection from
the other road, and so have to constantly drive very defensively
and drive more slowly in order to avoid getting into an accident.
Static typing is your friend. It finds bugs for you and prevents
you from shooting yourself in the foot. In fact, many of C's
safety problems come from allowing you to circumvent their static
type system via casting.
That being said, there are rare cases where you really have no
choice but to use dynamic typing - e.g. when dealing with
database queries; the types are based on the database schema, and
therefore can't be part of the API, since the API is not
schema-specific. So, for those cases, we have std.variant.Variant
and similar types in std.variant where they're helper structs
around unions so that they're safer and cleaner to use by knowing
about what type they currently hold (and in some cases, only
allow certain types). So, you can have dynamic types when you
need them, but they're not part of the language, and they
shouldn't be used unless you actually need them.
Adam Ruppe did a talk on this topic at dconf, so you should check
that out once the videos are up.
- Jonathan M Davis
