3 ms·

Hard disagree. Dynamic typing only increases development speed for the first few thousands lines of a solo programmer project. After that it is, in my personal

Hard disagree. Dynamic typing only increases development speed for the first few thousands lines of a solo programmer project. After that it is, in my personal experience, a significant drag on development speed. Furthermore, dynamic typing makes modifications and new features significantly harder to write. Turning compile-time bugs into runtime bugs is a catastrophic decrease in development speed. That’s my personal experience at least. YMMV.

moffkalast 4y ago
taps temple That's why you keep code encapsulated as much as possible in separate files/classes up to like a thousand lines. Any more will be unreadable anyway. > dynamic typing makes modifications and new features significantly harder to write Depends on what you're doing I suppose. Adding a parameter to an object? With dynamic typing you just add it to the object in literally any location, no issues. With static typing you might just need to refactor half your codebase if you have lots of interfaces. Have fun resolving merge conflicts with your team. Not only that, but (in Java as an example) serialization codes for objects will change unless you planned for that previously (you didn't), making old objects impossible to load. A completely new bug that's created solely by static types. And it's not the only one.
- forrestthewoods 4y ago
  My personal hell is having some nested objects/dictionaries and wanting to either add or remove a layer. Good luck and God speed in your attempt to simply find every single line of code that needs to be updated.
- ReactiveJelly 4y ago
  "serialization code"? Maybe it's an issue with Java. In Rust if I add a new field, I just wrap it in an Option. When de-serialized, old objects have a None, new objects with the field have a Some. When serializing it's just `Some (5)` instead of `5`, if it's an int. No runtime crashes from nulls, either.
  - moffkalast 4y ago
    Yeah I haven't really ever used Rust, maybe it handles these sort of things better.

moffkalast 4y ago

taps temple That's why you keep code encapsulated as much as possible in separate files/classes up to like a thousand lines. Any more will be unreadable anyway. > dynamic typing makes modifications and new features significantly harder to write Depends on what you're doing I suppose. Adding a parameter to an object? With dynamic typing you just add it to the object in literally any location, no issues. With static typing you might just need to refactor half your codebase if you have lots of interfaces. Have fun resolving merge conflicts with your team. Not only that, but (in Java as an example) serialization codes for objects will change unless you planned for that previously (you didn't), making old objects impossible to load. A completely new bug that's created solely by static types. And it's not the only one.

forrestthewoods 4y ago
My personal hell is having some nested objects/dictionaries and wanting to either add or remove a layer. Good luck and God speed in your attempt to simply find every single line of code that needs to be updated.
ReactiveJelly 4y ago
"serialization code"? Maybe it's an issue with Java. In Rust if I add a new field, I just wrap it in an Option. When de-serialized, old objects have a None, new objects with the field have a Some. When serializing it's just `Some (5)` instead of `5`, if it's an int. No runtime crashes from nulls, either.
- moffkalast 4y ago
  Yeah I haven't really ever used Rust, maybe it handles these sort of things better.