{"id":12989,"date":"2015-12-03T11:47:43","date_gmt":"2015-12-03T16:47:43","guid":{"rendered":"http:\/\/mjtsai.com\/blog\/?p=12989"},"modified":"2019-01-22T15:44:27","modified_gmt":"2019-01-22T20:44:27","slug":"the-end-of-dynamic-languages","status":"publish","type":"post","link":"https:\/\/mjtsai.com\/blog\/2015\/12\/03\/the-end-of-dynamic-languages\/","title":{"rendered":"The End of Dynamic Languages"},"content":{"rendered":"

Elben Shira<\/a> (via Michael Feathers<\/a>):<\/p>\n

\n

There is a frantic rush to bolt-on a type system to every dynamic language out there. Typed Racket, Typed Clojure, TypeScript, Typed Lua. Even Python has “type hints”. […] The fundamental problem, you see, is that a programming language is not just about code. Implied in the community is a school of thought, a philosophy. And that<\/em> is difficult to change.<\/p>\n

[…]<\/p>\n

This is my bet: the age of dynamic languages is over<\/strong>. There will be no new successful ones. Indeed we have learned a lot from them. We’ve learned that library code should be extendable by the programmer (mixins and meta-programming), that we want to control the structure (macros), that we disdain verbosity. And above all, we’ve learned that we want our languages to be enjoyable.<\/p><\/blockquote>\n\n

Marcel Weiher<\/a>:<\/p>\n

Looks like someone else confused hash-languages with dynamic languages. If you pass hashes around the type checker won’t save you<\/p><\/blockquote>\n\n

Dan Luu<\/a>:<\/p>\n

There are some pretty strong statements about types floating around out there; for the most part, those claims haven’t matched my personal experience. The claims range from the oft-repeated phrase that when you get the types to line up, everything just works, to “not relying on type safety is unethical (if you have an SLA)”, “I think programmers who doubt that type systems help are basically the tech equivalent of an anti-vaxxer”, and “It boils down to cost vs benefit, actual studies, and mathematical axioms, not aesthetics or feelings<\/a>”. There are probably plenty of strong claims about dynamic languages that I’d disagree with if I heard them, but I’m not in the right communities to hear the more outlandish claims about dynamically typed languages. Either way, it’s rare to see people cite actual evidence.<\/p>\n

This is a review of the empirical evidence.<\/p><\/blockquote>\n\n

Via Lambda the Ultimate<\/a>:<\/p>\n

Part of the benefits of types allegedly surround documentation to help refactoring without violating invariants. So another future study I’d like to see is one where participants develop a program meeting certain requirements in their language of choice. They will have as much time as needed to satisfy a correctness test suite. They should then be asked many months later to add a new feature to the program they developed. I expect that the maintenance effort required of a language is more important than the effort required of initial development, because programs change more often than they are written from scratch.<\/p>\n

This could be a good thread on how to test the various beliefs surrounding statically typed and dynamically languages. If you have any studies that aren’t mentioned above, or some ideas on what would make a good study, let’s hear it!<\/p><\/blockquote>\n\n

Maxime Chevalier-Boisvert<\/a>:<\/p>\n

That there are less dynamic programming languages coming out is an undeniable fact. I’ve written code in statically typed languages such as C, C++, D and OCaml, and I agree that their type systems help catch certain classes of bugs more easily and rapidly. When writing code in JavaScript, you can run into nasty surprises. Latent, trivial bugs that remain hidden in your code, sometimes for months, until some specific input causes them to manifest themselves.<\/p>\n

[…]<\/p>\n

Dynamic languages are at a disadvantage. Most of the mainstream ones out there today were designed by amateurs, people with no formal CS background, or no adequate background in compiler construction. They were designed with no regard for performance, and an impractical mash of features that often poorly work together. Most of the dynamic languages you know are simply poorly crafted. This has resulted in some backlash.<\/p>\n

[…]<\/p>\n

Have static languages won? It seems to me that what people really like about static languages is IDE support for things like simple refactorings and autocompletion. Program analysis that can provide some guarantees, find certain classes of bugs without having to run programs with every possible combination of inputs. It’s perfectly legitimate for programmers to want these things. They help alleviate the cognitive burden of working with large (and small) codebases. But, these advantages aren’t inherently advantages of statically typed programming languages. I would argue that Smalltalk had (has) some amazingly powerful tools that go way beyond what the Eclipse IDE could ever give you.<\/p><\/blockquote>\n\n

Update (2015-12-04): Michael R. Bernstein<\/a>:<\/p>\n

IMO you’re wrong if you think the “next big language” will be “either” “static” or “dynamic.” It’ll be both, if we’re making progress.<\/p><\/blockquote>","protected":false},"excerpt":{"rendered":"

Elben Shira (via Michael Feathers): There is a frantic rush to bolt-on a type system to every dynamic language out there. Typed Racket, Typed Clojure, TypeScript, Typed Lua. Even Python has “type hints”. […] The fundamental problem, you see, is that a programming language is not just about code. Implied in the community is a […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"apple_news_api_created_at":"2019-01-22T20:44:30Z","apple_news_api_id":"c8d38816-b0b5-4dc2-8619-bb12b6995784","apple_news_api_modified_at":"2019-01-22T20:44:31Z","apple_news_api_revision":"AAAAAAAAAAD\/\/\/\/\/\/\/\/\/\/w==","apple_news_api_share_url":"https:\/\/apple.news\/AyNOIFrC1TcKGGbsStplXhA","apple_news_coverimage":0,"apple_news_coverimage_caption":"","apple_news_is_hidden":false,"apple_news_is_paid":false,"apple_news_is_preview":false,"apple_news_is_sponsored":false,"apple_news_maturity_rating":"","apple_news_metadata":"\"\"","apple_news_pullquote":"","apple_news_pullquote_position":"","apple_news_slug":"","apple_news_sections":"\"\"","apple_news_suppress_video_url":false,"apple_news_use_image_component":false,"footnotes":""},"categories":[4],"tags":[1098,263,361,346,46,71,816,287,548,515],"class_list":["post-12989","post","type-post","status-publish","format-standard","hentry","category-programming-category","tag-clojure","tag-theory","tag-haskell","tag-javascript","tag-languagedesign","tag-programming","tag-refactoring","tag-ruby","tag-scala","tag-smalltalk"],"apple_news_notices":[],"_links":{"self":[{"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/posts\/12989","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/comments?post=12989"}],"version-history":[{"count":2,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/posts\/12989\/revisions"}],"predecessor-version":[{"id":13025,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/posts\/12989\/revisions\/13025"}],"wp:attachment":[{"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/media?parent=12989"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/categories?post=12989"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mjtsai.com\/blog\/wp-json\/wp\/v2\/tags?post=12989"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}