Эта статья является фактически неверной, логически противоречивой,
атакует соломенных аргументов и вводит читателей в заблуждение.

Простите меня. Я отстой при уценке.

Я использую вторую из статей, на которые вы ссылаетесь, для своего анализа.

Вы конкретно говорите о разнице между TypeScript и
JavaScript, когда дело касается количества ошибок. Во второй статье
непосредственно не рассматривается плотность ошибок, вероятно, потому, что это
чрезвычайно плохой показатель того, насколько дефектна база кода.

(Кроме того: плотность дефектов определяется как количество дефектов в компоненте
, деленное на размер компонента. Проблема в том, что
когда у вас есть несколько языков, которые вы сравниваете - как вы должны < br /> когда вы сравниваете статическую и динамическую типизацию, существуют другие
мешающие переменные, такие как многословность языка,
которые мешают
работе с такой метрикой. Например, для определения именованного идентификатора
функция в Haskell выглядит как `id x = x`, в то время как в C ++ это

template ‹typename T› T id (T x) {
return x;
}

Любая метрика, использующая размер кода вне языковых границ, почти
наверняка обречена на провал.)

Вместо этого в статье подсчитываются исправления ошибок, так как это гораздо более надежно для межъязыкового анализа. Вы не упоминаете, что коэффициент
, определяющий склонность к ошибкам в JavaScript, _ выше
среднего_ для исследуемых языков на значение 0,06. Вы не
упоминаете, что TypeScript _ ниже среднего_ для языков,
обследованных, со значением -0,43. Другими словами, если вы выбрали
JavaScript для своего следующего проекта, вы ожидаете 106% ошибок среднего
проекта, но если вы выбрали TypeScript для своего следующего проекта,
вы бы Согласно этому исследованию, ожидается 57% ошибок. Это означает, что
проекты JavaScript содержат в среднем * на 86% больше ошибок, чем проекты TypeScript
. * Поскольку TypeScript - это просто типы JavaScript +,
трудно сделать вывод, что статические типы не являются играет здесь ключевую роль
.

Вы утверждаете, что TDD снижает количество ошибок на 40–80%. Несмотря на
огромную ошибку этого значения (33%), даже в самом большом размере оно не
соответствует эффекту, который статические типы имеют в JavaScript и TypeScript.

Трудно недооценить негативное влияние этого на ваш
аргумент. Также трудно поверить, что вы могли пропустить этот
факт, если бы прочитали всю статью. Вот почему я говорю, что ваша статья
вводит в заблуждение и фактически неверна.

TDD сначала говорит тест, а затем напишите свой код. Вы не упомянули,
что подпись типа в строго типизированном языке:

1. Обычно пишется перед кодом и
2. Эквивалентен бесконечному количеству тестов.

В качестве очень простого примера представьте, что у вас есть эти две функции на языке
с динамической типизацией:

fakeId = function (x) {
if (x === 0.57483) {
return «gotcha»;
} else {
return x;
}

realId = функция (х) {вернуть х; }

Если никто не сказал вам, что константа x сравнивается (и помните:
это может быть строка, массив, объект и т. Д.), То какие тесты
вы бы написали, чтобы различать глючные функция идентификации
а какой? Ответ заключается в том, что вы не могли бы написать
теста, который бы обнаружил проблему. Это доказывает, что _ даже с
информацией, которой у вас нет в реальной жизни_ - например, с точным
знанием того, как проявляется ошибка - вы не можете написать тестовый пример, который
обнаружит эту ошибку. Однако предыдущий пример даже не скомпилировал
на строго статически типизированном языке.

Вы утверждаете, что системы типов допускают ошибки, которые может обнаружить тестирование.
Это правильно. Я продемонстрировал, что существуют классы
ошибок, которые (даже при тщательном) тестировании * невозможно * обнаружить, но
* статическая типизация * может *.

Таким образом, если системы типов позволяют выполнять бесконечное
количество тестов без необходимости явно записывать их,
также почти всегда используются до того, как разработчик начнет писать код,
тогда почему вы не видите их просто как еще один аспект TDD?
Вот почему ваш аргумент логически непоследователен.

Вы сравниваете JavaScript с TypeScript, но также делаете более общие
утверждения о статически типизированных языках в целом. Ваш аргумент
о том, что общие функции «шумнее», когда аннотированный тип неправильный,
в целом. В Haskell (или PureScript, если хотите) аннотированная функция идентификации типа
выглядит так:

id :: a -> a
id x = x

Это не шумно ни по одной метрике. Он состоит из двух частей - подписи,
и определения. Похоже, у вас проблема с _manifest,
системами встроенного типа, _ НЕ с _static type systems_.

Что касается функций высшего порядка и других типов полиморфизма, вы
также неправы, утверждая, что статическая типизация мешает.
Снова возьмем Haskell / PureScript в качестве примера (это просто
примеры Я больше всего знаком с), пожалуйста, объясните мне, почему функция
с аннотациями и документированием типа:

- | сортировать список xs, сравнивая элементы с помощью компаратора.
sortBy :: (a - ›a -› Ordering) - ›[a] -› [a]
sortBy компаратор xs = ‹реализация sortBy ›

- это любое« шумнее », чем эквивалент:

// компаратор - это функция, которая берет два элемента массива
// и сравнивает их, возвращая -1 для первого аргумента ‹второго аргумента, 0 для
// равенства и +1 для первого аргумента› второго арг. xs - это массив мусора.
// Возвращает новый отсортированный массив.
soryBy = function (comparator, xs) {
‹реализация sortBy›
}

Что, если компаратор вернет +2? Что, если он вернет «привет»? Лучше
напишите эти тесты! Лучше вставьте встроенные и ручные проверки типов и
затем выдавайте ошибки времени выполнения! К счастью, в случае со статической типизацией у нас
уже есть бесконечное количество тестов, которые служат
никогда не устаревшей-документацией, поэтому нам не нужно беспокоиться о
что. Аккуратный.

Ваш аргумент «шум» ужасно устарел и, похоже, исходит из
ассоциации статических типов и явных встроенных типов. Весь ваш аргумент
направлен на нападение на соломенного человека, поскольку эти две вещи на самом деле
разные проблемы.

На основании вышеизложенного я заключаю, что ваша статья вводит пользователей в заблуждение относительно
статических типов, и это настоящий позор. Типы составляют бесконечное
количество тестов, могут обнаруживать ошибки, которые не могут быть выполнены в тестах в стиле TDD,
не являются синонимами встроенного манифеста и сокращают количество ошибок больше, чем один только TDD
- в соответствии с вашими собственные источники.