Eric Elliott writes about JavaScript, React, testing, TypeScript, and software design on Medium's JavaScript Scene publication.
HN commenters cite his TypeScript Tax essay and nested ternaries post in debates, with one defending that he never called TypeScript useless.
> However, it is not a matter of opinion whether software safety (and therefore
availability) benefits from checks performed before run-time.
The article I linked to (it's still there for me?[1]) linked to another article[2]
which in turn mentioned a paper[3], which conclusion is:
> The data indicates functional languages are better than procedural languages;
> it suggests that strong typing is better than weak typing; that static typing
> is better than dynamic; and that managed memory usage is better than
> unmanaged. [...]
> On the other hand, even large datasets become small and insufficient when they
> are sliced and diced many ways simultaneously, [...] Hence, we are unable to
> quantify the specific effects of language type on usage.
So I still think there's no way to tell, for example, if a statically typed
imperative language with manual memory management is better than a dynamically
typed functional language with a GC. I think it's a case of "all else being
equal" in the context where "all else" varies drastically.
The argument is not about if static typing improves safety (because many things
do) but instead by how much and if that increase in safety is worth the
drawbacks it comes with... Which again is subjective and situation-dependent.
In other words, even if we agree that static typing has a positive effect on
some metric (like number of bugs) it's not going to move the discussion forward.
> Conversely, it is not a matter of…
While I think this sheet is a great reference, the level of opinionatedness is a turn off. It strikes me not open to people that might bring a point of view that challenges the author's orthodoxy. Some of the opinions expressed seem to indicate a lack of understanding of successful patterns from outside of the mainstream JS world. I would not use as a filter in hiring.
For example, I might agree that composition is better than inheritance if I'd never experienced the joy of algebraic data types. Pattern matching doesn't work out so hot without some concept of "is-a". Languages that support type-classes also tend to avoid the brittle-class problem. I agree that Java style single-inheritance hierarchies are a recipe for disaster, but that's not the only type of class-based inheritance. Scala, for example, has a much better story.
While Javascript's prototype system is really powerful, I'm not at all convinced anything more than a small number of library writers should be interacting directly with it. CoffeeScript and ES6 have class stories that are vastly more productive in most cases, in my opinion -- and by the way, are pretty thin layers of prototypes, if someone needs to really hack on that level. In my experience, most people spin monstrosities when they try to hack together their own prototypal logic, when all they is something pretty basic. The author's stamps [1] are very cool. They're more powerful than `class`. But they still expose a level of variation and control…
As others have said, key at this point is going to be to prioritize in relation to business needs. As hard as that all will be, the process will only get more difficult the longer you wait. I'd also suggest one thing you prioritize personally for yourself whatever happens is eight hours of sleep every night. :-)
As other have also said, you're also going to have to tailor the way you present the message about the facts (i.e. the "alarm") to your current organization's culture and your specific situation in it. You'll need to keep in mind your own talents/resources and current limitations in developing a message or plan (see also "Dunning–Kruger effect" for risks on that). Talents/resources and limitations include your own ability to present a message and what help you can rely on from the rest of the organization to develop a message and present it based on what your coworkers, manager, and management chain value.
If you eventually want to reflect on the larger issues that may have gotten you to this unfortunate situation and what your company can do better in the mid-term and long-term, here is a reading list I put together that includes multiple books on software engineering management as well as broader surrounding issues -- including a great book by Matthew Walker on the importance of adequate good sleep for everyone in an organization:
https://github.com/pdfernhout/High-Performance-Organizations-Reading-List
One item from there:
"Why Deadlines Need to Drop Dead"
by…
TL;DR: If you share the sentiment of the parent commentator you may find this wall of text interesting.
You might be interested in Alan Kay's "Doing with Images Makes Symbols Pt 1", https://archive.org/details/AlanKeyD1987 (46:29). This video features excerpts from Ivan Sutherland's Sketchpad demo (https://www.youtube.com/watch?v=USyoT_Ha_bA, 10:34; https://www.youtube.com/watch?v=6orsmFndx_o, 19:19) and Douglas Englebart's seminal demonstration (https://archive.org/details/XD300-23_68HighlightsAResearchCntAugHumanIntellect, 34:45). I recommend watching all the videos in full to get a proper sense of context (Alan Kay's excerpts from Douglas's demonstration particularly don't include the bits that explain how the workstation's camera system works, which is important; also, the right audio channel in the Alan Kay video unfortunately seems to be dead, while the other videos are much better).
Highlights from Alan Kay's video include (in hi..low precedence) info about the Sketchpad's CPU, which you might want to listen to twice so you don't mishear (8:58), some really depressing acknowledgements (from Alan Kay himself) that Sketchpad was a never-reproduced gem even in the 80s (8:33), Ivan's (quoted) remarks on the features of the Sketchpad system (7:58), and acknowledgement about the lack of ease of use of light pens (7:12).
I consider the above videos to be my own personal pinnacle, what I look up to when I think about good computer design. Some may find them depressing for…
I recognize that we can have different goals, and you may value flexibility over safety. However, it is not a matter of opinion whether software safety (and therefor availability) benefits from checks performed before run-time. Conversely, it is not a matter of opinion that dynamic languages allow patterns that static typing does not (eg. duck typing[sic]). These are objective arguments we can discuss, and weigh against each other. There are even studies that we can throw in here.
>> Nowadays I see no notable arguments for dynamically typed programming languages.
>A quick Google brought up an article from Dec 2016: https://medium.com/javascript-scene/you-might-not-need-types...
I glanced over it the other day and wasn't very interested. I wanted to give it a more thorough look before I replied to you, but it seems it got pulled. looks meaningfully
>What about Elixir and Clojure?
I see your Erlang dialect Elixir with Elm (arguably a dialect of ML). The Lisp Clojure is itself a bit older dialect of Lisp, so maybe Scala for that? I think Lisp and Erlang are mostly about the paradigm and concepts, not about being dynamic, what do you say? Talking about the JVM, I'll raise you a Kotlin. Also noteworthy is that Groovy got static type checking with v2. As for the CLR, I must say I don't know that much have changed since F# (a dialect of ML). Basically, you've had a nice pair of cards, but they make your hand. What I'm trying to reiterate is that there seems to be a definite…
ADTs are only concerned with the "shape" of the data and what interactions you can have. It is related to classical OOP in the sense that the "interactions" you can have are equivalent to the message passing from the original conception of OOP[1].
The distinction is similar to database design in SQL: the Schema is how the data is laid out and what the relationship between tables is (ADTs) while the queries is the operations performed on them (traits). On the other hand, in OOP there's a higher reliance on encapsulation, making behavior an integral part of what the class is and using inheritance for expansion. When all you have is ADTs, you _can't_ have inheritance, so you end up using composition (which is generally considered better design) and you are more likely to rely on the creation of "new-type" container types for everything. You think of them as a way to describe what the data is, not how you interact with it.
Apologies if this is a bit hand-wavy, I'll try to write a more thoughtful answer at a later time.
[1]: https://medium.com/javascript-scene/the-forgotten-history-of-oop-88d71b9b2d9f