6 ms·

It amazes me that someone could write down that principle and then design an untyped programming language.

Roboprog 9y ago
Dynamic types can be more problematic to modify, but many of us find them easier to read: assume that the code actually worked and does something reasonable, now skim for the gist of it (without having to see a bunch of extra detail). Assembler is untyped (just bytes and words). I'm not big into Python, but I'm pretty sure it has types, but they are late/runtime bound. Dynamic types are probably not a good choice for an army of idiots, but if dynamic types were so completely unworkable, you would think that they would disappear, eh? That said, I'd rather see avionics written in Ada than Python, but not every problem needs that level of scrutiny and pain.
- yen223 9y ago
  > assume that the code actually worked and does something reasonable That's almost never the case if you're in a situation where you're reading code
orf 9y ago
Why is dynamic typing (with reliance on duck typing) any harder to read, or more complex?
- yen223 9y ago
  def add(a, b): return a + b In a dynamically-typed language, you can't actually know if this dead-simple function will throw an exception, until you know the entire call graph leading up to where this function was called. That's fine in small scripts, but really freakin hard if you have call-stacks 10 levels deep.
  - orf 9y ago
    Sure, but it is both exceedingly readable and exceedingly simple. It is pretty much pseudocode. Which is what we are discussing, not type safety in huge codebases.
    - yen223 9y ago
      Thats true in small functions, but that's also true for statically-typed languages with type inference. In OCaml, the same function would also be let add x y = x + y Looks reasonable to me, and this is statically type-checked
      - Can_Not 9y ago
        If I were making an argument in this case, I'd say that several other languages have fulfilled the "readability" benefit while also fulfilling orders of magnitude higher performance and type safety garuantees. This implicates that one case is write only instant legacy code and the other will be highly maintainable going forward if the codebase and team need to scale in size.

Dynamic types can be more problematic to modify, but many of us find them easier to read: assume that the code actually worked and does something reasonable, now skim for the gist of it (without having to see a bunch of extra detail). Assembler is untyped (just bytes and words). I'm not big into Python, but I'm pretty sure it has types, but they are late/runtime bound. Dynamic types are probably not a good choice for an army of idiots, but if dynamic types were so completely unworkable, you would think that they would disappear, eh? That said, I'd rather see avionics written in Ada than Python, but not every problem needs that level of scrutiny and pain.

yen223 9y ago
> assume that the code actually worked and does something reasonable That's almost never the case if you're in a situation where you're reading code

orf 9y ago

Why is dynamic typing (with reliance on duck typing) any harder to read, or more complex?

yen223 9y ago
def add(a, b): return a + b In a dynamically-typed language, you can't actually know if this dead-simple function will throw an exception, until you know the entire call graph leading up to where this function was called. That's fine in small scripts, but really freakin hard if you have call-stacks 10 levels deep.
- orf 9y ago
  Sure, but it is both exceedingly readable and exceedingly simple. It is pretty much pseudocode. Which is what we are discussing, not type safety in huge codebases.
  - yen223 9y ago
    Thats true in small functions, but that's also true for statically-typed languages with type inference. In OCaml, the same function would also be let add x y = x + y Looks reasonable to me, and this is statically type-checked
    - Can_Not 9y ago
      If I were making an argument in this case, I'd say that several other languages have fulfilled the "readability" benefit while also fulfilling orders of magnitude higher performance and type safety garuantees. This implicates that one case is write only instant legacy code and the other will be highly maintainable going forward if the codebase and team need to scale in size.