Привет! Буду краток: одна из частей моей магистрской работы состоит в том, чтобы путём опроса людей, занимающихся непосредственно программированием (то есть кодингом) на одном из более-менее процедуральных языков (скажем, на C/C++, Pascal/ObjectPascal или Java), выяснить, какого типа ошибки чаще всего ими допускаются. Понятное дело, вряд ли кто-то ведёт точную статистику, но вот просто попробуйте с ходу определить, к какой категории принадлежат ваши собственные любимые ошибки. Итак, список категорий:

1) Некорректные операции с указателями и ошибки выделения/освобождения памяти.
2) Некорректные операции с массивами (выход за границы оного, например).
3) Неверные условия выхода из цикла (приводящие к зацикливанию, но не обязательно только к нему).
4) Некорректная организация синхронизации (deadlocks, livelocks и нарушения доступа как результат).
5) Передача неверных параметров (НЕ своим функциям, а куда-то в другие компоненты системы; пример — вызов WinAPI).
6) Отсутствие начальной инициализации переменных/памяти.
7) Неверная реализация специфичного алгоритма (фактически, всё, что не подпадает под категории с 1-й по 6-ю).

Всем, кто не поленится принять участие в этом опросе, выносится моя глубокая благодарность Спасибо!

Здравствуйте eXXXplosivo, Вы писали:

XXX>1) Некорректные операции с указателями и ошибки выделения/освобождения памяти.
XXX>2) Некорректные операции с массивами (выход за границы оного, например).
XXX>3) Неверные условия выхода из цикла (приводящие к зацикливанию, но не обязательно только к нему).
XXX>4) Некорректная организация синхронизации (deadlocks, livelocks и нарушения доступа как результат).
XXX>5) Передача неверных параметров (НЕ своим функциям, а куда-то в другие компоненты системы; пример — вызов WinAPI).
XXX>6) Отсутствие начальной инициализации переменных/памяти.
XXX>7) Неверная реализация специфичного алгоритма (фактически, всё, что не подпадает под категории с 1-й по 6-ю).

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

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

Поэтому приведу статистику только для ошибок из второй категории:
1. 25%
2. 10%
3. ~0%
4. 35%
5. ~0%
6. ~0%
7. 30%

Здравствуйте eXXXplosivo, Вы писали:


XXX>1) Некорректные операции с указателями и ошибки выделения/освобождения памяти.
XXX>2) Некорректные операции с массивами (выход за границы оного, например).
XXX>3) Неверные условия выхода из цикла (приводящие к зацикливанию, но не обязательно только к нему).
XXX>4) Некорректная организация синхронизации (deadlocks, livelocks и нарушения доступа как результат).
XXX>5) Передача неверных параметров (НЕ своим функциям, а куда-то в другие компоненты системы; пример — вызов WinAPI).
XXX>6) Отсутствие начальной инициализации переменных/памяти.
XXX>7) Неверная реализация специфичного алгоритма (фактически, всё, что не подпадает под категории с 1-й по 6-ю).

(1) редко (5%). Использую обертки указателей.
(2) близко к 0
(3) редко (5%) — я бы это отнес к пункту (7)
(4) непредсказуемо (5-10%). Обычно черновик программы делаю без синхроблоков, а потом расставляю повсюду
(5) умеренно (10-15%). Недавно любимый ляп был — memset(&var, sizeof(var), 0). Теперь — только благодаря недокументированным переопределениям функций API — отступление от POSIX
(6) часто (50%)
(7) все что осталось

Большое спасибо DarkGray и Кодт, уже ответившим на мой вопрос! Однако, хотелось бы ещё мнений по этому поводу... Буду очень благодарен тем, кто даже просто в качестве ответа укажет одну цифру от 1 до 7, тем самым отметив наиболее обычную для себя категорию ошибок...

Разумеется, такие подробные ответы как у DarkGray и Кодт приветствуются вдвойне! ;)

Здравствуйте eXXXplosivo, Вы писали:

Не знаю будетли это полезно или интересно но в написанной нами
программе еще под DOS на 8 ой год ее эксплуатации, а программа бухучета,
в библиотеке обработки запросов к Б/Д обнаружилось, что не
учтено пору вариантов развития событий. А мы удивлялись
почему так часто (относительно часто) рушатся индексы.

Здравствуйте Аноним, Вы писали:

А>Здравствуйте eXXXplosivo, Вы писали:

А>Не знаю будетли это полезно или интересно но в написанной нами
А>программе еще под DOS на 8 ой год ее эксплуатации, а программа бухучета,
А>в библиотеке обработки запросов к Б/Д обнаружилось, что не
А>учтено пору вариантов развития событий. А мы удивлялись
А>почему так часто (относительно часто) рушатся индексы.

Похоже на классический случай из 7-й категории...

Здравствуйте eXXXplosivo, Вы писали:

XXX>Привет! Буду краток: одна из частей моей магистрской работы состоит в том, чтобы путём опроса людей, занимающихся непосредственно программированием (то есть кодингом) на одном из более-менее процедуральных языков (скажем, на C/C++, Pascal/ObjectPascal или Java), выяснить, какого типа ошибки чаще всего ими допускаются. Понятное дело, вряд ли кто-то ведёт точную статистику, но вот просто попробуйте с ходу определить, к какой категории принадлежат ваши собственные любимые ошибки. Итак, список категорий:

XXX>1) Некорректные операции с указателями и ошибки выделения/освобождения памяти.
XXX>2) Некорректные операции с массивами (выход за границы оного, например).
XXX>3) Неверные условия выхода из цикла (приводящие к зацикливанию, но не обязательно только к нему).
XXX>4) Некорректная организация синхронизации (deadlocks, livelocks и нарушения доступа как результат).
XXX>5) Передача неверных параметров (НЕ своим функциям, а куда-то в другие компоненты системы; пример — вызов WinAPI).
XXX>6) Отсутствие начальной инициализации переменных/памяти.
XXX>7) Неверная реализация специфичного алгоритма (фактически, всё, что не подпадает под категории с 1-й по 6-ю).

На мой взгляд, самая частая ошибка для более-менее опытных программистов — неполное определение (в смысле definition) состояния объекта, либо неполное определения графа переходов из состояния в состояние. Спасает от этого, IMHO, только переход к автоматной модели программирования, что весьма геморройно
То есть, опять попадаем в седьмой пункт Хотя я бы этот случай в отдельную категорию выделил.

Здравствуйте eXXXplosivo, Вы писали:

XXX>Привет! Буду краток: одна из частей моей магистрской работы состоит в том, чтобы путём опроса людей, занимающихся непосредственно программированием (то есть кодингом) на одном из более-менее процедуральных языков (скажем, на C/C++, Pascal/ObjectPascal или Java), выяснить, какого типа ошибки чаще всего ими допускаются. Понятное дело, вряд ли кто-то ведёт точную статистику, но вот просто попробуйте с ходу определить, к какой категории принадлежат ваши собственные любимые ошибки. Итак, список категорий:

XXX>1) Некорректные операции с указателями и ошибки выделения/освобождения памяти.
XXX>2) Некорректные операции с массивами (выход за границы оного, например).
XXX>3) Неверные условия выхода из цикла (приводящие к зацикливанию, но не обязательно только к нему).
XXX>4) Некорректная организация синхронизации (deadlocks, livelocks и нарушения доступа как результат).
XXX>5) Передача неверных параметров (НЕ своим функциям, а куда-то в другие компоненты системы; пример — вызов WinAPI).
XXX>6) Отсутствие начальной инициализации переменных/памяти.
XXX>7) Неверная реализация специфичного алгоритма (фактически, всё, что не подпадает под категории с 1-й по 6-ю).

XXX>Всем, кто не поленится принять участие в этом опросе, выносится моя глубокая благодарность Спасибо!

У меня обычно так бывает:
1) 5%
2) ~0%
3) ~0%
4) 10%
5) 20-30%
6) ~0%
7) 65-75%

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

Здравствуйте eXXXplosivo, Вы писали:

XXX>Привет! Буду краток: одна из частей моей магистрской работы состоит в том, чтобы путём опроса людей, занимающихся непосредственно программированием (то есть кодингом) на одном из более-менее процедуральных языков (скажем, на C/C++, Pascal/ObjectPascal или Java), выяснить, какого типа ошибки чаще всего ими допускаются. Понятное дело, вряд ли кто-то ведёт точную статистику, но вот просто попробуйте с ходу определить, к какой категории принадлежат ваши собственные любимые ошибки. Итак, список категорий:

XXX>1) Некорректные операции с указателями и ошибки выделения/освобождения памяти.
XXX>2) Некорректные операции с массивами (выход за границы оного, например).
XXX>3) Неверные условия выхода из цикла (приводящие к зацикливанию, но не обязательно только к нему).
XXX>4) Некорректная организация синхронизации (deadlocks, livelocks и нарушения доступа как результат).
XXX>5) Передача неверных параметров (НЕ своим функциям, а куда-то в другие компоненты системы; пример — вызов WinAPI).
XXX>6) Отсутствие начальной инициализации переменных/памяти.
XXX>7) Неверная реализация специфичного алгоритма (фактически, всё, что не подпадает под категории с 1-й по 6-ю).

XXX>Всем, кто не поленится принять участие в этом опросе, выносится моя глубокая благодарность Спасибо!

1) ~5-10%
2) ~5%
3) ~0%
4) ~5% — но это в связи с тем, что я довольно редко это использую
5) 0%
6) 30% — но в последнее время с некоторой маниакальностью инициализирую в конструкторах и т.п. все и вся, после достаточно продолжительной отладки маааленького кусочка кода.
7) ну, здесь все остальное

Здравствуйте eXXXplosivo, Вы писали:

XXX>Итак, список категорий:

В принципе, к какой категории относить ошибки не так важно, тем более, что здесь нет самой опасной и печальной категории — лигические ошибки.

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

Здравствуйте eXXXplosivo, Вы писали:

XXX>Привет! Буду краток: одна из частей моей магистрской работы состоит в том, чтобы путём опроса людей, занимающихся непосредственно программированием (то есть кодингом) на одном из более-менее процедуральных языков (скажем, на C/C++, Pascal/ObjectPascal или Java), выяснить, какого типа ошибки чаще всего ими допускаются. Понятное дело, вряд ли кто-то ведёт точную статистику, но вот просто попробуйте с ходу определить, к какой категории принадлежат ваши собственные любимые ошибки. Итак, список категорий:

XXX>1) Некорректные операции с указателями и ошибки выделения/освобождения памяти.
XXX>2) Некорректные операции с массивами (выход за границы оного, например).
XXX>3) Неверные условия выхода из цикла (приводящие к зацикливанию, но не обязательно только к нему).
XXX>4) Некорректная организация синхронизации (deadlocks, livelocks и нарушения доступа как результат).
XXX>5) Передача неверных параметров (НЕ своим функциям, а куда-то в другие компоненты системы; пример — вызов WinAPI).
XXX>6) Отсутствие начальной инициализации переменных/памяти.
XXX>7) Неверная реализация специфичного алгоритма (фактически, всё, что не подпадает под категории с 1-й по 6-ю).

XXX>Всем, кто не поленится принять участие в этом опросе, выносится моя глубокая благодарность Спасибо!

1) редко 2.5%
2) очень редко 0.1%
3) бывает 7%
4) 5%
5) 0
6) с некоторого времени 0
7) 2.5%

Здравствуйте eXXXplosivo, Вы писали:

XXX>1) Некорректные операции с указателями и ошибки выделения/освобождения памяти.
XXX>2) Некорректные операции с массивами (выход за границы оного, например).
XXX>3) Неверные условия выхода из цикла (приводящие к зацикливанию, но не обязательно только к нему).
XXX>4) Некорректная организация синхронизации (deadlocks, livelocks и нарушения доступа как результат).
XXX>5) Передача неверных параметров (НЕ своим функциям, а куда-то в другие компоненты системы; пример — вызов WinAPI).
XXX>6) Отсутствие начальной инициализации переменных/памяти.
XXX>7) Неверная реализация специфичного алгоритма (фактически, всё, что не подпадает под категории с 1-й по 6-ю).

1) <5% (в большинстве случаев выявляются сразу же)
2) ~0% (массивы практически не использую, а где использую почему-то всегда попадаю)
3) ~5-10%
4) ~0% (я это перед тем как писать рисую, а потом постоянно сверяюсь)
5) 5-10%
6) 10-15%
7) соответвенно все остальное

Кстати, к некорректным операциям с памятью можно добавить еще и некорректные операции с объектами ОС, приводящие к их утечке.

Здравствуйте ioni, Вы писали:

I>1) редко 2.5%
I>2) очень редко 0.1%
I>3) бывает 7%
I>4) 5%
I>5) 0
I>6) с некоторого времени 0
I>7) 2.5%

Итого 17.1%.
Кажется, нужно добавить 8) ошибки счета на пальцах (82.9%)

Все люди делятся на три категории: кто умеет считать, и кто не умеет.

Здравствуйте Кодт, Вы писали:
К>Итого 17.1%.
К>Кажется, нужно добавить 8) ошибки счета на пальцах (82.9%)
К>Все люди делятся на три категории: кто умеет считать, и кто не умеет.

Нет, просто количество найденных ошибок — конечно. Количество же ненайденных — бесконечно по умолчанию.
А он похоже смог их учесть

Здравствуйте The Lex, Вы писали:

TL>4) ~0% (я это перед тем как писать рисую, а потом постоянно сверяюсь)

Хм... Если не секрет, что ты такое магическое рисуешь, что исчезают все ошибки синхронизации? :)

Здравствуйте eXXXplosivo, Вы писали:

XXX>Здравствуйте The Lex, Вы писали:

TL>>4) ~0% (я это перед тем как писать рисую, а потом постоянно сверяюсь)

XXX>Хм... Если не секрет, что ты такое магическое рисуешь, что исчезают все ошибки синхронизации?

Схемы рисую. Что с чем, как и посредством чего синхронизируется. Ну ладно-ладно, может с ~0% я несколько и загнул. Пусть будет <5%.

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

Здравствуйте eXXXplosivo, Вы писали:

XXX>Привет! Буду краток: одна из частей моей магистрской работы состоит в том, чтобы путём опроса людей, занимающихся непосредственно программированием (то есть кодингом) на одном из более-менее процедуральных языков (скажем, на C/C++, Pascal/ObjectPascal или Java), выяснить, какого типа ошибки чаще всего ими допускаются. Понятное дело, вряд ли кто-то ведёт точную статистику, но вот просто попробуйте с ходу определить, к какой категории принадлежат ваши собственные любимые ошибки. Итак, список категорий:

XXX>1) Некорректные операции с указателями и ошибки выделения/освобождения памяти.
XXX>2) Некорректные операции с массивами (выход за границы оного, например).
XXX>3) Неверные условия выхода из цикла (приводящие к зацикливанию, но не обязательно только к нему).
XXX>4) Некорректная организация синхронизации (deadlocks, livelocks и нарушения доступа как результат).
XXX>5) Передача неверных параметров (НЕ своим функциям, а куда-то в другие компоненты системы; пример — вызов WinAPI).
XXX>6) Отсутствие начальной инициализации переменных/памяти.
XXX>7) Неверная реализация специфичного алгоритма (фактически, всё, что не подпадает под категории с 1-й по 6-ю).
У меня однозначео рулит #6, особенно в функциях типа sprintf. (помниться убил целый день из-за глупого %d вместо %f Сейчас ими пользуюсь с маниакальной осторожностью.
Остальная "большая половина" — 7. Остальные категории в больштнстве случаев либо быстро ловятся, либо не столь часто встречаютcя (#4).

ЗЫЖ Поскольку в списке "более-менее процедуральных" языков наличествует С++, были некоторые траблы с неявными приведениями, не знаю к какой категории отнести.

Здравствуйте eXXXplosivo, Вы писали:

По частоте встречаемости:
1. (7) — основная масса, больше половины всех ошибок;
2. (1) — как правило memory leaks
3. (3) — редко, в каких-то сложных, не до конца продуманных алгоритмах;

Остальные, очень редко.

Здравствуйте eXXXplosivo, Вы писали:

Именно кодинг?
Т.е. когда ясно что и как делать. Да? Редкий случай. И малая часть работы.
Обычно по ходу работы что-то изучаешь(постановка задачи, инструменты, средства Ос),
не понимаешь, заблуждаешься, ошибаешься...
зацикливаешься, упираешься, чертыхаешься, пробуешь, догадываешься, прозреваешь и опять ничего не понимаешь.
А в перерывах стараешься аккуратненько кодить...

1) < %5 (Почти никогда не работаю с "голыми" указателями).
2) 0% (тут на автомате с закрытыми глазами)
3) 0% тоже самое, чисто "физический" труд.
4) 20-30% — это да, тут шурупить надо.
5) < 5%, это если есть нормальная дока, а если нет, то ~100%.
6) ~ 5%. бывает
7) 60%.

Удачи в магистерской работе!