<story><title>Dynamic type systems are not inherently more open</title><url>https://lexi-lambda.github.io/blog/2020/01/19/no-dynamic-type-systems-are-not-inherently-more-open/</url></story><parent_chain><item><author>ema</author><text>I&amp;#x27;ve come to the conclusion that the benefit dynamic typing brings to the table is to allow more technical debt. Now of course technical debt should be repaid at an appropriate moment but that appropriate moment isn&amp;#x27;t always &amp;quot;as soon as possible&amp;quot;. Let me illustrate, say you&amp;#x27;re adding a new feature and create lots of bugs in the process. Static typing will force you to fix some of these bugs before you can test out the feature. Then while testing out the feature you decide that it was a bad idea after all or that the feature should be implemented completely differently. So you scrap the implementation. In this case fixing those bugs was a waste of time. Dynamic typing allows you to postpone fixing those bugs after you&amp;#x27;re more certain that the feature and its implementation will stay.</text></item></parent_chain><comment><author>chongli</author><text>It isn’t even a benefit, really. Statically typed languages don’t force you to model things with types; you’re completely free to use strings and doubles everywhere and take on all the technical debt you want.&lt;p&gt;People who are only used to dynamic languages may feel like a static language’s type checker is an overbearing teacher (from the 1950s) standing over your shoulder, just waiting to jump on you for every silly mistake! While that feeling is common and valid as you’re learning the language, when you become fluent you see the compiler as more of an ally. You can call on it with a keystroke and it will find many problems that would otherwise only happen at runtime, possibly months or even years in the future!&lt;p&gt;Moreover, in more advanced languages (such as dependent typed languages), the compiler can actually infer the body of your functions which leads to a totally different style of programming that feels like a snippet plugin on steroids.</text></comment>
<story><title>Dynamic type systems are not inherently more open</title><url>https://lexi-lambda.github.io/blog/2020/01/19/no-dynamic-type-systems-are-not-inherently-more-open/</url></story><parent_chain><item><author>ema</author><text>I&amp;#x27;ve come to the conclusion that the benefit dynamic typing brings to the table is to allow more technical debt. Now of course technical debt should be repaid at an appropriate moment but that appropriate moment isn&amp;#x27;t always &amp;quot;as soon as possible&amp;quot;. Let me illustrate, say you&amp;#x27;re adding a new feature and create lots of bugs in the process. Static typing will force you to fix some of these bugs before you can test out the feature. Then while testing out the feature you decide that it was a bad idea after all or that the feature should be implemented completely differently. So you scrap the implementation. In this case fixing those bugs was a waste of time. Dynamic typing allows you to postpone fixing those bugs after you&amp;#x27;re more certain that the feature and its implementation will stay.</text></item></parent_chain><comment><author>dan00</author><text>Even this hasn’t to be only a feature of dynamically typed languages, like Haskells deferred typing shows. (&lt;a href=&quot;https:&amp;#x2F;&amp;#x2F;downloads.haskell.org&amp;#x2F;~ghc&amp;#x2F;latest&amp;#x2F;docs&amp;#x2F;html&amp;#x2F;users_guide&amp;#x2F;glasgow_exts.html#deferring-type-errors-to-runtime&quot; rel=&quot;nofollow&quot;&gt;https:&amp;#x2F;&amp;#x2F;downloads.haskell.org&amp;#x2F;~ghc&amp;#x2F;latest&amp;#x2F;docs&amp;#x2F;html&amp;#x2F;users_gu...&lt;/a&gt;)</text></comment>