Bohrbug: какво е, причини за поява и методи за коригиране

Какво е Bohrbug?

Bohrbug — е вид програмна грешка, която се проявява детерминирано: при еднакви входни данни винаги води до един и същ срив. Терминът е въведен в научно обръщение от изследователите Джим Грей и Андреас Ройтер в книгата „Transaction Processing: Concepts and Techniques” (1993).

За разлика от Mandelbug, който хаотично променя поведението си, Bohrbug е стабилен: разработчикът може да го възпроизведе със затворени очи, подавайки на системата същите параметри. Това го прави идеален кандидат за поетапно дебъгване в IDE.

Bohrbug се среща на всички етапи от жизнения цикъл на софтуера — от разработка до експлоатация. Често се открива в етапа на тестване, тъй като QA инженерите изпълняват повтарящи се сценарии, които гарантирано водят до срив.

Определение според Грей и Ройтер

Според класификацията на Грей и Ройтер, Bohrbug е дефект, който удовлетворява три условия: фиксиран набор от входни данни, еднакво състояние на системата и еднакъв резултат от срива. Ако поне едно от условията е нарушено, грешката престава да бъде „борова”.

Авторите подчертават, че Bohrbug не е задължително проста грешка. Тя може да бъде произволно сложна по логика, но нейният детерминизъм я отличава от всички останали видове сривове в класификацията.

Произход на името Bohrbug

Името Bohrbug произлиза от името на датския физик Нилс Бор, създател на планетарния модел на атома. Аналогията е проста: както електронът в модела на Бор се движи по строго фиксирана орбита, така и тази грешка повтаря същото поведение при всяко стартиране.

Грей и Ройтер избраха това име, за да противопоставят детерминираните грешки на хаотичните, които нарекоха Mandelbug — в чест на математика Беноа Манделброт, основател на теорията за фракталите и хаоса.

Интересно е, че в англоезичната литература терминът Bohrbug често се използва като синоним на „детерминирана грешка”, въпреки че в българската среда е по-слабо разпространен. Повечето разработчици наричат такива грешки просто „възпроизводими грешки”.

Ключови характеристики на Bohrbug

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

Детерминизъм

Основната черта на Bohrbug — пълна предвидимост. Ако приложението се срине с определени входни данни на машината на разработчика, то ще се срине точно по същия начин на машината на тестера и в продукционна среда. Без случайни фактори.

Възпроизводимост

Bohrbug се възпроизвежда в 100% от опитите. Това означава, че за дебъгването му не са необходими специални инструменти — достатъчни са обикновено IDE и дебъгер. Разработчикът поставя точка на прекъсване, стартира приложението, подава входните данни и преминава през кода стъпка по стъпка.

Стабилност във времето

Ако Bohrbug не бъде поправен, той ще се възпроизвежда във всяка версия на програмата до момента на поправката. Времевите фактори — натоварване на CPU, фаза на луната, време от деня — не влияят на проявлението му.

Основни причини за появата на Bohrbug

Причините за възникване на Bohrbug могат да бъдат разделени на няколко категории. Разбирането на тези категории помага за по-бързото намиране на корена на проблема.

Логически грешки

Неправилно изградено условие — най-честата причина за Bohrbug. Например, разработчикът е използвал оператора `||` вместо `&&`, което е довело до неправилно изпълнение на клон от кода при всяко извикване на функцията с определени аргументи.

Грешки в граничните условия

Използването на оператор `<=` вместо `<` или обратната ситуация — класически източник на Bohrbug. Ако цикълът трябва да се изпълни 10 пъти, но се изпълнява 11 поради грешно условие, това е детерминирана грешка, която ще се прояви при всяко стартиране.

Неверни константи и магически числа

Твърдо кодирани константи, които не съответстват на бизнес логиката, създават стабилни сривове. Например, таймаут за свързване към сървър е зададен на 100 милисекунди вместо 5000 — връзката ще се прекъсва при всяка заявка.

Как да открием Bohrbug в кода

Откриването на Bohrbug е най-лесната задача за разработчика в сравнение с други видове грешки. Детерминираният характер позволява прилагането на стандартни методи за дебъгване.

public class DiscountCalculator {
    public double calculate(double amount, boolean isPremium) {
        // Грешка: премиум потребителите получават 5% отстъпка вместо 10%
        if (isPremium) {
            return amount * 0.95;
        }
        return amount * 0.90;
    }
}

В този пример Bohrbug е очевиден: при извикване на `calculate(1000, true)` методът винаги връща 950 вместо 900. Най-простият unit тест с фиксирани входни данни незабавно ще разкрие проблема.

Unit тестването като основен метод

За откриване на Bohrbug unit тестовете са най-ефективното средство. Достатъчно е да покриете функцията с набор от тестове с различни гранични стойности и детерминираната грешка ще се прояви при първото изпълнение.

Поетапно дебъгване

Когато Bohrbug бъде открит, поетапното дебъгване в IDE е най-добрият начин за намиране на корена. Разработчикът поставя точка на прекъсване на входа на функцията и преминава през всеки ред, наблюдавайки стойностите на променливите.

Разлика между Bohrbug и други видове грешки

Bohrbug се различава от другите видове програмни грешки по ключов признак — детерминизъм. Нека разгледаме сравнението в таблица.

Bohrbug — единственият вид грешка, която може гарантирано да се възпроизведе в контролирани условия. Това го прави най-безопасен от гледна точка на диагностика, но не по-малко опасен за потребителя.

Защо бъркат Bohrbug и Heisenbug

Heisenbug — грешка, която изчезва при опит за дебъгване. За разлика от Bohrbug, Heisenbug може да не се възпроизведе в дебъгера поради промяна в таймингите на изпълнение на кода. Начинаещите разработчици често бъркат тези два вида.

Пример за Bohrbug в код

Нека разгледаме реален пример за Bohrbug в приложение за онлайн магазин. Функцията изчислява общата цена на поръчката, като взема предвид данъка.

public double calculateTotal(double subtotal, double taxRate) {
    // Грешка: разработчикът зададе taxRate като процент
    // но забрави да раздели на 100
    return subtotal + (subtotal * taxRate);
}

При извикване на `calculateTotal(1000, 20)` функцията ще върне 21000 вместо очакваните 1200. Това е класически Bohrbug: едни и същи входни данни винаги водят до един и същ грешен резултат. Поправката е тривиална — добавяне на деление на 100.

Коригиран вариант

След коригиране функцията обработва правилно данъчната ставка:

public double calculateTotal(double subtotal, double taxRatePercent) {
    return subtotal + (subtotal * taxRatePercent / 100.0);
}

Този пример ясно показва, че Bohrbug може да бъде причинен от най-простата математическа грешка. Точно затова код ревюто и unit тестовете са основните инструменти за превенция на такива дефекти.