bitrot имеет какие-либо принятые размеры?

Очень интересный ход мыслей!

Во-первых, что такое bitrot? Статья Rot программного обеспечения о Википедии собирает несколько точек:

• Изменение среды: изменения во времени выполнения
• Неиспользованный код: изменения в шаблонах использования
• Редко обновляемый код: изменения посредством обслуживания
• Рефакторинг: способ остановить bitrot

Законом Гордона Мура, delta(CPU)/delta(t) постоянный множитель два каждые 18 - 24 месяца. Так как среда содержит больше, чем ЦП, я предположил бы, что это формирует только очень слабую нижнюю границу на фактическом изменении в среде. Единица: OPS / $/s, изменяйтесь в Операциях в секунду на доллар со временем

delta(users)/delta(t) более твердо определить количество, но свидетельствовать в частоте случаев слов "Возраст Знания" в новостях, я сказал бы, что ожидания пользователей растут экспоненциально также. Путем рассмотрения разработки $/flops базовая экономика говорит нам, что предоставление становится быстрее, чем спрос, давая Закон Гордона Мура как верхнюю границу пользовательского изменения. Я буду использовать единицы функциональности ("функциональность торгового оборота, которую информационная система предоставляет пользователю") как мера требований. Единица: FP/s, изменяйтесь в необходимых Единицах функциональности со временем

delta(maintenance)/delta(t) зависит полностью от организации и обычно довольно высок сразу перед выпуском, когда быстрые исправления протолкнуты и при интеграции больших изменений. Изменения в различных мерах как SLOC, Цикломатическая Сложность или реализованные единицы функциональности со временем могут использоваться в качестве заместителя здесь. Другая возможность была бы маслобойкой ошибки в системе покупки билетов при наличии. Я буду оставаться с реализованными единицами функциональности со временем. Единица = FP/s, изменяйтесь в реализованных Единицах функциональности со временем

delta(refactoring)/delta(t) может измеряться как время, проведенное, не реализуя новые опции. Единица = 1, время тратило рефакторинг со временем

Таким образом, bitrot был бы

             d(env)     d(users)     d(maint)        d(t)
bitrot(t) = -------- * ---------- * ---------- * ----------------
              d(t)        d(t)        d(t)        d(refactoring)

             d(env) * d(users) * d(maint)
          = ------------------------------
                d(t)² * d(refactoring)

с объединенной единицей OPS/$/s * FP/s * FP/s = (OPS*FP²) / ($*s³).

Это - конечно, только очень принудительная псевдоматематическая нотация какой статья Wikipedia, уже сказанная: bitrot является результатом изменений в среде, изменений в требованиях пользователей и изменений в коде, в то время как это смягчено путем проведения времени на рефакторинге. Каждая организация должна будет решить для себя, как измерить те изменения, я только даю очень общие границы.

Я не соглашаюсь с Charlie: незначительный рефакторинг исходного кода может привести к очень большим Расстояниям Хемминга и не обеспечивает хорошую меру градуса, до которого был логически изменен код.

Я рассмотрел бы рассмотрение длины комментариев фиксации. Для данного программиста относительно длинный комментарий фиксации обычно указывает, что они внесли существенное изменение в код.

Как насчет самого простого ответа?

foreach (file in source control){
  file.RotLevel = (Time.Now - file.LastTestedOrDeployed)
}

Если файл не был развернут (или на производстве или на тестовой машине) в течение долгого времени, это может быть вне синхронизации с "действительностью". Среда, возможно, изменилась, и даже если файл не был изменен, это больше не может работать. Таким образом, это, кажется, мне простая и точная формула. Почему делают это более сложным, чем это? Вовлечение количества изменений, кажется, добавляет только неуверенность. Если файл был недавно изменен, который означает, что был обновлен для отражения изменения в среде (который делает его "менее гнилым"), или новые опции были добавлены (увеличение риска ошибок, и так создание его "более гнилой")? Модификации в файл могли означать что-либо.

Единственный однозначный фактор, о котором я могу думать, "сколько времени как, так как мы в последний раз проверили, что файл работал?"

Мне вспоминается Планирование на основе доказательств . Придумайте набор разумных метрик для обозначения битрота (как его фактического значения, так и того, насколько оно было уменьшено конкретным изменением). Затем определите, насколько они точны, исходя из времени, потраченного позже. Придумать числа и правила для этого, вероятно, сложно.

Обратная пропорция количества модульных тестов к общим строкам кода?

Думайте приблизительно две возможных меры: различия в редактировании, как расстояние Hamming или Wagner; и информационно-теоретическая энтропия.

Если Вы действительно интересуетесь рытьем в это, там существует некоторое исследование. Я изучал понятия от статьи, которая исследовала эффект Организационной Структуры на Качестве программного обеспечения только что. Я закончил тем, что регистрировал идеи далеко позади моей головы, но Вы могли бы найти это просвещением.

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

Файлы, которые часто изменяются (конфигурация и т. Д.), Не фиксируя большое значение, не будут отображаться, потому что ошибка в уравнении будет низкой. Файл с большим количеством открытых ошибок будет отображаться так же, как и файлы, где изменения часто приводят к новым ошибкам.

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

Но высококачественные модульные тесты, очевидно, обеспечат некоторую защиту.

Так что это мои важные факторы для программного гниения:

1. ] Количество точек интерфейса внешних данных (extDataIntfPts)
   • Качество обработки данных / ошибок, модульные тесты (codeQuality)
   • Зависимость от базовых реализаций, таких как OS / VM. (osDep)
   • Количество внешних точек реализации интерфейса, таких как плагины. (extIntfPts)
   • Сложность кода / простой объем кода (linesOfCode)

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

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

Есть также движущиеся цели базовой среды что система работает. Один из способов смягчить это - поместить приложение в виртуальную машину.

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

Сложный код! = Элегантный код. Если это элегантно, то, вероятно, просто. Здесь я пойму простую мысль: чем больше кода, тем меньше вероятность того, что он будет хорошо протестирован, но я полагаю, что его можно перевернуть.

Итак, вот мое уравнение:

bitrot=((linesofcode/codeQuality)*(extDataInfPts+(osDep/change)+extIntfPts)*numberOfSecondsDeployed)

Оценка codeQuality вероятно, будет включать в себя показатель того, что покрытие кода в модульных тестах. Вы можете запустить программу статического анализа для определения потенциальных ошибок, и это, вероятно, также поможет. Я имею в виду, что в какой-то момент очень сложно оценить, потому что многопоточный код должен быть намного тяжелее, чем POJO. И да, рефакторинг должен быть учтен, но только там, где есть свидетельства гниения программного обеспечения.

В конце концов, это ' са псевдонаука. Вот мой вклад в псевдонауку.

Реальный битрот (не программный гниль) имеет размеры физического объема памяти * время.

Битрот вызван радиоактивный распад примесей в среде хранения.