LambdaNative – Cross-platform mobile apps in Scheme

Even just in terms of reading and understanding what was going, there was no way to know the structure of objects passed to various function. A function would take an object foo, which had some arbitary strucutre and set of fields that were not defined or specified anywhere. Pure hell for readablity (i.e. understanding someone else's code). The absence of type system enforced structure on objects, means these objects could contain anything. Grr.

Everytime I get in production, a run-time JavaScript TypeError that would never happened had it been written in a statically typed language, I want to grab people like you by the collar (proponents of dynamically typed crap), and punch you in the face and give you a bloody nose.

I think you have to be slightly fucked up mentally to not appreciate the beauty, the power, the clarity, and the safety that high-quality type systems bring, in languages like Agda, Haskell, Elm, Swift, Kotlin, etc.

Dynamically typed languages are a bane.

This is not to deny that some statically typed languages have a poor type systems. Early Java had a disappointingly weak and primitive type system (e.g. no generics). Scala's type system is so complex that it's worse off for it. Etc.

But solid type systems are a huge advantage. I wish more people invested time researching and building more advanced and better type systems. We'd all be better off for it.

Is there a wiki or an issue to track progress of this?

Most of your argument is emotional and anecdotal, and what remains is only a compelling argument for code quality, not static/dynamic.

I, too, have worked in large code bases in both static and dynamic languages, and generally, I found the latter was a far better experience than the former - but code quality trumped any static/dynamic effect.

Even in just terms of reading and understanding what was going on, it was generally far more challenging to understand the point of code blocks due to boilerplate to deal with typing; indirection through wrapper classes in particular. A function might take an object foo, which would typically be on some level on an inheritance tree, and you'd have to trace up and down both the tree and the call stack in order to understand, and discard more than half the characters to get to the logical meat. Pure hell on development - the absence of REPL consoles means you really can't explore what's actually going on at a point in the code, you have to infer it. Grr.

Every time I get in production [in static languages], I run into some issue processing data that would never happen had it been written in a dynamically typed language.

I don't want to grab people like you and punch them, I want to either find a way to chill you the fuck out so we can have an actual discussion, or fire you so the rest of the team doesn't have to deal with religious fervor.

I think you have to be lacking mentally to not appreciate the beauty, power, clarity and flexibility that high-quality dynamically typed systems bring, in languages like Ruby, Javascript, Python, Lisp, etc.

People limited to one paradigm - static/dynamic, OO/functional - are a bane.

This is not to deny that some dynamic code bases are poor, but that's true of everything.

But solid dynamic systems are a huge advantage.

I don't actually wish more people spend time researching and building more advanced and better dynamic systems, because the ones we've got are plenty kick-ass as it is. We're already better off for it.

--

In actuality, in my experience, the strengths and weaknesses of static/dynamic are entirely based on how well or poorly "typed" the data you're dealing with is - over the lifetime of the project - although at small scale it really doesn't matter.

This is why dynamic languages took over the web - not only do you have very flexible information in systems you've already built (see "myths programmers believe about names, gender, time, etc" for a good example), but your development speed is such that the type of information changes ~1/mo anyway. Static languages are great for when have a well-defined problem that's not really going to change on you, and you need a solution that's fast and/or extremely safe.

The problems really only happen when you shut down the conversation with insults and vitriol.

neither did you. in fact, you italicized probably the least objective portion, that of staically typed languages being more readable. and that's likely to be the opposite case for most people. the draw for most dymaically typed languages is that they are often quite readable.

sometimes people prefer different stuff, and that's all the commenter was saying. i myself like both.