Категории программных ошибок функциональные недостатки

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

В этой статье мы обсудим самые распространенные типы ПО дефекты и способы их выявления.

Что такое дефект?

Дефект программного обеспечения — это ошибка, изъян, сбой или неисправность в компьютерной программе, из-за которой она выдает неправильный или неожиданный результат или ведет себя непреднамеренным образом. Программная ошибка возникает, когда фактические результаты не совпадают с ожидаемыми. Разработчики и программисты иногда допускают ошибки, которые создают ошибки, называемые дефектами. Большинство ошибок возникает из-за ошибок, которые допускают разработчики или программисты.

Обязательно прочтите: Разница между дефектом, ошибкой, ошибкой и сбоем

Типы программных ошибок при тестировании программного обеспечения

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

Ошибки программного обеспечения подразделяются на три типа:

1. Дефекты программного обеспечения по своей природе
2. Дефекты программного обеспечения по их приоритету
3. Дефекты программного обеспечения по их серьезности

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

#1. Дефекты программного обеспечения по своей природе

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

#1. Функциональные ошибки

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

Функциональные ошибки можно исправить, выполнив функциональное тестирование.

#2. Ошибки на уровне модуля

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

Ошибки на уровне модуля можно исправить, выполнив модульное тестирование.

#3. Ошибки уровня интеграции

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

Ошибки интеграции можно исправить, выполнив интеграционное тестирование.

#4. Дефекты юзабилити

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

Во время тестирования удобства использования тестировщики программного обеспечения проверяют приложения на соответствие требованиям пользователей и Руководству по доступности веб-контента (WCAG) для выявления таких проблем. Однако они могут оказать существенное влияние на общее качество программного обеспечения.

Ошибки, связанные с удобством использования, можно исправить, выполнив тестирование удобства использования.

#5. Дефекты производительности

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

Ошибки юзабилити можно исправить, выполнив тестирование производительности.

#6. Дефекты безопасности

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

Ошибки безопасности можно исправить, выполнив тестирование безопасности.

#7. Дефекты совместимости

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

Ошибки совместимости можно исправить, выполнение тестирования совместимости.

#8. Синтаксические ошибки

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

#9. Логические ошибки

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

Общие симптомы логических ошибок включают:

• Неверные результаты или выходные данные
• Неожиданное поведение
• Сбой или зависание программного обеспечения

Чтобы найти и исправить логические ошибки, тестировщикам необходимо иметь четкое представление о коде программы и о том, как она должна работать. Часто лучший способ найти такие ошибки — использовать инструменты отладки или пошаговое выполнение, чтобы отслеживать выполнение программы и видеть, где что-то идет не так.

#2. Дефекты программного обеспечения по степени серьезности

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

#1. Критические дефекты

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

#2. Серьезные дефекты

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

#3. Незначительные дефекты

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

#4. Тривиальные дефекты

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

#3. Дефекты программного обеспечения по приоритету

#1. Дефекты с низким приоритетом

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

#2. Дефекты со средним приоритетом

Дефекты со средним приоритетом — это ошибки, которые могут быть исправлены после предстоящего выпуска или в следующем выпуске. Приложение, возвращающее ожидаемый результат, которое, однако, неправильно форматируется в конкретном браузере, является примером дефекта со средним приоритетом.

#3. Дефекты с высоким приоритетом

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

Некоторые распространенные примеры дефектов с высоким приоритетом включают:

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

#4. Срочные дефекты

Срочные дефекты — это дефекты, которые необходимо устранить в течение 24 часов после сообщения о них. В эту категорию попадают дефекты со статусом критической серьезности. Однако дефекты с низким уровнем серьезности также могут быть классифицированы как высокоприоритетные. Например, опечатка в названии компании на домашней странице приложения не оказывает технического влияния на программное обеспечение, но оказывает существенное влияние на бизнес, поэтому считается срочной.

#4. Дополнительные дефекты

#1. Отсутствующие дефекты

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

#2. Неправильные дефекты

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

#3. Дефекты регрессии

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

Часто задаваемые вопросы — Типы программных ошибок< /h2>

Почему так важна правильная классификация дефектов?

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

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

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

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

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

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

Как найти лежащие в основе ошибки программного обеспечения?

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

1) Репликация. Первым этапом является воспроизведение ошибки. Это включает в себя попытку воспроизвести тот же набор шагов, в котором возникла ошибка. Это поможет проверить, является ли ошибка реальной или нет.
2) Изоляция. После того, как ошибка воспроизведена, следующим шагом будет попытка ее изоляции. Это включает в себя выяснение того, что именно вызывает ошибку. Для этого тестировщики должны задать себе несколько вопросов, например:
– Какие входные данные вызывают ошибку?
– При каких различных условиях возникает ошибка?
– Каковы различные способы проявления ошибки?
3) Анализ: после Изолируя ошибку, следующим шагом будет ее анализ. Это включает в себя понимание того, почему возникает ошибка. Тестировщики должны задать себе несколько вопросов, таких как:
– Какова основная причина ошибки?
– Какими способами можно исправить ошибку?
– Какое исправление было бы наиболее эффективным? эффективно?
4) Отчет. После анализа ошибки следующим шагом является сообщение о ней. Это включает в себя создание отчета об ошибке, который включает всю соответствующую информацию об ошибке. Отчет должен быть четким и кратким, чтобы разработчики могли его легко понять.
5) Проверка. После сообщения об ошибке следующим шагом является проверка того, была ли она исправлена. Это включает в себя повторное тестирование программного обеспечения, чтобы убедиться, что ошибка все еще существует. Если ошибка исправлена, то тестер может подтвердить это и закрыть отчет об ошибке. Если ошибка все еще существует, тестировщик может повторно открыть отчет об ошибке.

Заключение

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

Задавая правильные вопросы и применяя правильные методы, тестировщики могут помочь обеспечить чтобы дефекты обнаруживались и исправлялись как можно раньше в процессе разработки.
TAG: qa

К вопросу о классификации программных ошибок

Березкин
Д.В.

Определение
понятия «ошибка в программе» 1

Классификация
ошибок по месту их возникновения 2

Классификация
ошибок с точки зрения тестировщика 12

Классификация
ошибок по степени их критичности 13

Классификация
ошибок в зависимости от их места в
жизненном цикле программного изделия 14

Классификация
программных ошибок (багов) с точки
зрения субъективного восприятия их
программистами 15

Некоторые
выводы 16

Литература 16

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

По определению стандарта ISO
9241-13 [1] ошибка это – несоответствие
между целями пользователя и ответом
системы.

Определение, приведенное в работе [2],
предполагает, что ошибка вызвана не
сложностью задачи, а сложностью орудия
(напр., компьютерной системы), поэтому
она является не ошибкой пользователя,
а ошибкой разработчиков этого орудия.

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

Определение понятия «ошибка в программе»

В самом общем случае под ошибкой
понимается какой-то сбой в программе
на этапе ее выполнения.

Ошибкой (или так называемым багом) можно
назвать недокументированные или
нежелательные, «побочные» реакции
программы на те или иные действия
пользователя равно как и при использовании
ее одновременно с другим программами
или на другой аппаратной платформе.

Майерс дает такое нестрогое определение:
«Если программа не делает того, чего
пользователь от нее вполне обосновано
ожидает, значит налицо программная
ошибка» [3].

Автор работы [4] настаивает на субъективном
характере программных ошибок: «Не
существует ни абсолютного определения
ошибок, ни точного критерия наличия их
в программе. Можно лишь сказать, насколько
программа не справляется со своей
задачей, — это исключительно субъективная
характеристика».

Канер с соавторами [5] указывают, что
определение ошибок как расхождение
между программой и ее спецификацией —
не верно. Они исходят из того, что даже
точно соответствующая спецификации
программа содержит ошибки в том случае,
если есть ошибки и в самой спецификации.

В книге [6] приводится такое определение
программных ошибок: «Говоря простыми
словами, программная ошибка — не что
иное, как изъян в разработке программного
продукта, который вызывает несоответствие
ожидаемых результатов выполнения
программного продукта и фактически
полученных результатов. Дефект может
возникнуть на стадии кодирования, на
стадии формулирования требований или
на стадии проектирования, либо же его
причина может крыться в некорректной
конфигурации или данных. Дефектом может
быть также что-то другое, что не
соответствует ожиданиям заказчика и
что может быть, а может и не быть определено
в спецификации программного продукта».

Классификация ошибок по месту их возникновения

Классификация ошибок в книге [5] дается
по месту их возникновения. В главе 4
приводится краткая классификация ошибок
и в Приложении – более полная, которая,
на мой взгляд, не имеет строгих принципов
и является скорее перечнем возможных
ошибок, чем их классификацией. Авторы
исходят из того, что главным критерием
программы должно быть ее качество,
которое трактуется как отсутствие в
ней недостатков, а также сбоев и явных
ошибок. Недостатки программы зависят
от субъективной оценкой ее качества
потенциальным пользователем. При этом
авторы скептически относятся к
спецификации и утверждают, что даже при
ее наличии, выявленные на конечном этапе
недостатки говорят о ее низком качестве.
При таком подходе преодоление недостатков
программы, особенно на заключительном
этапе проектирования, может приводить
к снижению надежности. Очевидно, что
для разработки ответственного и
безопасного программного обеспечения
(ПО) такой подход не годится, однако
проблемы наличия ошибок в спецификациях,
субъективного оценивания пользователем
качества программы существуют и не
могут быть проигнорированы. Должна быть
разработана система некоторых ограничений,
которая бы учитывала эти факторы при
разработке и сертификации такого рода
ПО. Для обычных программ все проблемы,
связанные с субъективным оцениванием
их качества и наличием ошибок, скорее
всего неизбежны.

В краткой классификации выделяются
следующие ошибки.

Ошибки пользовательского интерфейса.

Функциональность.

Взаимодействие программы с пользователем.

Организация программы.

Пропущенные команды.

Производительность.

Выходные данные.

Обработка ошибок.

Ошибки, связанные с обработкой граничных
условий.

Ошибки
вычислений.

Начальное и последующие состояния.

Ошибки управления потоком.

Ошибки передачи или интерпретации
данных.

Ситуация гонок.

Перегрузки.

Аппаратное обеспечение.

Контроль версий.

Документация.

Ошибки тестирования.

Подробная классификация с небольшой
правкой и моими комментариями приведена
ниже.

Ошибки пользовательского интерфейса.

Многие
из них субъективны, т.к. часто они
являются скорее неудобствами, чем
«чистыми» логическими ошибками. Однако
они могут провоцировать ошибки
пользователя программы или же замедлять
время его работы до неприемлемой
величины. В результате чего мы будем
иметь ошибки информационной системы
(ИС) в целом. Основным источником таких
ошибок является сложный компромисс
между функциональностью программы и
простотой обучения и работы пользователя
с этой программой. Проблему надо начинать
решать при проектировании системы на
уровне ее декомпозиции на отдельные
модули, исходя из того, что вряд ли
удастся спроектировать простой и удобный
пользовательский интерфейс для модуля,
перегруженного различными функциями.
Кроме того, необходимо учитывать
рекомендации по проектированию
пользовательских интерфейсов, например
[7]. В этой книге приводятся простые
модели проверки качества интерфейса,
которые можно использовать на стадии
его проектирования. На этапе тестирования
ПО полезно предусмотреть встроенные
средства тестирования, которые бы
запоминали последовательности действий
пользователя, время совершения отдельных
операций, расстояния перемещения курсора
мыши. Кроме этого возможно применение
гораздо более сложных средств
психо-физического тестирования на этапе
тестирования интерфейса пользователя,
которые позволят оценить скорость
реакции пользователя, частоту этих
реакций, утомляемость и т.п. Необходимо
отметить, что такие ошибки очень критичны
с точки зрения коммерческого успеха
разрабатываемого ПО, т.к. они будут в
первую очередь оцениваться потенциальным
заказчиком.

Ошибки функциональности.

«Если с помощью программы трудно,
неудобно или невозможно выполнить
что-то, чего может обоснованно ожидать
от нее пользователь, значит, в ней имеется
функциональная ошибка». Очень расплывчатое
определение, хотя возможно, что и верное.
Как уже отмечалось, авторы книги [5]
предполагают наличие ошибок в спецификации
программы. Авторы подразделяют ошибки
функциональности, однако трудно провести
грань между функциональными и другими
видами ошибок.

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

Ложное впечатление о наборе функций
продукта. Связано в первую очередь с
ошибками или низким качеством документации.
Сюда же можно отнести не документируемые
функции программы и закладки. Очень
важный пункт с точки зрения безопасного
ПО: необходимо обеспечить строгое
соответствие описания программы и ее
функций.

Неадекватность реализации базовых
функций. Функция реализована так, что
не годится для эксплуатации. Сюда
относятся вопросы недостаточной
производительности.

Пропущенная функция. В программе
не реализована функция, предусмотренная
спецификацией.

Неверно работающая функция. Функция
работает не так, как предусмотрено
спецификацией.

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

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

Взаимодействия программы и пользователя.
Их появление возможно как в интерактивном,
так и в пакетном режимах.

Пропущенная информация. Сюда
относятся типичные ошибки интерфейса:
ошибки в подсказках, в перечне возможных
команд, отсутствие справочной информации
и т.п., отсутствие индикации курсора или
признаков активности выполнения
программы, открытия документов. Сюда
необходимо отнести ошибки, когда
пользователю не выдана, предусмотренная
спецификацией информация, но почему-то
именно этот случай не отражен в работе
[5]. Для некоторых видов ПО подобная
ошибка может быть весьма критичной
(например, если не отражена информация
о наступлении важного события, аварии
в системе и т.п.).

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

Справочная система и сообщения об
ошибках. Текст в электронном виде
должен быть не сложнее, чем на бумаге
(максимальный уровень сложности 5). Текст
должен быть написан простым языком,
сообщения программ должны быть в
утвердительной форме, краткими и
простыми, содержать минимум технических
терминов. Нужно избегать неуместной
эмоциональности и слов, которые могут
напугать пользователя. Документация
не должна содержать ошибок и неверных
примеров. Контекстно-зависимые справочные
системы и подсистемы обработки ошибок
должны проверять, что делает программа
в момент их вызова. Неправильное
определение источника ошибки в сообщении,
должны указываться причина ошибки и
способ выхода из ситуации.

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

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

Организация экрана. Плохая
структурированность информации на
экране, неэстетическое оформление
экрана, неудачная организация меню,
ошибки организации диалоговых окон,
труднонаходимые конструкции, неуместное
использование мигания, пестрые цветовые
сочетания, использование цветов в
качестве смыслового интерфейса,
невозможность избавиться от избыточной
информации на экране – все это «ошибки
интерфейса».

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

Потери времени. Имеются в виду потери
времени из-за неудачного интерфейса
программы.

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

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

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

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

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

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

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

Кто здесь главный? В этом пункте
авторы работы [5] опять возвращаются к
ошибкам в сообщениях программ и
недостаткам команд. Получился как бы
еще один раздел «Разное», который
включает следующие ошибки: навязывание
ненужных ограничений, дружественность
к новичкам, создающая неудобства для
опытных пользователей, навязчивая
предупредительность и неудачная попытка
сделать программу интеллектуальной,
запрос информации без необходимости,
ненужное повторение действий, ненужные
ограничения.

Производительность. Авторы отмечают
существование нескольких трактовок
этого понятия: 1) скорость программы, 2)
производительность работы пользователя,
3) субъективное восприятие пользователем
характеристик производительности
программы. В связи с этим возможна
ситуация, когда высокоскоростная
программа с неудачным пользовательским
интерфейсом кажется медленнее, чем на
самом деле. Какая-то логика в этом
безусловно есть, но представляется
более правильным разделить производительность
программы при решении ее основных
функциональных задач, которая в
большинстве случаев не зависит от
пользователей и может быть точно
замерена, и производительность
непосредственно интерфейса. При всей
субъективности этой характеристики
она может быть оценена на стадии
разработки интерфейса, а затем и измерена
специальными средствами.

В разделе выделяются следующие подразделы:
низкоскоростная программа (ошибки
проектирования и кодирования), задержка
реакции на действия пользователя,
большое время ответа, программа не
распознает ввод, отсутствие предупреждений
о длительных операциях, отсутствие
индикаторов хода работы, проблемы
тайм-аутов (здесь речь идет об искусственных
ограничениях времени ввода данных или
паузах при совершении каких-то действий),
надоедливая программа, избыточная
информация, передавая по медленным
сетям (проблема рассматривается только
с точки зрения интерфейса пользователя,
хотя проблема должна решаться при
проектировании системы в целом). Далее
приводятся ряд ошибок, которые явно не
из этого раздела: выходная информация
должна быть полной и понятной пользователю,
невозможно получить определенные
данные, невозможно перенаправить вывод,
формат, неподходящий для дальнейшей
обработки (речь идет об ошибках в
программных интерфейсах, явно напрашивается
вывод — выделить их в раздел: «Ошибки
взаимодействия программ»), слишком мало
или слишком много выходной информации,
абсурдная степень точности, невозможность
форматирования заголовков таблиц и
подписей рисунков, невозможность
изменения масштаба графиков. Необходимо
отметить, что последние 2 пункта являются
слишком частными, поэтому вызывает
сомнение необходимость включать
настолько частные ошибки в общую
классификацию.

Авторы работы [5] подчеркивают, что
вопросы производительности нельзя
рассматривать без учета работы
пользователя, поэтому выделяются такие
«узкие места», как: все, что повышает
вероятность ошибок пользователя,
громоздкая схема исправления ошибок,
все, что ставит пользователя в тупик,
неоправданное увеличение количества
действий, необходимых для достижения
определенного результата.

Обработка ошибок.

Предотвращение ошибок. Программа
должна быть защищена от недопустимого
ввода и неправильной эксплуатации.
Должна быть предусмотрена проверка
вводимых данных. Можно использовать
методы аппаратного обнаружения и
исправления ошибок.

Выделяются подпункты:

неверное начальное состояние;

неадекватная проверка пользовательского
ввода;

неадекватная защита от испорченных
данных;

не выполнена проверка переданных
параметров;

недостаточная защита от ошибок
операционной системы;

не выполняется проверка версии;

недостаточная защита от неправильного
использования («защита от дурака»).

Выявление ошибок. Программа должна
контролировать правильность данных.

Выделяются подпункты:

переполнение;

невозможные значения;

непроверенные данные;

флаги ошибок;

аппаратные сбои;

сравнение данных;

восстановление после ошибок;

автоматическое исправление ошибок;

отсутствие сообщения об ошибке;

не установлен флаг ошибки;

куда возвращается управление? (Ошибки
передачи управления после сбоя);

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

обработка аппаратных отказов;

ну нет у меня нужного диска! Программа
должна предусматривать какой-то выход
из ситуации, когда пользователь не в
состоянии выполнить требуемое действие.

Ошибки, связанные с граничными
условиями.

Выделяют следующие типы таких ошибок:

неправильная обработка граничного
значения;

неверное граничное условие;

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

Выделяются следующие подпункты:

числовые ограничения;

ограничения на равенство;

количественные ограничения;

пространственные ограничения;

ограничения времени (имеются в виду
вопросы, связанные с поведением системы
на границах заданных в программе
временных интервалов);

условия циклов;

ограничения объема памяти;

ограничения, связанные со структурой
данных;

ограничения, связанные с аппаратным
обеспечением;

невидимые границы.

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

Ошибки вычислений.

Авторы работы [5] выделяют следующие
причины возникновения таких ошибок:

неверная логика (может быть следствием,
как ошибок проектирования, так и
кодирования);

неправильно выполняются арифметические
операции (как правило – это ошибки
кодирования);

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

Выделяются подпункты:

устаревшие константы;

ошибки вычислений;

неверно расставленные скобки;

неправильный порядок операторов;

неверно работает базовая функция;

переполнение и потеря значащих разрядов;

ошибки отсечения и округления;

путаница с представлением данных;

неправильное преобразование данных из
одного формата в другой;

неверная формула;

неправильное приближение.

Начальное и последующие состояния
(Ошибки инициализации).

Представляется не очень обоснованным
их выделение в самостоятельный раздел,
хотя они важны.

Выделяются подпункты:

не присвоены начальные значения;

не инициализирована переменная,
управляющая циклом;

не инициализирован указатель;

не очищена строка;

не инициализированы регистры;

не сброшен флаг;

данные должны были инициализироваться
в другом месте;

не выполнена повторная инициализация;

предположение (не верное), что данные
не были инициализированы;

путаница со статическими и динамическими
переменными;

не предполагавшаяся модификация данных,
выполняемая другими подпрограммами;

ошибочная инициализация;

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

Ошибки управления потоком.

В этот раздел относится все то, что
связано с последовательностью и
обстоятельствами выполнения операторов
программы.

Выделяются подпункты:

очевидно неверное поведение программы;

переход по GOTO;

логика, основанная на определении
вызывающей подпрограммы;

использование таблиц переходов;

выполнение данных (вместо команд).
Ситуация возможна из-за ошибок работы
с указателями, отсутствия проверок
границ массивов, ошибок перехода,
вызванных, например, ошибкой в таблице
адресов перехода, ошибок сегментирования
памяти;

переход к подпрограмме, которая
отсутствует в памяти. Ошибки связаны с
ошибками в организации оверлейных
программ;

реентерабельность. Реентерабельная
программа может вызывать сама себя или
быть вызвана несколькими параллельными
процессами одновременно. Такая возможность
может не поддерживаться языком
программирования. Если она поддерживается,
то нужно обеспечить защиту данных,
используемых одним процессом, от их
модификации другим;

путаница имен переменных и команд;

неверное предположение о состоянии
программы или данных после вызова;

обработка ошибок выполнения процедур
(имеются в виду ошибки, когда программист
не предусмотрел такую обработку);

возврат не в ту точку кода (сюда включены
несколько видов ошибок: испорченный
стек, переполнение и выход за нижнюю
границу стека, выход из подпрограммы
по GOTO вместо RETURN);

прерывания (сюда включены несколько
видов ошибок: неверная таблица прерываний,
ошибки, связанные с модификацией
программами таблицы прерываний, ошибки,
связанные с блокированием прерываний,
неудачное возобновление работы программы
после прерывания);

завершение работы программы;

«зависание» компьютера;

синтаксические ошибки, сообщения о
которых отображаются во время выполнения
программы (имеются в виду программы,
написанные на интерпретируемом языке
программирования);

ожидание невозможных условий или
комбинаций условий (примерами таких
ошибок являются: проблемы ввода/вывода,
взаимная блокировка, простая логическая
ошибка в условиях);

неверный приоритет пользователя или
процесса;

циклы (сюда включены несколько видов
ошибок: бесконечный цикл, неверное
начальное значение переменной управления
циклом, случайное изменение переменной
управления циклом, ошибочный критерий
выхода из цикла, команды, которые должны
или не должны выполняться внутри цикла,
ошибка вложенности циклов);

условные операторы (Сюда включены
несколько видов ошибок: неправильное
сравнение, неверные результаты сравнений,
условный оператор не учитывает модификации
программы, ошибки сравнения значений
переменных с плавающей точкой из-за
округлений, спутаны логические операторы,
присваивание вместо сравнения, ошибки
в использовании конструкции THRN/ELSE,
команды, которые не входят ни в одно из
предложений, не проверен флаг, не сброшен
флаг. Кроме этого в этом же подразделе
рассматривается сложный условный
оператор, содержащий многочисленные
варианты ветвления. В этом случае
возможны следующие ошибки: пропущен
блок, выполняемый во всех остальных
случаях, неверно определены действия
для всех остальных случаев, пропущенные
варианты, требуется подразделение
одного варианта на несколько, пересекающиеся
условия, неверные условия и невозможные
случаи).

Ошибки обработки или интерпретации
данных.

Выделяются подпункты:

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

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

проблемы с обменом сообщений (сюда
включены несколько видов ошибок: отправка
сообщения не тому процессу или не в тот
порт, ошибка распознавания полученного
сообщения, недостающие или
несинхронизированные сообщения,
сообщение передано только N
процессам из N+1, порча
данных, хранящихся на внешнем устройстве,
потеря изменений, не сохранены введенные
данные, объем данных слишком велик для
процесса-получателя, неудачная попытка
отмены записи данных).

Ситуация гонок.

Выделяются подпункты:

гонки при обновлении данных;

предположение, что одно задание завершится
до начала другого;

предположение, что в течение определенного
короткого интервала времени не будет
ввода данных;

предположение, что в течение определенного
короткого интервала времени не будет
прерываний;

ресурс только что стал недоступен;

предположение, что человек, устройство
или процесс ответят быстро;

реальный набор опций в процессе
перерисовки экрана;

задание начинается до того, как выполнены
подготовительные действия;

сообщения приходят одновременно или
не в том порядке, в котором они были
отправлены.

Повышенные нагрузки.

При повышенных нагрузках или нехватке
ресурсов могут возникнуть дополнительные
ошибки. Выделяются подпункты:

требуемый ресурс недоступен;

не освобожден ресурс;

нет сигнала об освобождении устройства;

старый файл не удален с накопителя;

системе не возвращена неиспользуемая
память;

лишние затраты компьютерного времени;

нет свободного блока памяти достаточного
размера;

недостаточный размер буфера ввода или
очереди;

не очищен элемент очереди, буфера или
стека;

потерянные сообщения;

снижение производительности;

повышение вероятности ситуационных
гонок;

при повышенной нагрузке объем
необязательных данных не сокращается;

не распознается сокращенный вывод
другого процесса при повышенной загрузке;

не приостанавливаются задания с низким
приоритетом;

задания с низким приоритетом вообще не
выполняются.

В этом разделе хотелось бы обратить
внимание на следующее:

1) Часть ошибок из этого раздела могут
проявляться и при не очень высоких
нагрузках, но, возможно, они будут
проявляться реже и через более длительные
интервалы времени;

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

Аппаратное обеспечение.

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

неверное устройство;

неверный адрес устройства;

устройство недоступно;

устройство возвращено не в тот пул;

данному пользователю или программе
использование устройства запрещено;

данный уровень привилегий не позволяет
получить доступ к устройству;

шумы;

прерывание связи;

проблемы тайм-аута;

неверный накопитель;

не проверяется содержимое текущего
диска;

не закрыт файл;

неожиданный конец файла;

ошибки, связанные с длиной файлов и
дисковыми секторами;

неверный код операции или команды;

неверно интерпретирован код состояния
или возврата;

ошибка протокола обмена с устройством;

неполное использование возможностей
устройства;

игнорирование или неправильно используется
механизм страничного управления памятью;

игнорирование ограничений канала;

предположения о наличии или отсутствии
устройства или его инициализации;

программируемые функциональные клавиши.

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

Контроль версий и идентификаторов.

Выделяются подпункты:

таинственным образом появляются старые
ошибки;

обновление не всех копий данных или
программных файлов;

отсутствие заголовка;

отсутствие номера версии;

неверный номер версии в заголовке
экрана;

отсутствующая или неверная информация
об авторских правах;

программа, скомпилированная из архивной
копии, не соответствует проданному
варианту;

готовые диски содержат неверный код
или данные.

Ошибки тестирования.

Являются ошибками сотрудников группы
тестирования, а не программы. Выделяются
подпункты:

пропущенные ошибки в программе;

не замечена проблема (отмечаются
следующие причины этого: тестировщик
не знает, каким должен быть правильный
результат, ошибка затерялась в большом
объеме выходных данных, тестировщик не
ожидал такого результата теста,
тестировщик устал и невнимателен, ему
скучно, механизм выполнения теста
настолько сложен, что тестировщик
уделяет ему больше внимания, чем
результатам);

пропуск ошибок на экране;

не документирована проблема (отмечаются
следующие причины этого: тестировщик
неаккуратно ведет записи, тестировщик
не уверен в том, что данные действия
программы являются ошибочными, ошибка
показалась слишком незначительной,
тестировщик считает, что ошибку не будет
исправлена, тестировщика просили не
документировать больше подобные ошибки);

не выполнен запланированный тест
(отмечаются следующие причины этого:
тестовые материалы и записи плохо
организованы, тестировщику скучно
выполнять однотипные примеры, в одном
тесте объединено слишком много действий);

не описаны временные зависимости
появления ошибок;

слишком сложный тест (не позволяет
ошибку и добиться ее воспроизведения);

преувеличения;

личные выпады.

Ошибка выявлена и забыта.

Описываются ошибки использования
результатов тестирования. По-моему,
раздел следует объединить с предыдущим.
Выделяются подпункты:

не составлен итоговый отчет;

серьезная проблема не документирована
повторно;

не проверено исправление;

перед выпуском продукта не проанализирован
список нерешенных проблем.

Необходимо заметить, что изложенные в
2-х последних разделах ошибки тестирования
требуют для устранения средств
автоматизации тестирования и составления
отчетов. В идеальном случае, эти средства
должны быть проинтегрированы со
средствами и технологиями проектирования
ПО. Они должны стать важными инструментальными
средствами создания высококачественного
ПО. При разработке средств автоматизированного
тестирования следует избегать ошибок,
которые присущи любому ПО, поэтому нужно
потребовать, чтобы такие средства
обладали более высокими характеристиками
надежности, чем проверяемое с их помощью
ПО.

Содержание:

Введение

Программное обеспечение, согласно ГОСТ 19781-90, – совокупность программ системы обработки информации и программных документов, необходимых для их эксплуатации.

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

Проблема надежности программного обеспечения относится, похоже, к категории «вечных». В посвященной ей монографии Г.Майерса, выпущенной в 1980 году (американское издание — в 1976), отмечается, что, хотя этот вопрос рассматривался еще на заре применения вычислительных машин, в 1952 году, он не потерял актуальности до настоящего времени. Отношение к проблеме довольно выразительно сформулировано в книге Р.Гласса: «Надежность программного обеспечения — беспризорное дитя вычислительной техники». Следует далее отметить, что сама проблема надежности программного обеспечения имеет, по крайней мере, два аспекта: обеспечение и оценка (измерение) надежности. Практически вся имеющаяся литература на эту тему, включая упомянутые выше монографии, посвящена первому аспекту, а вопрос оценки надежности компьютерных программ оказывается еще более «беспризорным». Вместе с тем очевидно, что надежность программы гораздо важнее таких традиционных ее характеристик, как время исполнения или требуемый объем оперативной памяти, однако никакой общепринятой количественной меры надежности программ до сих пор не существует.

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

Цель данной работы – рассмотреть классификацию ошибок программного обеспечения для обеспечения его надежности.

Надежность программного обеспечения

Показатели качества программного обеспечения

Оценка качества программного обеспечения могут проводиться с двух позиций: с позиции положительной эффективности и непосредственной адекватности их характеристик назначению, целям создания и применения, а также с негативной позиции, возможного при этом ущерба – риска от пользования ПС или системы. Показатели качества преимущественно отражают положительный эффект от применения программного обеспечения и основная задача разработчиков проекта состоит в обеспечении высоких значений качества. Риски характеризуют возможные негативные последствия проявившихся в ходе эксплуатации ошибок или ущерб для пользователя при применении и функционировании программного обеспечения.

Согласно ГОСТ 9126[2], качество программного обеспечения – это весь объем признаков и характеристик программного обеспечения, который относится к ее способности удовлетворять установленным или предполагаемым потребностям.

Качество программного обеспечения оценивается следующими характеристиками:

• Функциональные возможности (Functionality). Набор атрибутов, относящихся к сути набора функций и их конкретным свойствам. Функциями являются те, которые реализуют установленные или предполагаемые потребности.
• Надежность (Reliability). Набор атрибутов относящихся к способности программного обеспечения сохранять свой уровень качества функционирования при установленных условиях за установленный период времени.
• Практичность (Usability). Набор атрибутов, относящихся к объему работ, требуемых для использования и индивидуальной оценки такого использования определенным и предполагаемым кругом пользователей.
• Эффективность (Efficiencies). Набор атрибутов, относящихся к соотношению между уровнем качества функционирования программного обеспечения и объемом используемых ресурсов при установленных условиях.
• Сопровождаемость (Maintainability). Набор атрибутов, относящихся к объему работ, требуемых для проведения конкретных изменений (модификаций).
• Мобильность (Portability). Набор атрибутов, относящихся к способности программного обеспечения быть перенесенным из одного окружения в другое.

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

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

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

По правилу, установленному в [2], надежность – свойство объекта осуществлять заданные функции, храня во времени значения установленных эксплуатационных показателей в заданных пределах, соответствующим заданным режимам и условиям использования, ремонта, технического обслуживания, хранения, транспортирования.

Рис. 1. Надежность по ГОСТ 27.002 – 89

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

В [3] надежность программного обеспечения предлагается характеризовать с помощью следующих характеристик (рис. 2): стабильность, устойчивость и восстанавливаемость.

Рис. 2. Надежность программного обеспечения

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

Для оценки стабильности программного обеспечения возможно использование показателей характеризующих безотказность технических устройств [2] (рис. 3).

Рис. 3. Показатели безотказности

В большинстве случаев поток программных ошибок может быть описан негомогенным процессом Пуассона [4]. Это означает, что программные ошибки происходят в статистически независимые моменты времени, наработки подчиняются экспоненциальному распределению, а интенсивность проявления ошибок изменяется во времени. Обычно используют убывающую интенсивность проявления ошибок. Это означает, что ошибки, как только они выявлены, эффективно устраняются без введения новых ошибок. Главная цель анализа надежности программного обеспечения заключается в том, чтобы определить форму функции интенсивности проявления ошибок и оценить ее параметры по наблюдаемым данным. Как только функция интенсивности проявления ошибок определена, могут быть найдены такие показатели надежности как:

• общее количество ошибок;
• количество остающихся ошибок;
• время до проявления следующей ошибки;
• вероятность безошибочной работы;
• интенсивность проявления ошибок;
• остаточное время испытаний (до принятия решения);
• максимальное количество ошибок (относительно срока службы).

При этом следует различать понятия ошибка и отказ. Применительно к надежности программного обеспечения ошибка это погрешность или искажение кода программы, неумышленно внесенные в нее в процессе разработки, которые в ходе функционирования этой программы могут вызвать отказ или снижение эффективности функционирования. Под отказом в общем случае понимают событие, заключающееся в нарушении работоспособности объекта [2]. Состояние объекта, при котором значения всех параметров характеризующих способность выполнять заданные функции, соответствуют требованиям нормативно – технической и (или) конструкторской (проектной) документации – называется работоспособным. При этом критерии отказов, как признаки или совокупность признаков нарушения работоспособного состояния программного обеспечения, должны определяться исходя из его предназначения в нормативно – технической и (или) конструкторской (проектной) документации.

В общем случае отказ программного обеспечения можно определить как:

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

При этом исходя из [2], все отказы в программном обеспечении следует трактовать как сбои (самоустраняющиеся отказы или однократные отказы, устраняемые незначительным вмешательством оператора), поскольку восстановление работоспособного состояния программного обеспечения может произойти без вмешательства оператора (перезагрузка ЭВМ не требуется), либо при участии оператора или эксплуатирующего персонала (перезагрузка ЭВМ необходима).

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

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

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

В [5] стабильность предлагается оценивать вероятностью безотказной работы, которая оценивается исходя из модели относительной частоты, при этом применение ее ограничено периодом эксплуатации программного обеспечения, что не всегда приемлемо, поскольку надежность объекта, как правило, необходимо оценивать не только в процессе его эксплуатации, но и до начала эксплуатации этого объекта. Ограничение модели относительной частоты вызвано тем, что в этой модели не учитываются процессы тестирования и отладки, а конкретно то, что при возникновении отказа программного обеспечения, ошибка, вызвавшая этот отказ, исправляется.

Наиболее приемлемыми показателями характеризующими стабильность (безотказность) программного обеспечения представляются показатели сходные с показателями безотказности технических систем: вероятность безотказной работы, интенсивность отказов, и среднее время наработки на отказ. Эти показатели взаимосвязаны и, зная один из них, можно определить другие [2]. При определении этих показателей в большинстве случаев можно исходить из модели надежности, предполагающей, что интенсивность проявления ошибок убывает по мере исправления этих ошибок, время между проявлениями ошибок распределено экспоненциально, а интенсивность проявления ошибок постоянна между двумя соседними проявлениями ошибок. Применение такой модели надежности программного обеспечения позволит оценить надежность программного обеспечения во время тестирования и отладки.

Устойчивость, как свойство или совокупность свойств программного обеспечения, характеризующие его возможность поддерживать приемлемый уровень функционирования при проявлениях ошибок в нем, можно оценивать условной вероятностью безотказной работы при проявлении ошибки. Согласно [5] устойчивость оценивается с помощью трех метрик, включающих двадцать оценочных элементов (рис. 4). Результаты оценки каждой метрики определяются результатами оценки определяющих ее оценочных элементов, а результат оценки устойчивости определяются результатами соответствующих ему метрик. Программное обеспечение по каждому из оценочных элементов оценивается группой экспертов – специалистов, компетентных в решении данной задачи, на базе их опыта и интуиции. Для оценочных элементов принимается единая шкала оценки от 0 до 1.

Недостатком такого подхода является одинаковая оценка устойчивости для всех возможных ошибок. Поскольку вероятность возникновения отказа при проявлении разных ошибок может быть разной, возникает необходимость разделения ошибок на несколько категорий. Признаком, по которому в этом случае можно относить ошибки к той или иной категории, можно считать тяжесть ошибки. Под тяжестью ошибки в этом случае следует понимать количественную или качественную оценку вероятного ущерба при проявлении этой ошибки [6], а если говорить о надежности, то оценку вероятности возникновения отказа при проявлении ошибки. При этом категорией тяжести последствий ошибки будет являться классификационная группа ошибок по тяжести их последствий, характеризуемая определенным сочетанием качественных и/или количественных учитываемых составляющих ожидаемого (вероятного) отказа или нанесенного отказом ущерба.

Рис. 4. Метрики и оценочные элементы устойчивости программного обеспечения по ГОСТ 28195 – 89

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

Таблица 1. Категории тяжести ошибки в программном обеспечении, нарушение работоспособности которого могут привести к катастрофическим последствиям

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

Таблица 2. Категории тяжести ошибки в программном обеспечении, нарушение работоспособности которого не приводят к катастрофическим последствиям

Оценку степени тяжести ошибки как условной вероятности возникновения отказа (последствий этого отказа), можно производить согласно [5], используя метрики и оценочные элементы, характеризующие устойчивость программного обеспечения. При этом оценка производится для каждой ошибки в отдельности, а не для всего программного обеспечения. Далее исходя из проведенных оценок возможно определение устойчивости программного обеспечения к проявлениям ошибок каждой из категорий.

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

Показатели надежности программного обеспечения в значительной степени адекватны аналогичным характеристикам, принятых для других технических систем. Наиболее широко используется показатель наработки на отказ. Наработка на отказ – это отношение суммарной наработки объекта к математическому ожиданию числа его отказов в течении этой наработки. Для программного обеспечения использование данного показателя затруднено, в силу особенностей тестирования и отладки программного обеспечения (ошибка вызвавшая отказ, как правило, исправляется и больше не повторяется). Поэтому целесообразно использовать показатель средней наработки до отказа – математического ожидания времени функционирования программного обеспечения до отказа. При использовании модели надежности программного обеспечения предполагающей экспоненциальное распределение времени между отказами, среднее время наработки до отказа равно величине обратной интенсивности отказов. Интенсивность отказов можно оценить исходя из оценок стабильности и устойчивости программного обеспечения. Обобщение характеристик отказов и восстановлений производится в показателе коэффициент готовности [2]. Коэффициент готовности программного обеспечения это вероятность того, что программное обеспечение окажется в работоспособном состоянии в произвольный момент времени. Значение коэффициента готовности соответствует доле времени полезной работы программного обеспечения на достаточно большом интервале времени, содержащем отказы и восстановления.

Источники ошибок программного обеспечения

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

Основными причинами ошибок программного обеспечения являются:

• Большая сложность программного обеспечения, например, по сравнению с аппаратурой ЭВМ.
• Неправильный перевод информации из одного представления в другое на макро и микро уровнях. На макро уровне, уровне проекта, осуществляется передача и преобразование различных видов информации между организациями, подразделениями и конкретными исполнителями на всех этапах жизненного цикла ПО. На микро уровне, уровне исполнителя, производится преобразование информации по схеме: получить информацию, запомнить, выбрать из памяти, воспроизвести информацию.

Источниками ошибок программного обеспечения являются:

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

Внешние: ошибки пользователей, сбои и отказы аппаратуры ЭВМ, искажение информации в каналах связи, изменения конфигурации системы.

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

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

Ошибки, скрытые в самой программе: ошибка вычислений, ошибка ввода-вывода, логические ошибки, ошибка манипулирования данными, ошибка совместимости, ошибка сопряжения.

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

Неверные действия пользователя:

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

Неисправности аппаратуры установки: приводят к нарушениям нормального хода вычислительного процесса; приводят к искажениям данных и текстов программ в основной и внешней памяти.

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

Виды ошибок программного обеспечения

Характеристика основных видов ошибок программного обеспечения

Рассмотрим классификацию ошибок по месту их возникновения, которая рассмотрена в книге С. Канера «Тестирование программного обеспечения». Фундаментальные концепции менеджмента бизнес-приложений. Главным критерием программы должно быть ее качество, которое трактуется как отсутствие в ней недостатков, а также сбоев и явных ошибок. Недостатки программы зависят от субъективной оценкой ее качества потенциальным пользователем. При этом авторы скептически относятся к спецификации и утверждают, что даже при ее наличии, выявленные на конечном этапе недостатки говорят о ее низком качестве. При таком подходе преодоление недостатков программы, особенно на заключительном этапе проектирования, может приводить к снижению надежности. Очевидно, что для разработки ответственного и безопасного программного обеспечения (ПО) такой подход не годится, однако проблемы наличия ошибок в спецификациях, субъективного оценивания пользователем качества программы существуют и не могут быть проигнорированы. Должна быть разработана система некоторых ограничений, которая бы учитывала эти факторы при разработке и сертификации такого рода ПО. Для обычных программ все проблемы, связанные с субъективным оцениванием их качества и наличием ошибок, скорее всего неизбежны.

В краткой классификации выделяются следующие ошибки.

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

1. Ошибки пользовательского интерфейса.

Многие из них субъективны, т.к. часто они являются скорее неудобствами, чем «чистыми» логическими ошибками. Однако они могут провоцировать ошибки пользователя программы или же замедлять время его работы до неприемлемой величины. В результате чего мы будем иметь ошибки информационной системы (ИС) в целом. Основным источником таких ошибок является сложный компромисс между функциональностью программы и простотой обучения и работы пользователя с этой программой. Проблему надо начинать решать при проектировании системы на уровне ее декомпозиции на отдельные модули, исходя из того, что вряд ли удастся спроектировать простой и удобный пользовательский интерфейс для модуля, перегруженного различными функциями. Кроме того, необходимо учитывать рекомендации по проектированию пользовательских интерфейсов. На этапе тестирования ПО полезно предусмотреть встроенные средства тестирования, которые бы запоминали последовательности действий пользователя, время совершения отдельных операций, расстояния перемещения курсора мыши. Кроме этого возможно применение гораздо более сложных средств психо-физического тестирования на этапе тестирования интерфейса пользователя, которые позволят оценить скорость реакции пользователя, частоту этих реакций, утомляемость и т.п. Необходимо отметить, что такие ошибки очень критичны с точки зрения коммерческого успеха разрабатываемого ПО, т.к. они будут в первую очередь оцениваться потенциальным заказчиком.

2.Ошибки вычислений.

Выделяют следующие причины возникновения таких ошибок:

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

Выделяются подпункты: устаревшие константы; ошибки вычислений; неверно расставленные скобки; неправильный порядок операторов; неверно работает базовая функция; переполнение и потеря значащих разрядов; ошибки отсечения и округления; путаница с представлением данных; неправильное преобразование данных из одного формата в другой; неверная формула; неправильное приближение.

3.Ошибки управления потоком.

В этот раздел относится все то, что связано с последовательностью и обстоятельствами выполнения операторов программы.

Выделяются подпункты:

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

4.Ошибки обработки или интерпретации данных.

Выделяются подпункты:

• проблемы при передаче данных между подпрограммами (сюда включены несколько видов ошибок: параметры указаны не в том порядке или пропущены, несоответствие типов данных, псевдонимы и различная интерпретация содержимого одной и той же области памяти, неправильная интерпретация данных, неадекватная информация об ошибке, перед аварийным выходом из подпрограммы не восстановлено правильное состояние данных, устаревшие копии данных, связанные переменные не синхронизированы, локальная установка глобальных данных (имеется в виду путаница локальных и глобальных переменных), глобальное использование локальных переменных, неверная маска битового поля, неверное значение из таблицы);
• границы расположения данных (сюда включены несколько видов ошибок: не обозначен конец нуль-терминированной строки, неожиданный конец строки, запись/чтение за границами структуры данных или ее элемента, чтение за пределами буфера сообщения, чтение за пределами буфера сообщения, дополнение переменных до полного слова, переполнение и выход за нижнюю границу стека данных, затирание кода или данных другого процесса);
• проблемы с обменом сообщений (сюда включены несколько видов ошибок: отправка сообщения не тому процессу или не в тот порт, ошибка распознавания полученного сообщения, недостающие или несинхронизированные сообщения, сообщение передано только N процессам из N+1, порча данных, хранящихся на внешнем устройстве, потеря изменений, не сохранены введенные данные, объем данных слишком велик для процесса-получателя, неудачная попытка отмены записи данных).

5.Повышенные нагрузки.

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

7.Ошибки тестирования.

Являются ошибками сотрудников группы тестирования, а не программы. Выделяются подпункты:

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

8.Ошибка выявлена и забыта.

Описываются ошибки использования результатов тестирования. По-моему, раздел следует объединить с предыдущим. Выделяются подпункты: не составлен итоговый отчет; серьезная проблема не документирована повторно; не проверено исправление; перед выпуском продукта не проанализирован список нерешенных проблем.

Необходимо заметить, что изложенные в 2-х последних разделах ошибки тестирования требуют для устранения средств автоматизации тестирования и составления отчетов. В идеальном случае, эти средства должны быть проинтегрированы со средствами и технологиями проектирования ПО. Они должны стать важными инструментальными средствами создания высококачественного ПО. При разработке средств автоматизированного тестирования следует избегать ошибок, которые присущи любому ПО, поэтому нужно потребовать, чтобы такие средства обладали более высокими характеристиками надежности, чем проверяемое с их помощью ПО.

Меры по повышению надежности программного обеспечения

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

В последние годы сформировалась комплексная система управления качеством продукции TQM (Totaly Quality Management), которая концептуально близка к предшествующей более общей системе на основе стандартов ИСО серии 9000. Система ориентирована на удовлетворение требований потребителя, на постоянное улучшение процессов производства или проектирования, на управление процессами со стороны руководства предприятия на основе фактического состояния проекта. Основные достижения TQM состоят в углублении и дифференциации требований потребителей по реализации процессов, их взаимодействию и обеспечению качества продукции. Системный подход поддержан рядом специализированных инструментальных средств, ориентированных на управление производством продукции. Поэтому эта система пока не находит применения в области обеспечения качества жизненного цикла программных средств.

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

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

• модульность и строгую иерархию в структурном построении программ;
• унификацию правил проектирования, структурного построения и взаимодействия компонент ПС;
• унификацию правил организации межмодульного интерфейса;
• поэтапный контроль полноты и качества решения функциональных задач.

Заключение

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

В заключение можно подвести итог:

• В программном обеспечении имеется ошибка, если оно не выполняет того, что пользователю разумно от него ожидать;
• Отказ программного обеспечения — это появление в нем ошибки;
• Надежность программного обеспечения — есть вероятность его работы без отказов в течении определенного периода времени, рассчитанного с учетом стоимости для пользователя каждого отказа.

Из данных определений можно сделать важные выводы:

• Надежность программного обеспечения является не только внутренним свойством программы;
• Надежность программного обеспечения — это функция как самого ПО, так и ожиданий (действий) его пользователей.

Основными причинами ошибок программного обеспечения являются:

• большая сложность ПО, например, по сравнению с аппаратурой ЭВМ;
• неправильный перевод информации из одного представления в другое.

Список использованной литературы

1. ГОСТ 27.002 – 89. Надежность в технике. Основные понятия. Термины и определения. // М.: Издательство стандартов, 1990.
2. ГОСТ Р ИСО/МЭК 9126 – 93. Информационная технология. Оценка программной продукции. Характеристики качества и руководства по их применению. // М.: Издательство стандартов, 1994.
3. ГОСТ 51901.5 – 2005. Менеджмент риска. Руководство по применению методов анализа надежности. // М.: Издательство стандартов, 2007.
4. ГОСТ 28195 – 89. Оценка качества программных средств. Общие положения. // М.: Издательство стандартов, 1989.
5. ГОСТ 27.310 – 95. Надежность в технике. Анализ видов, последствий и критичности отказов. // М.: Издательство стандартов, 1995.
6. ГОСТ 51901.12 – 2007. Менеджмент риска. Метод анализа видов и последствий отказов. // М.: Издательство стандартов, 2007.
7. Братчиков И.Л. «Синтаксис языков программирования» Наука, М.:Инси, 2005. — 344 с.
8. Дейкстра Э. Заметки по структурному программированию.- М.:Дрофа, 2006, — 455 с.
9. Ершов А.П. Введение в теоретическое программирование.- М.:РОСТО, 2008, — 288 с.
10. Кнут Д. Искусство программирования для ЭВМ, т.1. М.: 2006, 735 с.
11. Коган Д.И., Бабкина Т.С. «Основы теории конечных автоматов и регулярных языков. Учебное пособие» Издательство ННГУ, 2002. — 97 с.
12. Липаев В. В. / Программная инженерия. Методологические основы. // М.: ТЕИС, 2006.
13. Майерс Г. Надежность программного обеспечения.- М.:Дрофа, 2008, — 360 с.
14. Рудаков А. В. Технология разработки программных продуктов. М.:Издательский центр «Академия», 2006. — 306 с.
15. Тыугу, Э.Х. Концептуальное программирование. — М.: Наука, 2001, — 256 с.
16. Хьюз Дж., Мичтом Дж. Структурный подход к программированию.-М.:Мир, 2000, — 278 с.

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

Определение

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

Баги обнаруживаются чаще всего в момент отладки или бета-тестирования. Реже – после итогового релиза готовой программы. Вот несколько вариантов багов:

1. Появляется сообщение об ошибке, но приложение продолжает функционировать.
2. ПО вылетает или зависает. Никаких предупреждений или предпосылок этому не было. Процедура осуществляется неожиданно для пользователя. Возможен вариант, при котором контент перезапускается самостоятельно и непредсказуемо.
3. Одно из событий, описанных ранее, сопровождается отправкой отчетов разработчикам.

Ошибки в программах могут привести соответствующее приложение в негодность, а также к непредсказуемым алгоритмам функционирования. Желательно обнаруживать баги на этапе ранней разработки или тестирования. Лишь в этом случае программист сможет оперативно и относительно недорого внести необходимые изменения в код для отладки ПО.

История происхождения термина

Баг – слово, которое используется разработчиками в качестве сленга. Оно произошло от слова «bug» – «жук». Точно неизвестно, откуда в программировании и IT возник соответствующий термин. Существуют две теории:

1. 9 сентября 1945 года ученые из Гарварда тестировали очередную вычислительную машину. Она называлась Mark II Aiken Relay Calculator. Устройство начало работать с ошибками. Когда его разобрали, то ученые заметили мотылька, застрявшего между реле. Тогда некая Грейс Хоппер назвала произошедший сбой упомянутым термином.
2. Слово «баг» появилось задолго до появления Mark II. Термин использовался Томасом Эдисоном и указывал на мелкие недочеты и трудности. Во время Второй Мировой войны «bugs» называли проблемы с радарной электроникой.

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

Как классифицируют

Ошибки работы программ разделяются по разным факторам. Классификация у рядовых пользователей и разработчиков различается. То, что для первых – «просто программа вылетела» или «глючит», для вторых – огромная головная боль. Но существует и общепринятая классификация ошибок. Пример – по критичности:

1. Серьезные неполадки. Это нарушения работоспособности приложения, которые могут приводить к непредвиденным крупным изменениям.
2. Незначительные ошибки в программах. Чаще всего не оказывают серьезного воздействия на функциональность ПО.
3. Showstopper. Критические проблемы в приложении или аппаратном обеспечении. Приводят к выходу программы из строя почти всегда. Для примера можно взять любое клиент-серверное приложение, в котором не получается авторизоваться через логин и пароль.

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

Также существуют различные виды сбоев в плане частоты проявления: постоянные и «разовые». Вторые встречаются редко, чаще – при определенных настройках и действиях со стороны пользователя. Первые появляются независимо от используемой платформы и выполненных клиентом манипуляций.

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

Виды

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

Разработчики выделяют следующие типы ошибок по уровню сложности:

1. «Борбаг» – «стабильная» неполадка. Она легко обнаруживается на этапе разработки и компилирования. Иногда – во время тестирования наработкой исходной программы.
2. «Гейзенбаг» – баги с поддержкой изменения свойств, включая зависимость от среды, в которой было запущено приложение. Сюда относят периодические неполадки в программах. Они могут исчезать на некоторое время, но через какой-то промежуток вновь дают о себе знать.
3. «Мандельбаг» – непредвиденные ошибки. Обладают энтропийным поведением. Предсказать, к чему они приведут, практически невозможно.
4. «Шрединбаг» – критические неполадки. Приводят к тому, что злоумышленники могут взломать программу. Данный тип ошибок обнаружить достаточно трудно, потому что они никак себя не проявляют.

Также есть классификация «по критичности». Тут всего два варианта – warning («варнинги») и критические весомые сбои. Первые сопровождаются характерными сообщениями и отчетами для разработчиков. Они не представляют серьезной опасности для работоспособности приложения. При компилировании такие сбои легко исправляются. В отдельных случаях компилятор справляется с этой задачей самостоятельно. А вот критические весомые сбои говорят сами за себя. Они приводят к серьезным нарушениям ПО. Исправляются обычно путем проработки логики и значительных изменений программного кода.

Типы багов

Ошибки в программах бывают:

• логическими;
• синтаксическими;
• взаимодействия;
• компиляционные;
• ресурсные;
• арифметические;
• среды выполнения.

Это – основная классификация сбоев в приложениях и операционных системах. Логические, синтаксические и «среды выполнения» встречаются в разработке чаще остальных. На них будет сделан основной акцент.

Ошибки синтаксиса

Синтаксические баги распространены среди новичков. Они относятся к категории «самых безобидных». С данной категорией ошибок способны справиться компиляторы тех или иных языков. Соответствующие инструменты показывают, где допущена неточность. Остается лишь понять, как исправить ее.

Синтаксические ошибки – ошибки синтаксиса, правил языка. Вот пример в Паскале:

Код написан неверно. Согласно действующим синтаксическим нормам, в Pascal в первой строчке нужно в конце поставить точку с запятой.

Логические

Тут стоит выделить обычные и арифметические типы. Вторые возникают, когда программе при работе необходимо вычислить много переменных, но на каком-то этапе расчетов возникают неполадки или нечто непредвиденное. Пример – получение в результатах «бесконечности».

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

Выше – пример логической ошибки в программе. Тут:

1. Происходит сравнение значения i с 15.
2. На экран выводится сообщение, если I = 15.
3. В заданном цикле i не будет равно 15. Связано это с диапазоном значений – от 1 до 10.

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

Время выполнения

Run-time сбои – это ошибка времени выполнения программы. Встречается даже когда исходный код лишен логических и синтаксических ошибок. Связаны такие неполадки с ходом выполнения программного продукта. Пример – в процессе функционирования ПО был удален файл, считываемый программой. Если игнорировать подобные неполадки, можно столкнуться с аварийным завершением работы контента.

Самый распространенный пример в данной категории – это неожиданное деление на ноль. Предложенный фрагмент кода с точки зрения синтаксиса и логики написан грамотно. Но, если клиент наберет 0, произойдет сбой системы.

Компиляционный тип

Встречается при разработке на языках высокого уровня. Во время преобразований в машинный тип «что-то идет не так». Причиной служат синтаксические ошибки или сбои непосредственно в компиляторе.

Наличие подобных неполадок делает бета-тестирование невозможным. Компиляционные ошибки устраняются при разработке-отладке.

Ресурсные

Ресурсный тип ошибок – это сбои вроде «переполнение буфера» или «нехватка памяти». Тесно связаны с «железом» устройства. Могут быть вызваны действиями пользователя. Пример – запуск «свежих» игр на стареньких компьютерах.

Исправить ситуацию помогают основательные работы над исходным кодом. А именно – полное переписывание программы или «проблемного» фрагмента.

Взаимодействие

Подразумевается взаимодействие с аппаратным или программным окружением. Пример – ошибка при использовании веб-протоколов. Это приведет к тому, что облачный сервис не будет нормально функционировать. При постоянном возникновении соответствующей неполадки остается один путь – полностью переписывать «проблемный» участок кода, ответственный за соответствующий баг.

Исключения и как избежать багов

Исключение – событие, при возникновении которых начинается «неправильное» поведение программы. Механизм, необходимый для стабилизации обработки неполадок независимо от типа ПО, платформ и иных условий. Помогают разрабатывать единые концепции ответа на баги со стороны операционной системы или контента.

Исключения бывают:

1. Программными. Они генерируются приложением или ОС.
2. Аппаратными. Создаются процессором. Пример – обращение к невыделенной памяти.

Исключения нужны для охвата критических багов. Избежать неполадок помогут отладчики на этапе разработки. А еще – своевременное поэтапное тестирование программы.

P. S. Большой выбор курсов по тестированию есть и в Otus. Присутствуют варианты как для продвинутых, так и для начинающих пользователей.