Тенденции языков
От: s22  
Дата: 16.05.15 09:22
Оценка:
Смотрю на новые компилируемые языки вижу следующие вещи:

1. Отказ от исключений
2. Отказ от автоматического разрешения ссылок (только подсчет ссылок+-слабые ссылки)
3. Поддержка функцирнальщины.
4. Отказ от классов/объектов => замена на интерфейсы.

Rust,Swift и т д

а вы какие тенденции заметил и почему так?
(упрощается генерация оптимизированного кода, отсутствие остановки мира)
Re: Тенденции языков
От: hardcase Пират http://nemerle.org
Дата: 16.05.15 11:44
Оценка: +1 :))) :))
Здравствуйте, s22, Вы писали:

s22>а вы какие тенденции заметил и почему так?


Ты случаем не Vogue листаешь?

s22>(упрощается генерация оптимизированного кода, отсутствие остановки мира)


Имхо, подсчет ссылок потому что разрабы вменяемый GC не осилили.
Политика по принципиальному отказу от исключений приводит к необходимости протаскивать чего-то похожего на Maybe через весь код (имеется в виду поддержка со стороны языка, а не как в С). Упрощением компилятора и кодогенерации я бы это не назвал.
/* иЗвиНите зА неРовнЫй поЧерК */
Re: Тенденции языков
От: hi_octane Беларусь  
Дата: 16.05.15 13:51
Оценка: 25 (4) +10 :)))
s22>а вы какие тенденции заметил и почему так?

Заметил тенденцию узости мысли — в прошлом веке появлялись всякие принципиально отличающиеся штуки (lisp, prolog, sql, pascal — у каждого своя идея), а сейчас новые языки — как клонированные. Кстати буду рад если ткнут в что-то крутое, что пропустил.

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

Как выше написал hardcase — вначале все обещают GC, обламываются в реализации и делают подсчёт ссылок (который в общем-то убогий GC, и в котором тоже можно словить вполне заметные проблемы там где не ждёшь). С исключениями та же фигня — сейчас все компиляторы хотят уметь хотя-бы x86, x64, Arm. Нормальная реализация исключений — это трудно, вот и лепят коды ошибок. Дурят голову программистам которые уже освоили C++, и позволяют им повторить путь индустрии 70-х прошлого века (вроде тогда первые статьи пошли о пользе исключений) чем поворачивают их назад в C++.

Из маргинальных языков радует редко упоминаемый тут Nim — компилируемый, статически типизированный, есть какой-то GC с некоторыми настройками, есть исключения, есть макросы но (пока?) без квази-цитат и есть шаблоны (квази-цитаты без макросов?), есть целых 3 перегрузки оператора '.', memory regions, декларируется автоматический решатель/доказатель того что программы работают на непересекающихся данных (имхо это грамотнее чем вводить кучу видов указателей), замыкания, yield, возвращаемые значения lvalue (зачем? пока не разобрался...), и куча других интересностей. Но развивается медленно. Часть синтаксиса как будто содрана с Nemerle — не думаю что до квадратных скобок в Generics можно самому додуматься
Re[2]: Тенденции языков
От: s22  
Дата: 16.05.15 14:13
Оценка: :))) :))
Здравствуйте, hardcase, Вы писали:

H>Ты случаем не Vogue листаешь?

Нет.

s22>>(упрощается генерация оптимизированного кода, отсутствие остановки мира)

H>Имхо, подсчет ссылок потому что разрабы вменяемый GC не осилили.
Apple не осилила?
Mozilla?
Где то читал, что "вменяемый GC" на телефоне требует как минимум 0,05 секунды задержки, что Apple признали не приемлемым, так как пользователь будет ощущать дискомфорт.
Далее как быть в случае с многопоточностью с GC? везде бросать локи? Я не спорю, что может быть ты всегда способен переделать алгоритм на минимум локов, но в Мозиле не уверены ии они пошли другм путем... Компилятор направляет на безлоковость кода.

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

Об этом был пост на gcc, зачастую из за исключений и не формулирования точной точки исключения = необходимости хранить стек в случае оптимизации -O3 разница составляет 2 раза!
Вопрос, инлайнет ли Net код, если в коде есть цепочка исключений и в каких версиях да/нет?
Re[2]: Тенденции языков
От: AlexRK  
Дата: 16.05.15 16:17
Оценка: +4
Здравствуйте, hi_octane, Вы писали:

_>Как выше написал hardcase — вначале все обещают GC, обламываются в реализации и делают подсчёт ссылок (который в общем-то убогий GC, и в котором тоже можно словить вполне заметные проблемы там где не ждёшь).


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

_>С исключениями та же фигня — сейчас все компиляторы хотят уметь хотя-бы x86, x64, Arm. Нормальная реализация исключений — это трудно, вот и лепят коды ошибок. Дурят голову программистам которые уже освоили C++, и позволяют им повторить путь индустрии 70-х прошлого века (вроде тогда первые статьи пошли о пользе исключений) чем поворачивают их назад в C++.


Исключения — очень спорная вещь. Разговоры о "пользе" исключений — однобокий взгляд. Минусов у исключений не меньше, чем плюсов.
К счастью, есть люди, которые это понимают, поэтому Rust и Swift именно такие, какие есть.
Re[3]: Тенденции языков
От: hi_octane Беларусь  
Дата: 16.05.15 17:24
Оценка:
ARK>Не обязательно городить подсчет ссылок, можно как в Rust — уникальные указатели и контроль за ними. С точки зрения надежности и скорости — самый лучший вариант.
Ну и в итоге преимуществ перед C++ примерно 0, как следствие повторяем очередную итерацию борьбы с C++. Проверено предыдущими поколениями убивцев C++.

ARK>Исключения — очень спорная вещь. Разговоры о "пользе" исключений — однобокий взгляд. Минусов у исключений не меньше, чем плюсов.

ARK>К счастью, есть люди, которые это понимают, поэтому Rust и Swift именно такие, какие есть.
Как-то упустил минусы исключений. Можешь перечислить или кинуть ссылку где прочитать?
Re[4]: Тенденции языков
От: s22  
Дата: 16.05.15 17:34
Оценка:
Здравствуйте, hi_octane, Вы писали:

ARK>>Не обязательно городить подсчет ссылок, можно как в Rust — уникальные указатели и контроль за ними. С точки зрения надежности и скорости — самый лучший вариант.

_>Ну и в итоге преимуществ перед C++ примерно 0, как следствие повторяем очередную итерацию борьбы с C++. Проверено предыдущими поколениями убивцев C++.

ARK>>Исключения — очень спорная вещь. Разговоры о "пользе" исключений — однобокий взгляд. Минусов у исключений не меньше, чем плюсов.

ARK>>К счастью, есть люди, которые это понимают, поэтому Rust и Swift именно такие, какие есть.
_>Как-то упустил минусы исключений. Можешь перечислить или кинуть ссылку где прочитать?

http://stackoverflow.com/questions/1897940/in-what-ways-do-c-exceptions-slow-down-code-when-there-are-no-exceptions-thown
в инете много про это....
часто компиляторы не инлайнят код, если во вложенной функции есть вызов исключения.
Re[3]: Тенденции языков
От: dsorokin Россия  
Дата: 16.05.15 18:10
Оценка: +2
Здравствуйте, s22, Вы писали:

s22>Далее как быть в случае с многопоточностью с GC? везде бросать локи?


Если язык ссылочно-прозрачный, то все очень хорошо. Ну, вычислят два или три потока одно значение. Разве от этого что-то изменится?! Чистота как никак

А если серьезно, то даже на Java и C# можно с пользой использовать GC. Вспоминаю свой код на Си++ и Asio. Сколько там всяких заморочек, особенно со std::shared_ptr, тогда так даже на эти двух перечисленных выше не самых сложных и далеко не самых мощных языках мейнстрима было бы все много проще.
Re[4]: Тенденции языков
От: AlexRK  
Дата: 16.05.15 18:11
Оценка: 4 (1) -3 :)
Здравствуйте, hi_octane, Вы писали:

ARK>>Не обязательно городить подсчет ссылок, можно как в Rust — уникальные указатели и контроль за ними. С точки зрения надежности и скорости — самый лучший вариант.

_>Ну и в итоге преимуществ перед C++ примерно 0, как следствие повторяем очередную итерацию борьбы с C++. Проверено предыдущими поколениями убивцев C++.

Гарантированная корректность операций с памятью — это "0"? Хм.

Убить С++ мешает не его "крутизна", а то, что в него вложено огромное количество ресурсов. В обозримой перспективе смерть С++ абсолютно исключена и разговоры об убийстве С++, ИМХО, не от большого ума. Что не отменяет того факта, что С++ — это говно мамонта, перегруженное фичами и отягощенное наследственными болезнями.

ARK>>Исключения — очень спорная вещь. Разговоры о "пользе" исключений — однобокий взгляд. Минусов у исключений не меньше, чем плюсов.

ARK>>К счастью, есть люди, которые это понимают, поэтому Rust и Swift именно такие, какие есть.
_>Как-то упустил минусы исключений. Можешь перечислить или кинуть ссылку где прочитать?

Могу. Главный минус: исключения оставляют программу в несогласованном состоянии, с разрушенными инвариантами, и формально проконтролировать этот момент нельзя. Теоретически могло бы помочь STM, но у него свой неустранимый минус — не работает с IO.

А вот почитать:
http://blogs.msdn.com/b/oldnewthing/archive/2005/01/14/352949.aspx
http://yosefk.com/blog/error-codes-vs-exceptions-critical-code-vs-typical-code.html
Re[4]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 16.05.15 19:13
Оценка:
Здравствуйте, hi_octane, Вы писали:

_>Как-то упустил минусы исключений. Можешь перечислить или кинуть ссылку где прочитать?


Это бла-бла-бла про якобы просадку производительности и про завуалированный goto.
Re[5]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 16.05.15 19:16
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Могу. Главный минус: исключения оставляют программу в несогласованном состоянии


А необработанный код ошибки в каком состоянии оставляет программу?

ARK>с разрушенными инвариантами, и формально проконтролировать этот момент нельзя.


А что насчет С++ с раскруткой стека и деструкторами?
Re[6]: Тенденции языков
От: AlexRK  
Дата: 16.05.15 19:22
Оценка: +1 :)))
Здравствуйте, MTD, Вы писали:

ARK>>Могу. Главный минус: исключения оставляют программу в несогласованном состоянии

MTD>А необработанный код ошибки в каком состоянии оставляет программу?

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

ARK>>с разрушенными инвариантами, и формально проконтролировать этот момент нельзя.

MTD>А что насчет С++ с раскруткой стека и деструкторами?

Деструкторы это хорошо, не спорю. Но это, как ни крути, своеобразный костыль над исключениями.
Довольно старая статья Александреску на эту тему: http://www.drdobbs.com/cpp/generic-change-the-way-you-write-excepti/184403758

Solution 3: The Real Approach

"Who said memory's going to exhaust? There's half a gig in this box!"

"Even if memory does exhaust, the paging system will slow the program down to a crawl way before the program crashes."

"The database folks said AddFriend cannot possibly fail. They're using XYZ and TZN!"

"It's not worth the trouble. We'll think of it at a later review."

Re[7]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 16.05.15 19:29
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>В прежнем, очевидно. Правда дальше все равно развалится.


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

ARK>Но в современных ЯП необработанный код пропустить нельзя, компилятор запрещает.


Чмсто для общего развития — в каких? И каким образом? Ну не проверяю я что функия вернула или в "современных" языках по определению функция может вернуть только код ошибки?

ARK>Деструкторы это хорошо, не спорю. Но это, как ни крути, своеобразный костыль над исключениями.


Все костыль, нет ничего идеального, по мне так исключения гораздо лучший костыл, чем коды ошибок.
Re[8]: Тенденции языков
От: AlexRK  
Дата: 16.05.15 19:43
Оценка:
Здравствуйте, MTD, Вы писали:

ARK>>Но в современных ЯП необработанный код пропустить нельзя, компилятор запрещает.

MTD>Чмсто для общего развития — в каких? И каким образом? Ну не проверяю я что функия вернула или в "современных" языках по определению функция может вернуть только код ошибки?

Rust точно, Swift не помню, но тоже, скорее всего.
Вот тут: https://doc.rust-lang.org/std/result/
Компилятор требует обработать возвращаемое значение.

ARK>>Деструкторы это хорошо, не спорю. Но это, как ни крути, своеобразный костыль над исключениями.

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

Я тут выше статью приводил: http://yosefk.com/blog/error-codes-vs-exceptions-critical-code-vs-typical-code.html
С ней в целом согласен — что исключения хороши для "простого" кода, а коды — для требовательного к качеству и скорости.
Re[9]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 16.05.15 19:58
Оценка: +1
Здравствуйте, AlexRK, Вы писали:

ARK>Rust точно


Там просто есть атрибут #[must_use], что таки оставляет простор для ошибок.

ARK>Я тут выше статью приводил: http://yosefk.com/blog/error-codes-vs-exceptions-critical-code-vs-typical-code.html


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

ARK>С ней в целом согласен — что исключения хороши для "простого" кода, а коды — для требовательного к качеству и скорости.


А точно не наоборот?
Re[10]: Тенденции языков
От: AlexRK  
Дата: 16.05.15 20:19
Оценка: +2
Здравствуйте, MTD, Вы писали:

MTD>Там просто есть атрибут #[must_use], что таки оставляет простор для ошибок.


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

ARK>>С ней в целом согласен — что исключения хороши для "простого" кода, а коды — для требовательного к качеству и скорости.

MTD>А точно не наоборот?

Думаю, что нет. Софт на марсоходе писан на языке без исключений. Игры на современных приставках пишутся без исключений. Статические анализаторы, применяющиеся в авиакосмической промышленности (например: http://www.astree.ens.fr/, http://www.spark-2014.org/), не предусматривают использования исключений. Ядра всех этих линупсов и прочих ОС — тоже без исключений.
Re[2]: Тенденции языков
От: btn1  
Дата: 16.05.15 21:39
Оценка: +1 -3
Здравствуйте, hi_octane, Вы писали:

_>Из маргинальных языков радует редко упоминаемый тут Nim


Синтаксис на отступах — такое школоло сразу в топку.
Re[3]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 17.05.15 04:12
Оценка:
Здравствуйте, btn1, Вы писали:

B>Синтаксис на отступах — такое школоло сразу в топку.


Вот мне питоноподобный синтаксис на отступах тоже очень не нравится. Но с другой стороны, в хаскеле и идрисе тоже на отступах, но там ок, нет такого отторжения совсем.
Re[10]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 17.05.15 04:16
Оценка:
Здравствуйте, MTD, Вы писали:

ARK>>С ней в целом согласен — что исключения хороши для "простого" кода, а коды — для требовательного к качеству и скорости.


MTD>А точно не наоборот?


Про качество не скажу, а вот про скорость недавно один из разработчиков интеловского компилятора рассказывал, что если в функции есть какая-то работа с исключениями, то многие оптимизации для нее сразу выключаются.
Re[11]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 17.05.15 06:22
Оценка: +1 -2
Здравствуйте, AlexRK, Вы писали:

ARK>Думаю, что нет. Софт на марсоходе писан на языке без исключений.


На такой софт тратится столько денег, что обычное прикладное ПО никто бы не купил, если бы на его разработку столько же тратили.

ARK>Игры на современных приставках пишутся без исключений. Статические анализаторы, применяющиеся в авиакосмической промышленности (например: http://www.astree.ens.fr/, http://www.spark-2014.org/), не предусматривают использования исключений. Ядра всех этих линупсов и прочих ОС — тоже без исключений.


То что многие проекты были начаты когда поддержка исключений хромала или потому, что главный архитектор фанатик — ничего не доказывает. Достаточно один раз переписать код с кодами возврата на исключения и сравнить результат, чтобы сомнения отпали, как писать проще и безопасней.
Re[11]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 17.05.15 06:24
Оценка: -1
Здравствуйте, D. Mon, Вы писали:

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


Не осилили интеловские разработчики исключения, бывает.
Re[12]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 17.05.15 08:34
Оценка: +1
Здравствуйте, MTD, Вы писали:

MTD>Не осилили интеловские разработчики исключения, бывает.


В других компиляторах не лучше, не обольщайтесь.
Re[13]: Тенденции языков
От: AlexRK  
Дата: 17.05.15 09:37
Оценка: +1
Здравствуйте, D. Mon, Вы писали:

MTD>>Не осилили интеловские разработчики исключения, бывает.

DM>В других компиляторах не лучше, не обольщайтесь.

Скорее всего, гораздо хуже.
Re: Тенденции языков
От: Mystic Украина http://mystic2000.newmail.ru
Дата: 17.05.15 09:46
Оценка:
Здравствуйте, s22, Вы писали:

Основных тенденций две:
Re[3]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.05.15 14:16
Оценка: +1 -1
Здравствуйте, AlexRK, Вы писали:

ARK>Не обязательно городить подсчет ссылок, можно как в Rust — уникальные указатели и контроль за ними. С точки зрения надежности и скорости — самый лучший вариант.


В Расте, как раз, подсчет ссылок. Уникальные указатели можно в любой язык/рантайм встроить. Но это не общий механизм. Все равно нужно иметь возможность раделяемого владения ссылками. И тут есть только три варианта:
1. GC.
2. Подсчет ссылок.
3. Ручное управление памятью.

Мне кажется GC + уникальные указатели лучше чем подсчет ссылок и уникальные указатели.

ARK>Исключения — очень спорная вещь. Разговоры о "пользе" исключений — однобокий взгляд. Минусов у исключений не меньше, чем плюсов.


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

ARK>К счастью, есть люди, которые это понимают, поэтому Rust и Swift именно такие, какие есть.


Осталось только понять не заблуждаются ли эти люди. Вот Гугль в Хроме выбрал GC. И Хром выглядит вполне себе конкурентноспособно. А вот Раст выглядит довольно странно (мягко говоря).
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.05.15 14:21
Оценка: +3 -2
Здравствуйте, s22, Вы писали:

s22>в инете много про это....

s22>часто компиляторы не инлайнят код, если во вложенной функции есть вызов исключения.

Это проблемы не исключений, а С++ и его компиляторов. И не смотря на эти проблемы С++ считается одним из самых "быстрых" языков (т.е. его компиляторы порождают самый быстрый код).

Вряд ли у разработчиков новых языков главным требованием является превзойти С++ по скорости генерируемого кода.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[4]: Тенденции языков
От: AlexRK  
Дата: 17.05.15 14:55
Оценка: +1
Здравствуйте, VladD2, Вы писали:

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


На мой взгляд, разделяемые ссылки нужны редко. И как раз уникальные ссылки в Расте являются главным типом ссылок, а ARC там — сбоку припеку.

ARK>>Исключения — очень спорная вещь. Разговоры о "пользе" исключений — однобокий взгляд. Минусов у исключений не меньше, чем плюсов.

VD>Все минусы упираются в ручное управление памятью. В управляемых средах с исключениями проблем нет. Не надо выдумывать.

Да нет, главные проблемы исключений — совсем не из-за ручного управления памятью. Про них я здесь уже писал.
И в управляемых средах все проблемы исключений тоже присутствуют в полной мере.
Отредактировано 17.05.2015 14:55 AlexRK . Предыдущая версия .
Re[5]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.05.15 15:52
Оценка: -1 :)
Здравствуйте, AlexRK, Вы писали:

ARK>На мой взгляд, разделяемые ссылки нужны редко. И как раз уникальные ссылки в Расте являются главным типом ссылок, а ARC там — сбоку припеку.


Ну, так какие проблемы то тогда? Раз разделяемые ссылки это редкость (хотя я не понимаю как без них делать иерархии объектов вроде HTML DOM), то GC будет идеальным дополнением к ним, так как на малых объемах GC рулит неимоверно. А вот ARC ваш нужен только тем кто GC не осилил.

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

ARK>И в управляемых средах все проблемы исключений тоже присутствуют в полной мере.

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

Мой аргумент очень прост. В С++ проблемы с исключением возникают из-за необходимости раскрутки стека. Почти любой объект в С++ обладает деструктором. При раскрутке стека нужно вызвать деструкторы. 99% объектов с деструктора занимаются освобождением памяти, а не каких-то других ресуросв. В языках с GC такой проблемы нет. Объекты контролируются GC. Банальный сдвиг указателя стека убивает ссылки на них и следовательно виртуально освобождает ссылки на объекты. Конструкции try/finally редки и несложно (без заметного оверхэда) реализуются. Инлайнингу это никак не препятствует.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[6]: Тенденции языков
От: AlexRK  
Дата: 17.05.15 16:48
Оценка: +2
Здравствуйте, VladD2, Вы писали:

VD>Ты много писал, но внятно ничего не сказал. Давай, опиши нам здесь проблемы которые вызывают исключения в языках с GC. Думаю, ты начнешь вилять и не приведешь ни одного аргумента, потому что их нет в природе.


Главное я вроде как сказал: вылет исключения нарушает инварианты программы, ответственность за поддержку которых ложится на программиста. Чего тут непонятного или невнятного — Именно поэтому исключения не используются нигде в mission-critical софте.

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

Really easy:
— Recognizing that error-code-based code is badly-written.
— Recognizing the difference between bad error-code-based code and not-bad error-code-based code.

Hard:
— Recognizing that error-code-base code is not badly-written.

Really hard:
— Recognizing that exception-based code is badly-written.
— Recognizing that exception-based code is not badly-written.
— Recognizing the difference between bad exception-based code and not-bad exception-based code.


По-моему, абсолютно верное наблюдение.


Мои аргументы в основном о качестве и поддерживаемости кода, а вы смотрите только с технической стороны — раз можно написать using, значит все хорошо. Не написал? ССЗБ, вон из профессии, исключения это не проблема! А другим потом говнокод разгребать приходится.
Re[2]: Тенденции языков
От: alex_public  
Дата: 17.05.15 18:12
Оценка:
Здравствуйте, hi_octane, Вы писали:

_>Из маргинальных языков радует редко упоминаемый тут Nim — компилируемый, статически типизированный, есть какой-то GC с некоторыми настройками, есть исключения, есть макросы но (пока?) без квази-цитат и есть шаблоны (квази-цитаты без макросов?), есть целых 3 перегрузки оператора '.', memory regions, декларируется автоматический решатель/доказатель того что программы работают на непересекающихся данных (имхо это грамотнее чем вводить кучу видов указателей), замыкания, yield, возвращаемые значения lvalue (зачем? пока не разобрался...), и куча других интересностей. Но развивается медленно. Часть синтаксиса как будто содрана с Nemerle — не думаю что до квадратных скобок в Generics можно самому додуматься


Кстати, очень интересный язык. Как раз прочёл сегодня статейку про него http://habrahabr.ru/post/258119/. Странно, что на rsnd часто обсуждался D и Rust (как замена C++), и ни разу не упоминался Nim. В то время как он умеет даже компилироваться в C++ код, имея при этом множество синтаксических вкусностей.
Re[3]: Тенденции языков
От: AlexRK  
Дата: 17.05.15 18:30
Оценка: +1
Здравствуйте, alex_public, Вы писали:

_>Кстати, очень интересный язык. Как раз прочёл сегодня статейку про него http://habrahabr.ru/post/258119/. Странно, что на rsnd часто обсуждался D и Rust (как замена C++), и ни разу не упоминался Nim. В то время как он умеет даже компилироваться в C++ код, имея при этом множество синтаксических вкусностей.


Прочел статью. Не увидел в Nim ничего интересного... Ну обсыпали Ц сахаром слегка, не более того. Не вижу ни цельной концепции, ни каких-то новых фич. Да еще эти отступы.
Re[5]: Тенденции языков
От: mrTwister Россия  
Дата: 17.05.15 18:33
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Могу. Главный минус: исключения оставляют программу в несогласованном состоянии, с разрушенными инвариантами, и формально проконтролировать этот момент нельзя. Теоретически могло бы помочь STM, но у него свой неустранимый минус — не работает с IO.


Исключения могут оставить программу в несогласованном состоянии, с разрушенными инвариантам, и формально проконтролировать этот момент нельзя. То же самое относится и ко всем остальным операторам языка.
лэт ми спик фром май харт
Re[11]: Тенденции языков
От: mrTwister Россия  
Дата: 17.05.15 18:37
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Ну, это ошибки другого рода. Грамотно написанное API не позволит _пользователю_ этого API забыть проверку.


В яве тоже пытались заставлять обрабатывать исключения — не взлетело. И с кодами ошибок не взлетит.
лэт ми спик фром май харт
Re[12]: Тенденции языков
От: AlexRK  
Дата: 17.05.15 18:46
Оценка: +1
Здравствуйте, mrTwister, Вы писали:

ARK>>Ну, это ошибки другого рода. Грамотно написанное API не позволит _пользователю_ этого API забыть проверку.

T>В яве тоже пытались заставлять обрабатывать исключения — не взлетело. И с кодами ошибок не взлетит.

Уже давным-давно взлетело. Целые классы приложений не пишутся с применением исключений. Ядра ОС, например.
Re[6]: Тенденции языков
От: AlexRK  
Дата: 17.05.15 18:51
Оценка:
Здравствуйте, mrTwister, Вы писали:

ARK>>Могу. Главный минус: исключения оставляют программу в несогласованном состоянии, с разрушенными инвариантами, и формально проконтролировать этот момент нельзя. Теоретически могло бы помочь STM, но у него свой неустранимый минус — не работает с IO.


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


Бинарное "могут — не могут"? Смешно. Все тьюринг-полные языки одинаково удобны и одинаково надежны?

Исключения позволяют достичь негативного эффекта с гораздо большей вероятностью, чем остальные операторы. Просто потому, что их в коде вообще не видно.
Re[7]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.05.15 21:06
Оценка: 1 (1) +3
Здравствуйте, AlexRK, Вы писали:

ARK>Главное я вроде как сказал: вылет исключения нарушает инварианты программы, ответственность за поддержку которых ложится на программиста.


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

ARK>Чего тут непонятного


Ничего. Ты что-то там ляпнул, а все должны тебе верить на слово? Я пишу на дотнете с его появления, т.е. 13 лет. Никаких таких проблем ни разу не видел.

ARK>Именно поэтому исключения не используются нигде в mission-critical софте.


Вот это ваше "mission-critical" — это что-то не дертерминированное граничащее с понтами. Давай примеры в студию и опиши что в них не так.

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


Куча трепа без единого доказательства? А мне это не интересно. Ты что-то утверждаешь, будь добр обосновать.

ARK>Например:

ARK>Really easy:...
ARK>Hard:...
ARK>Really hard:...
ARK>По-моему, абсолютно верное наблюдение.

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

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

ARK>Мои аргументы в основном о качестве и поддерживаемости кода, а вы смотрите только с технической стороны — раз можно написать using, значит все хорошо. Не написал? ССЗБ, вон из профессии, исключения это не проблема! А другим потом говнокод разгребать приходится.


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

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

Кроме того очень хочется увидеть пример разломанных исключениями инвариантов в управляемом коде.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[3]: Тенденции языков
От: hi_octane Беларусь  
Дата: 17.05.15 22:08
Оценка:
_>Кстати, очень интересный язык. Как раз прочёл сегодня статейку про него http://habrahabr.ru/post/258119/. Странно, что на rsnd часто обсуждался D и Rust (как замена C++), и ни разу не упоминался Nim. В то время как он умеет даже компилироваться в C++ код, имея при этом множество синтаксических вкусностей.

Немерлисты знали про него 4 года назад
Автор: Ziaw
Дата: 07.06.11
, но обсуждать видимо было нечего. Раньше этот язык назывался Nimrod, и редкие посты найти можно.
Re[3]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 18.05.15 04:02
Оценка: +1
Здравствуйте, alex_public, Вы писали:

_>>Nim

_>Кстати, очень интересный язык. Как раз прочёл сегодня статейку про него http://habrahabr.ru/post/258119/. Странно, что на rsnd часто обсуждался D и Rust (как замена C++), и ни разу не упоминался Nim. В то время как он умеет даже компилироваться в C++ код, имея при этом множество синтаксических вкусностей.

От всех, кто пробовал с ним играться, я пока слышал (читал) лишь одно — все очень сырое и половина не работает (еще на уровне компилятора). Потенциально он может и интересный (хотя мне противен чисто синтаксически), но пока неюзабелен.
Re[2]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 18.05.15 04:03
Оценка:
Здравствуйте, hi_octane, Вы писали:

> Часть синтаксиса как будто содрана с Nemerle — не думаю что до квадратных скобок в Generics можно самому додуматься


При живой-то Скале? Ну-ну.
Re[8]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 07:03
Оценка: :)))
Здравствуйте, VladD2, Вы писали:

ARK>>Главное я вроде как сказал: вылет исключения нарушает инварианты программы, ответственность за поддержку которых ложится на программиста.

VD>А тебе ответили, что ты заблуждаешься. Приведи код на Шарпе или Яве доказывающий твое заявление.
VD>Кроме того очень хочется увидеть пример разломанных исключениями инвариантов в управляемом коде.

Ну вот примитивный пример:

  class Test
  {
    private MyItem[] _myArray;

    protected abstract void ProcessInternal(MyItem item);

    public void Process()
    {
      foreach (var item in _myArray)
      {
         ProcessInternal(item);   // throws Exception
      }

      // здесь _myArray оказался в неизвестно каком состоянии
    }


VD>Результаты использования кодов возврата мы можем наблюдать в коде COM-серверов. Практически стандартным явлением в которых является просто никакая обработка ошибок. Люди просто халтурят и получается полная задница. Отладка становится тяжелой. Найти концы очень не просто. В то же время исключения позволяют находить место проблемы элементарно. Включи перехват и получи нужную точку в программе в отладчике.


Обычные коды ошибок действительно обладают этим недостатком. Но возврат в стиле Rust — нет.
Re[9]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 18.05.15 08:13
Оценка: +5 :)))
Здравствуйте, AlexRK, Вы писали:

ARK>Ну вот примитивный пример:


ARK>
ARK>  class Test
ARK>  {
ARK>    private MyItem[] _myArray;

ARK>    protected abstract void ProcessInternal(MyItem item);

ARK>    public int  Process()
ARK>    {
ARK>      foreach (var item in _myArray)
ARK>      {
ARK>         if (ProcessInternal(item) != ERR_OK) return -1;   // error!
ARK>      }

ARK>      // здесь _myArray оказался в неизвестно каком состоянии
ARK>    }
ARK>


Отличный пример
Re[9]: Тенденции языков
От: hi_octane Беларусь  
Дата: 18.05.15 08:18
Оценка: +2
ARK>
ARK>      foreach (var item in _myArray)
ARK>      {
ARK>         ProcessInternal(item);   // throws Exception
ARK>      }
ARK>      // здесь _myArray оказался в неизвестно каком состоянии
ARK>


То есть имеем плохо написанный код и обижаемся на исключения за то что он по волшебству не стал хорошо написанным? Ну ОК, только как проблему решают коды возврата? Учитывая в Rust анти-паттерн появился try!() — как только его освоят джамшуты — в коде ты увидишь !try(ProcessInternal(item)) и поехали наверх с настолько же неизвестным состоянием. Кстати само появление этой конструкции до того как язык даже вышел — уже должно было заставить авторов сесть за круглый стол и начать осознавать то что они идут куда-то не туда.
Re[9]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 18.05.15 08:20
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Обычные коды ошибок действительно обладают этим недостатком. Но возврат в стиле Rust — нет.


Чисто для справки — в Java давным давно пытались заставить насильно обрабатывать исключения, привело это только к автоматически генерируемым заглушкам. Сейчас общее мнение в сообществе, что checked exceptions — зло. Не вижу, почему в Rust будет иначе.
Re[10]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 18.05.15 08:26
Оценка: +5
Здравствуйте, MTD, Вы писали:

ARK>> if (ProcessInternal(item) != ERR_OK) return -1; // error!


Добавлю, что при этом исключение хоть стек трейс хранит и имеет тип, что существенно упрощает поиск проблемы и исправление ошибки, а с кодами ошибки только хардкор, только дебаг!
Re[5]: Тенденции языков
От: hi_octane Беларусь  
Дата: 18.05.15 08:43
Оценка: +2
ARK>Гарантированная корректность операций с памятью — это "0"? Хм.
Тебе в C++ форуме враз объяснят что обложившись смарт-пойнтерами и используя только подмножество C++ можно добиться результата не хуже. Вот это и есть "0".

ARK>Убить С++ мешает не его "крутизна", а то, что в него вложено огромное количество ресурсов. В обозримой перспективе смерть С++ абсолютно исключена и разговоры об убийстве С++, ИМХО, не от большого ума. Что не отменяет того факта, что С++ — это говно мамонта, перегруженное фичами и отягощенное наследственными болезнями.

По слухам в Кобол и особенно в Аду было вложено больше и при этом до наследственных болезней дело не дошло

ARK>Могу. Главный минус: исключения оставляют программу в несогласованном состоянии, с разрушенными инвариантами, и формально проконтролировать этот момент нельзя. Теоретически могло бы помочь STM, но у него свой неустранимый минус — не работает с IO.

Почитал и ничего с эпохи флеймов C vs C++ нового в тех статьях не увидел. Задача "Recognize that code is как-то written" вообще стоит чаще перед фрилансером или аналитиком конторы когда решается вопрос ввязываться в очередной умирающий проект или нет. Ну может ещё перед программистом на коротком этапе "хочу добавить зависимость, но прежде гляну не поимею ли геморроя".

Аргумент что исключения затормаживают компилятор в пролёте из-за того что компилятора способного соревноваться с С++ сейчас на горизонте не видно, а в обещания что "вот потом в будущем он всех уделает и тогда..." я не верю — они всё равно не взлетают, а в это время стандарты C++ и C# принимаются на ура один за одним. Кроме того я помню как Rust начинался как zero cost, и как потом к этому zero cost добавилась сносочка "бла-бла-бла, мы делаем всё что минимально нужно для выполнения это и есть наш более правильный zero cost" — хи-хи два раза.

Остаётся, видимо, аргумент про корректность состояния программы написанной с использованием исключений. Но коды возврата не делают программу автоматически корректной. Точно также можно забить на код возврата, или тупо пробросить его наверх не вникая в то что повсюду осталось нагажено. И что пайпинг что try! — имхо два пути в никуда. Ну тем кто пропустил 70-е кажется что это путь куда-то, но честное слово, люди туда уже ходили, просто тогда интернета почти не было, все заметки в старых книжках остались.

Имхо выход из этого тупика я вижу только один — автоматические верификаторы кода и язык дружественный статической верификации. По тому же C++ глянув на код можно на глазок оценить — если смарт-пойнтеры и const повсюду — значит есть надежда что код сильно выше среднего по больнице, и скорее всего обработка исключений там тоже будет правильная. Уже сейчас ReSharper очень неплохо подсвечивает и подчёркивает мягко говоря "неудачные" места. Причём иногда настолько хорошо, что просто загружаешь какой-нить проект и просто взглянув (кого там беспокоила проблема recognition?) как методы один за одним подчёркнуты в каждой строчке с собщениями "Possible ... exception" — и сразу видишь — код говно, и исключения его не спасут. Расширить и углубить эту самую верификацию, так что бы понимался всякий pure, const, no throw, guarded и т.п. — и получится годный надёжный код.
Re[3]: Тенденции языков
От: hi_octane Беларусь  
Дата: 18.05.15 08:49
Оценка:
DM>При живой-то Скале? Ну-ну.

Слона то и забыл блин. Их получается уже трое
Re[4]: Тенденции языков
От: hi_octane Беларусь  
Дата: 18.05.15 08:53
Оценка:
ARK>Прочел статью. Не увидел в Nim ничего интересного... Ну обсыпали Ц сахаром слегка, не более того. Не вижу ни цельной концепции, ни каких-то новых фич. Да еще эти отступы.

Решатель для определения разделяемого состояния же. В отдалённой перспективе такая штука может и корректность lock free алгоритмов проверять и много чего ещё. Другое дело что реализация может быть никакая, но сама идея определённо стоящая. Ну и макросы/шаблоны/дженерики — вместо разделения вот так православненько, а вот так — анафема, не поленились и сделали сразу всё.
Re[10]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 08:55
Оценка:
Здравствуйте, hi_octane, Вы писали:

_>Учитывая в Rust анти-паттерн появился try!() — как только его освоят джамшуты — в коде ты увидишь !try(ProcessInternal(item)) и поехали наверх с настолько же неизвестным состоянием. Кстати само появление этой конструкции до того как язык даже вышел — уже должно было заставить авторов сесть за круглый стол и начать осознавать то что они идут куда-то не туда.


В принципе, согласен с этим. Плюс, который я вижу — таки явный "try!", который можно тупо найти поиском.
Re[10]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 08:56
Оценка:
Здравствуйте, MTD, Вы писали:

MTD>Чисто для справки — в Java давным давно пытались заставить насильно обрабатывать исключения, привело это только к автоматически генерируемым заглушкам. Сейчас общее мнение в сообществе, что checked exceptions — зло. Не вижу, почему в Rust будет иначе.


ИМХО, checked exceptions требуют таки гораздо большей кучи бойлерплейта. Впрочем — посмотрим.
Re[6]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 09:00
Оценка:
Здравствуйте, hi_octane, Вы писали:

_>Остаётся, видимо, аргумент про корректность состояния программы написанной с использованием исключений. Но коды возврата не делают программу автоматически корректной. Точно также можно забить на код возврата, или тупо пробросить его наверх не вникая в то что повсюду осталось нагажено. И что пайпинг что try! — имхо два пути в никуда. Ну тем кто пропустил 70-е кажется что это путь куда-то, но честное слово, люди туда уже ходили, просто тогда интернета почти не было, все заметки в старых книжках остались.


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

С остальным в принципе согласен.
Re[10]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 09:04
Оценка: :))
Здравствуйте, MTD, Вы писали:

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


ARK>>Ну вот примитивный пример:


ARK>>
ARK>>  class Test
ARK>>  {
ARK>>    private MyItem[] _myArray;

ARK>>    protected abstract void ProcessInternal(MyItem item);

ARK>>    public int  Process()
ARK>>    {
ARK>>      foreach (var item in _myArray)
ARK>>      {
ARK>>         if (ProcessInternal(item) != ERR_OK) return -1;   // error!
ARK>>      }

ARK>>      // здесь _myArray оказался в неизвестно каком состоянии
ARK>>    }
ARK>>


MTD>Отличный пример


Не совсем так:

  class Test
  {
    private MyItem[] _myArray;

    protected abstract void ProcessInternal(MyItem item) throws Error;  // видим возможность вылета и можем найти по Ctrl-F

    public void Process() throws Error    // видим возможность вылета и можем найти по Ctrl-F
    {
      foreach (var item in _myArray)
      {
         try!(ProcessInternal(item));           // видим возможность вылета и можем найти по Ctrl-F
      }

      // здесь _myArray оказался в неизвестно каком состоянии
    }
Отредактировано 18.05.2015 9:05 AlexRK . Предыдущая версия .
Re[6]: Тенденции языков
От: DarkEld3r  
Дата: 18.05.15 09:53
Оценка:
Здравствуйте, hi_octane, Вы писали:

_>Кроме того я помню как Rust начинался как zero cost, и как потом к этому zero cost добавилась сносочка "бла-бла-бла, мы делаем всё что минимально нужно для выполнения это и есть наш более правильный zero cost" — хи-хи два раза.

Начинался язык как раз немного иначе — у них и ГЦ был. Сейчас как раз вполне до нормального "zero cost" дошли.

В остальном более-менее согласен. Правда в расте паника вполне перехватывается и обрабатывается на границе потоков. То есть работает, по сути, как исключения. Так что если они не упрутся из упрямства, то могут и нормальные исключения появиться, по идее.
Re[6]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 18.05.15 11:15
Оценка: +1
Здравствуйте, hi_octane, Вы писали:

_>Остаётся, видимо, аргумент про корректность состояния программы написанной с использованием исключений. Но коды возврата не делают программу автоматически корректной. Точно также можно забить на код возврата, или тупо пробросить его наверх не вникая в то что повсюду осталось нагажено. И что пайпинг что try! — имхо два пути в никуда. Ну тем кто пропустил 70-е кажется что это путь куда-то, но честное слово, люди туда уже ходили, просто тогда интернета почти не было, все заметки в старых книжках остались.


Я не пойму, почему при обсуждении Раста исключениям по старинке противопоставляют коды возврата. В Расте же есть нормальные алгебраические типы, и обработка ошибок строится как в хаскеле и прочих ML-ях: паттерн матчингом, там забыть что-то обработать компилятор не даст. Это вообще не коды ошибок, нет смысла даже сравнивать.
Re[7]: Тенденции языков
От: DarkEld3r  
Дата: 18.05.15 11:24
Оценка:
Здравствуйте, D. Mon, Вы писали:

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

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

Опять же, хватает случаев когда мы "обязаны обработать", но не можем сделать ничего содержательного, кроме передачи ошибки и раннего выхода (как раз try! сахар). Чем это отличается от "старых-добрых" сишных кодов возврата?

Имхо, исключения отлично смотрелись бы в языке. "Всего-то" сделать панику исключением и готово.
Re[7]: Тенденции языков
От: hi_octane Беларусь  
Дата: 18.05.15 11:56
Оценка:
DM>Я не пойму, почему при обсуждении Раста исключениям по старинке противопоставляют коды возврата. В Расте же есть нормальные алгебраические типы, и обработка ошибок строится как в хаскеле и прочих ML-ях: паттерн матчингом, там забыть что-то обработать компилятор не даст. Это вообще не коды ошибок, нет смысла даже сравнивать.

Дык читал доки и туториалы когда там ещё не было столько чёрточек и других символов. Позже осилил "Error Handling in Rust" и прочие, и пришёл к выводу что упаковали тупл (значение, код_ошибки), и дают на выбор — тянуть его везде при этом чем выше по стэку он пролез тем непонятнее что с ним делать, явно или не очень игнорировать его, unwrap с паникой, или пытаться что-то исправить. В общем коды возврата как они есть и все проблемы к ним относятся в полной мере, пусть даже компилятор и заставляет формально проверку влепить. Иногда натыкаюсь на код типа такого — и ещё раз убеждаюсь, что что-то не так. Ну и сам panic! как бы намекает что сделать совсем без исключений вроде как не смогли.
Re[8]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 18.05.15 12:30
Оценка: +1
Здравствуйте, hi_octane, Вы писали:

_> и пришёл к выводу что упаковали тупл (значение, код_ошибки)...


Не, тут как раз принципиальная разница между произведением (туплом) и копроизведением (алгебраиком Result). Использовать для этих целей тупл крайне тупо, так делают только в самом имбецильном языке Go, и там как раз игнорировать ошибки проще простого. Растаманский Result же это не тупл, а "или-или", у тебя везде два пути в коде — что делать если ок и что делать если ошибка. И можно с этим работать как со значением, накапливать там, трансформировать и т.д. Скажем, пройтись по коллекции, все попробовать обработать, все ошибки собрать в один отчет, что-то с ним сделать. Отличие от привычных кодов возврата — хрен забудешь и удобно комбинировать и обрабатывать как данные. Но писанины, конечно, намного больше получается чем с исключениями. Раст вообще довольно многословный (многобуквенный).
Re[9]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.15 12:32
Оценка: +2
Здравствуйте, AlexRK, Вы писали:

ARK>Ну вот примитивный пример:


ARK>
ARK>      foreach (var item in _myArray)
ARK>         ProcessInternal(item);   // throws Exception
ARK>      // здесь _myArray оказался в неизвестно каком состоянии
ARK>    }
ARK>


"Здесь" управление просто не появится. Соответственно никаких проблем ни _myArray, ни с item не будет. А, вот, с обработкой кодов возвратов управление может и дойти до этого места. Конечно это тоже ошибка в программе, но сделать ее проще, так как для этого достаточно просто халтуры (специальные действия предпринимать не надо).

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

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

Итого, ты снова ничего нам не доказал.

ARK>Обычные коды ошибок действительно обладают этим недостатком. Но возврат в стиле Rust — нет.


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

Немерл тоже контролирует использование возвращаемого значения и создать структуру аналогичную растовскому Result-у не представляет труда. Есть даже похожие стандартные структуры вроде optoion[T] (позволяет хранить значение обернутое в подтип Some или отсутствие значения None). Так вот optoion позволяет явно описывать отсутствие значения. Но применение его усложняет код. Приходится во всех местах где происходит вызов функций возвращающих этот тип писать код проверок. Это муторно, засоряет код и отвлекает от дела. Но тут хотя бы ясно что мы за это получаем.

С обработкой же ошибок, чаще всего, это не так. 99% обработки кода возврата заключается в возврате управления наружу с протаскиванием этого самого кода возврата. Изредка нужно его перезавернуть. И уж совсем редко нужно их реально обрабатывать и что-то делать. Причем, в большинстве случаев, обработка заключается и уведомлении пользователя о возникшей проблеме, логирование оной или перезапуск некоего процесса. Никаких проблем с инвариантами, при этом, не возникает, так как все порожденные в процессе работы данные попросту выбрасываются.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[11]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.15 12:40
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Не совсем так:


Совсем.

ARK> protected abstract void ProcessInternal(MyItem item) throws Error; // видим возможность вылета и можем найти по Ctrl-F


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

ARK> public void Process() throws Error // видим возможность вылета и можем найти по Ctrl-F


Это вообще пипец! И об этом тебе уже говорили. Явские checked exception доказали свою полную непригодность для реальной жизни. Геморрой вызываемый ими нивелируют все их гипотетические преимущества.

ARK> try!(ProcessInternal(item)); // видим возможность вылета и можем найти по Ctrl-F


Не видим, так как этим дело мужно обложить каждую строчку кода. По сути — это закат солнца вручную (эмуляция исключений на кодах возврата). Вот это ваше try!() — это чистой воды болерплэйт. Просто его немного засахарили.

ARK> // здесь _myArray оказался в неизвестно каком состоянии


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

ЗЫ

Итого, мне очевидно, что ты не смог доказать ни одного из своих утверждений. Мой тебе совет признать ошибочность своего мнения, а не упираться рогом.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[11]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.15 12:48
Оценка: 1 (1) +1
Здравствуйте, AlexRK, Вы писали:

ARK> try!(ProcessInternal(item)); // видим возможность вылета и можем найти по Ctrl-F


Кстати, у этого метода есть еще одно неприятное следствие. Вот представь себе, написал ты свой метод ProcessInternal год назад. В то время необходимости обработки ошибок в нем не было. Заиспользовал ты его в сотне мест, из сотни других функций. И вдруг, у тебя малость изменились условия и где-то этот методу потребовалось записать пару байт в файл. Файл этот обязан быть на диске в некотором каталоге. Но ведь файл могут нечаянно грохнуть или место на диске может кончиться, а приложение — это сервер который дергает GUI-ёвое приложение, и ошибку нужно показать в этом самом GUI-е. Что делать будем?

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

В случае же исключений мы просто обрабатываем исключение прямо в корне GUI-ёвого приложения (ведь, они же прозрачно бегают между клиентом и сервером) и показываем тот самый диалог.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[11]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.15 12:50
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>В принципе, согласен с этим. Плюс, который я вижу — таки явный "try!", который можно тупо найти поиском.


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

ЗЫ

Мне вот интересно что в Расте с делением на 0 происходит. Тупо халтят всю программу?
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[12]: Тенденции языков
От: DarkEld3r  
Дата: 18.05.15 13:11
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Мне вот интересно что в Расте с делением на 0 происходит. Тупо халтят всю программу?

Будет паника, да.
Только паника всё-таки вызывает деструкторы, ну и если она была не в главном потоке, то можно обработать.
Re[13]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.15 14:46
Оценка:
Здравствуйте, DarkEld3r, Вы писали:

DE>Будет паника, да.

DE>Только паника всё-таки вызывает деструкторы, ну и если она была не в главном потоке, то можно обработать.

А, если у меня навернулась совсем не критичный метод, но в главном потоке, то программа закроется?
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[10]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 18.05.15 15:10
Оценка: +1
Здравствуйте, VladD2, Вы писали:

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


Все так. Это осознанное их решение — весь раст пронизан духом максимально явного и подробного прописывания всех деталей. Многое из того, что в других языках делается на умолчаниях и на автомате, в расте намеренно заставляют программиста описывать явно. Так они надеются уменьшить число багов в коде на расте. Языков, где "нужно писать основной алгоритм" без мелочей, и так хватает.
Re[14]: Тенденции языков
От: DarkEld3r  
Дата: 18.05.15 15:16
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>А, если у меня навернулась совсем не критичный метод, но в главном потоке, то программа закроется?

Если под "навернулась" понимать растовую "панику" (типа деления на ноль), то да. В общем случае, панику и не предполагается обрабатывать, это что-то типа assert/abort. Да, кто-то может кидать панику из либы и пользователь библиотеки обработать это не сможет, но так делать не принято.

Я не то чтобы защищаю отказ от исключений, но в том же С++ при наличии исключений, деление на ноль тоже нельзя перехватить средствами языка.
Re[11]: Тенденции языков
От: DarkEld3r  
Дата: 18.05.15 15:24
Оценка: +1
Здравствуйте, D. Mon, Вы писали:

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

Ну так обязали бы как-то помечать функции, которые могут кидать (что угодно). А то сейчас ты никак не можешь знать возможна ли паника при вызове произвольной функции. То есть аналога плюсового nothrow нет. А в плане гарантий паника даже хуже исключений так как обработать нельзя (в общем случае). Если, конечно, нас не устраивает "гарантированное падение, если что-то пошло не так".
Re[10]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 16:00
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>"Здесь" управление просто не появится. Соответственно никаких проблем ни _myArray, ни с item не будет.


Ну да, понятно, что здесь не появится. Но _myArray — это поле, и оно испорчено. Проблема проявится в другом методе, если этот объект не будет разрушен.

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


Да, я имел в виду именно состояние объектов внутри _myArray, а не сам массив. Половина из них изменена, другая — нет.

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


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

VD>Никаких проблем с инвариантами, при этом, не возникает, так как все порожденные в процессе работы данные попросту выбрасываются.


Возникают в тех местах, где данные таки не выбрасываются.
Re[12]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 16:06
Оценка:
Здравствуйте, VladD2, Вы писали:

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


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

VD>Это вообще пипец! И об этом тебе уже говорили. Явские checked exception доказали свою полную непригодность для реальной жизни. Геморрой вызываемый ими нивелируют все их гипотетические преимущества.


ИМХО, checked exceptions все же гораздо многословнее растовского варианта. Но смысл примерно тот же, да.

VD>Не видим, так как этим дело мужно обложить каждую строчку кода. По сути — это закат солнца вручную (эмуляция исключений на кодах возврата). Вот это ваше try!() — это чистой воды болерплэйт. Просто его немного засахарили.


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

VD>Вранье! Здесть или не будет управления или он будет в испорченном состоянии, но мы не будет знать об этом, так как где-то выше проигнорировали или неверно обработали код возврата.


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

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


А очевидно другое — что вы не хотите понять, о чем я говорю.
Re[12]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 16:11
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Кстати, у этого метода есть еще одно неприятное следствие. Вот представь себе, написал ты свой метод ProcessInternal год назад. В то время необходимости обработки ошибок в нем не было. Заиспользовал ты его в сотне мест, из сотни других функций. И вдруг, у тебя малость изменились условия и где-то этот методу потребовалось записать пару байт в файл. Файл этот обязан быть на диске в некотором каталоге. Но ведь файл могут нечаянно грохнуть или место на диске может кончиться, а приложение — это сервер который дергает GUI-ёвое приложение, и ошибку нужно показать в этом самом GUI-е. Что делать будем?


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


Кстати, у этого метода есть еще одно неприятное следствие. Вот представь себе, написал ты свой метод ProcessInternal год назад. В то время необходимости ветвления обработки в нем не было. Заиспользовал ты его в сотне мест, из сотни других функций. И вдруг, у тебя малость изменились условия и где-то этот методу потребовалось вычислить дополнительно интеграл Пуассона. Что делать будем?

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



Да, вынесение ошибок в заголовок функции имеет и плюсы, и минусы. В каких-то классах приложений предпочтительнее не выносить, в каких-то выносить.
Re[12]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 16:13
Оценка:
Здравствуйте, VladD2, Вы писали:

ARK>>В принципе, согласен с этим. Плюс, который я вижу — таки явный "try!", который можно тупо найти поиском.

VD>В реальном приложении у тебя этих явных траев будет 100500 на каждом шагу и поиск будет попросту бесполезен.

Думаю, что код на расте надо писать так, чтобы ошибки были сконсолидированы в одном кластере кода. То бишь не вызывать чтение файлов в методе вычисления дифференциальных уравнений. Тогда и 100500 траев не будет. ИМХО.

VD>Мне вот интересно что в Расте с делением на 0 происходит. Тупо халтят всю программу?


По-моему, халт текущей задачи.
Re[12]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 16:16
Оценка:
Здравствуйте, DarkEld3r, Вы писали:

DE>Ну так обязали бы как-то помечать функции, которые могут кидать (что угодно). А то сейчас ты никак не можешь знать возможна ли паника при вызове произвольной функции. То есть аналога плюсового nothrow нет.


А нужно ли оно? Отреагировать на панику ведь все равно никак нельзя. Поэтому просто можно считать, что ее нет.
Re[12]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 18.05.15 16:24
Оценка:
Здравствуйте, DarkEld3r, Вы писали:

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


Знаешь — всегда возможна.
Re[13]: Тенденции языков
От: s22  
Дата: 18.05.15 16:40
Оценка:
Здравствуйте, AlexRK, Вы писали:

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


DE>>Ну так обязали бы как-то помечать функции, которые могут кидать (что угодно). А то сейчас ты никак не можешь знать возможна ли паника при вызове произвольной функции. То есть аналога плюсового nothrow нет.


ARK>А нужно ли оно? Отреагировать на панику ведь все равно никак нельзя. Поэтому просто можно считать, что ее нет.


сохранение дампа....
если дамп будет можно относительно легко читать(сделают тузлу) в дебуг варианте..... то это более информативно, чем исключения
Re[11]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.15 16:53
Оценка:
Здравствуйте, D. Mon, Вы писали:

DM>Все так. Это осознанное их решение — весь раст пронизан духом максимально явного и подробного прописывания всех деталей. Многое из того, что в других языках делается на умолчаниях и на автомате, в расте намеренно заставляют программиста описывать явно. Так они надеются уменьшить число багов в коде на расте. Языков, где "нужно писать основной алгоритм" без мелочей, и так хватает.


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

И не ясно зачем они тогда седелали макросы. Ведь макросы как раз призваны скрывать болерплэйт. Вот эти все Try! — это ведь тоже сокрытие деталей.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[15]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.15 16:57
Оценка: +1
Здравствуйте, DarkEld3r, Вы писали:

DE>Если под "навернулась" понимать растовую "панику" (типа деления на ноль), то да. В общем случае, панику и не предполагается обрабатывать, это что-то типа assert/abort. Да, кто-то может кидать панику из либы и пользователь библиотеки обработать это не сможет, но так делать не принято.


"Не принято" — это зачет!

DE>Я не то чтобы защищаю отказ от исключений, но в том же С++ при наличии исключений, деление на ноль тоже нельзя перехватить средствами языка.


Дык, все ненавистники исключений обычно и имеют опыт их использования исключительно на С++. Возможно, если бы авторы того же Раста по пользовались бы языками где исключения реализованы качественно, у них и не возникло бы желания возвращаться в прошлые века и городить сахар над кодами возврата.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[11]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.15 17:05
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Ну да, понятно, что здесь не появится. Но _myArray — это поле, и оно испорчено. Проблема проявится в другом методе, если этот объект не будет разрушен.


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

ARK>Да, я имел в виду именно состояние объектов внутри _myArray, а не сам массив. Половина из них изменена, другая — нет.


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

ARK>Да, панацеи нет.


О, да, КО!

ARK>Мое изначальное замечание было именно об этом. Обработка ошибок обладает природной сложностью и серебряной пули для нее пока не придумали. Коды возврата (в том числе проверяемые компилятором) обладают своими недостатками, исключения — своими.


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

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

VD>>Никаких проблем с инвариантами, при этом, не возникает, так как все порожденные в процессе работы данные попросту выбрасываются.


ARK>Возникают в тех местах, где данные таки не выбрасываются.


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

Коды возвратов тебе все равно ничем тут не помогут.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[12]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 17:10
Оценка:
Здравствуйте, VladD2, Вы писали:

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


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

То бишь "забыть" о проблемах с инвариантами, когда компилятор явно тебе предписывает обработать ошибку, гораздо сложнее, чем 1) в случае с обычными ретурн кодами (можем забыть проверить); 2) с исключениями (можем быть вообще не в курсе, что они тут пролетают).
Re[13]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.15 17:36
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Как это не видим, когда видим в заголовке функции?


У тебя чуть менее чем все функции будут возвращать Result.

ARK>ИМХО, checked exceptions все же гораздо многословнее растовского варианта. Но смысл примерно тот же, да.


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

ARK>Я думаю, что просто исключения не должны летать где попало, и раст предоставляет для этого средства.


Не бросай их где попало и они не будут летать где попало. Ваш, КО.

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


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

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

ARK>Можно было бы и догадаться, идея не бог весть какая сложная.

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

ARK>А очевидно другое — что вы не хотите понять, о чем я говорю.


Нет, уж. Или ты не можешь сформулировать мысль, или у тебя ее просто нет, а есть некое туманное ощущение. Лично я склоняюсь ко второму.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[13]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.15 17:40
Оценка: +4
Здравствуйте, AlexRK, Вы писали:

ARK>Кстати, у этого метода есть еще одно неприятное следствие. Вот представь себе, написал ты свой метод ProcessInternal год назад. В то время необходимости ветвления обработки в нем не было. Заиспользовал ты его в сотне мест, из сотни других функций. И вдруг, у тебя малость изменились условия и где-то этот методу потребовалось вычислить дополнительно интеграл Пуассона. Что делать будем?


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

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


Вот я и буду логикой заниматься, а ты обработкой кодов.

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


Нет никаких плюсов. Ну, нет. Покажи мне эти плюсы, если ты их видишь.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[13]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.15 17:43
Оценка:
Здравствуйте, AlexRK, Вы писали:

VD>>Мне вот интересно что в Расте с делением на 0 происходит. Тупо халтят всю программу?


ARK>По-моему, халт текущей задачи.


Печально. Это значит, что приложения будут тихо схлопываться вместо того чтобы дать диагностику и продолжить работу.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[7]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 18.05.15 18:02
Оценка:
DM>Я не пойму, почему при обсуждении Раста исключениям по старинке противопоставляют коды возврата. В Расте же есть нормальные алгебраические типы, и обработка ошибок строится как в хаскеле и прочих ML-ях: паттерн матчингом, там забыть что-то обработать компилятор не даст. Это вообще не коды ошибок, нет смысла даже сравнивать.

То есть

case a() of
  _  -> сделай_что_то, невзирая на то, что был возвращен код ошибки?
end

?


dmitriid.comGitHubLinkedIn
Re[11]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 18.05.15 18:12
Оценка:
ARK>Не совсем так:
  Скрытый текст
ARK>
ARK>  class Test
ARK>  {
ARK>    private MyItem[] _myArray;

ARK>    protected abstract void ProcessInternal(MyItem item) throws Error;  // видим возможность вылета и можем найти по Ctrl-F

ARK>    public void Process() throws Error    // видим возможность вылета и можем найти по Ctrl-F
ARK>    {
ARK>      foreach (var item in _myArray)
ARK>      {
ARK>         try!(ProcessInternal(item));           // видим возможность вылета и можем найти по Ctrl-F
ARK>      }

ARK>      // здесь _myArray оказался в неизвестно каком состоянии
ARK>    }
ARK>


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

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

Чем это хорошо? А ничем.

В общем, do not program defensively.


dmitriid.comGitHubLinkedIn
Re[3]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 18.05.15 18:19
Оценка:
s22>Где то читал, что "вменяемый GC" на телефоне требует как минимум 0,05 секунды задержки, что Apple признали не приемлемым, так как пользователь будет ощущать дискомфорт.

эээ чо? Сфероваккумный GC на сферовакуумном телефоне.

У Apple'а есть Objective-C, в который пытались впихнуть GC, и есть Swift, который должен быть совместимым со всем кодом, написанным на этом самом Objective-C. Вот тут да, возможно и есть задержка в 0.05 секунды банально из-за того, что нельзя натянуть GC на Objective-C.

В языке типа Erlang'а GC вообще незаметен для приложения, и на него не влияет. Но Erlang не особо впихуем на телефоны Хотя...


dmitriid.comGitHubLinkedIn
Re[12]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 18:24
Оценка:
Здравствуйте, Mamut, Вы писали:

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


Ну так пусть функция возвращает нужное значение, в чем проблема? Ах, внутри файл читается? Тогда будьте добры отреагировать на потенциальный сбой.
Не хотите? Используйте другие языки, никто не против.
Лично мне нравится подход Rust/Swift.

M>Чем это хорошо? А ничем.


Это хорошо тем, что все происходит _явно_ и видно в коде.

M>В общем, do not program defensively.


А, например, МакКоннелл другого мнения. И я тоже. Впрочем, как эрлангисты пишут, мне все равно.
Re[13]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 18.05.15 18:34
Оценка:
M>>В итоге, любой функции, даже написанной через три месяца другим человеком четырьмя уровнями выше, рпидется столкнуться с тем, что возвращается не нужное значение, а никому не нужная обертка Result<список любых типов любой сложности, внутренности или вложенности>?

ARK>Ну так пусть функция возвращает нужное значение, в чем проблема?


В том, что никто не знает, что это за «нужное значение».

ARK>Ах, внутри файл читается? Тогда будьте добры отреагировать на потенциальный сбой.


Каким образом, если исключений нет?

M>>Чем это хорошо? А ничем.

ARK>Это хорошо тем, что все происходит _явно_ и видно в коде.

Да ничего там «явного». Будет две сотни try! и один общий Err("строка"). И иди разбирайся.


dmitriid.comGitHubLinkedIn
Re[13]: Тенденции языков
От: DarkEld3r  
Дата: 18.05.15 18:50
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>А нужно ли оно? Отреагировать на панику ведь все равно никак нельзя. Поэтому просто можно считать, что ее нет.

Во первых, noexcept в плюсах предоставляет дополнительную информацию компилятору, а значит помогает оптимизациям. Во вторых, в минусы исключений записывается неявность — про панику точно так же из документации узнавать приходится. Ну и в третьих, "иногда" среагировать можно.
Re[13]: Тенденции языков
От: DarkEld3r  
Дата: 18.05.15 18:50
Оценка:
Здравствуйте, D. Mon, Вы писали:

DM>Знаешь — всегда возможна.

Да ладно?
Re[16]: Тенденции языков
От: DarkEld3r  
Дата: 18.05.15 18:53
Оценка: +1
Здравствуйте, VladD2, Вы писали:

VD>"Не принято" — это зачет!

Понимаю, что это звучит забавно. Но ведь и в плюсах можно аборт изнутри либы звать, но так обычно всё-таки не делают.

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

Ну у меня как раз, в основном, плюсовых опыт, а исключения в расте тоже хочется. Так что подозреваю, что причина в другом. Опять же, авторы ссылаются и на другие языки.
Re[14]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 18:54
Оценка:
Здравствуйте, Mamut, Вы писали:

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

ARK>>Ну так пусть функция возвращает нужное значение, в чем проблема?
M>В том, что никто не знает, что это за «нужное значение».

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

ARK>>Ах, внутри файл читается? Тогда будьте добры отреагировать на потенциальный сбой.

M>Каким образом, если исключений нет?

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

M>>>Чем это хорошо? А ничем.

ARK>>Это хорошо тем, что все происходит _явно_ и видно в коде.
M>Да ничего там «явного». Будет две сотни try! и один общий Err("строка"). И иди разбирайся.

Как я понимаю, авторы раста рассчитывают на то, что код будет писаться в основном таким образом, чтобы избегать исключений где попало. Поэтому — в теории — не должно быть try везде, где только можно.
Бич дотнета и явы, NRE, они устранили, это уже неплохо. Если бы еще были правильно сделанные предусловия, тогда закрылся бы еще один источник ошибок — проверки в начале функций.
Re[14]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 18:58
Оценка:
Здравствуйте, DarkEld3r, Вы писали:

ARK>>А нужно ли оно? Отреагировать на панику ведь все равно никак нельзя. Поэтому просто можно считать, что ее нет.

DE>Во первых, noexcept в плюсах предоставляет дополнительную информацию компилятору, а значит помогает оптимизациям.

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

DE>Во вторых, в минусы исключений записывается неявность — про панику точно так же из документации узнавать приходится.


Да вот я не пойму — а зачем?

DE>Ну и в третьих, "иногда" среагировать можно.


В расте? Не слышал. Но, ИМХО, это неправильно, по идее паника это паника.
Re[15]: Тенденции языков
От: DarkEld3r  
Дата: 18.05.15 19:09
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>В плюсах исключения, которые можно хватать и работать дальше, а в расте аборт.

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

ARK>Да вот я не пойму — а зачем?

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

ARK>В расте? Не слышал. Но, ИМХО, это неправильно, по идее паника это паника.

Можно обрабатывать на границе потоков. Так что при большом желании можно извернутсья и использовать как исключения, только вместо try будет thread.
Re[16]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 19:13
Оценка:
Здравствуйте, DarkEld3r, Вы писали:

ARK>>В плюсах исключения, которые можно хватать и работать дальше, а в расте аборт.

DE>Не совсем аборт, по крайней мере, не аборт в плюсовом смысле — стек разматывается и деструкторы вызываются. Очевидно, для этого нужно дополнительные действия предпринимать, а для noexcept не нужно.

Да, тогда согласен.

ARK>>Да вот я не пойму — а зачем?

DE>Как правило всё достаточно очевидно, но мне хочется заранее знать в каких случах что-то может пойти не так. Опять же, для стандартных функций старательно прописаны случаи возникновения паники. Даже в официальном мануале пару слов про соответствующее оформление документации есть. Значит не только мне это важным кажется.

Хз. По-моему, это идею паники убивает, она действительно начинает рассматриваться как исключение (что-то обратимое).

ARK>>В расте? Не слышал. Но, ИМХО, это неправильно, по идее паника это паника.

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

Интересно, зачем это сделано... Как пить дать, на основе этой фичи будут криво эмулировать исключения.
Re[15]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 18.05.15 19:40
Оценка:
M>>В том, что никто не знает, что это за «нужное значение».

ARK>Ничего не понял.

ARK>(Если что, говнокод, в том числе и "список любых типов любой сложности, внутренности или вложенности", можно написать на чем угодно.)

То, что это можно написать на чем угодно не дает индульгенции Расту.

ARK>>>Ах, внутри файл читается? Тогда будьте добры отреагировать на потенциальный сбой.

M>>Каким образом, если исключений нет?
ARK>Проверкой результата функции, представленного алгебраическим типом.

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



M>>>>Чем это хорошо? А ничем.

ARK>>>Это хорошо тем, что все происходит _явно_ и видно в коде.
M>>Да ничего там «явного». Будет две сотни try! и один общий Err("строка"). И иди разбирайся.

ARK>Как я понимаю, авторы раста рассчитывают на то, что код будет писаться в основном таким образом, чтобы избегать исключений где попало. Поэтому — в теории — не должно быть try везде, где только можно.


Чистые теоретики, что ли? На практике будет сотня try! со строкой в Err


dmitriid.comGitHubLinkedIn
Re[15]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 18.05.15 19:47
Оценка:
DE>>Во вторых, в минусы исключений записывается неявность — про панику точно так же из документации узнавать приходится.
ARK>Да вот я не пойму — а зачем?

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

Как это будет работать в расте?


dmitriid.comGitHubLinkedIn
Re[16]: Тенденции языков
От: AlexRK  
Дата: 18.05.15 19:54
Оценка:
Здравствуйте, Mamut, Вы писали:

DE>>>Во вторых, в минусы исключений записывается неявность — про панику точно так же из документации узнавать приходится.

ARK>>Да вот я не пойму — а зачем?

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


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

M>Как это будет работать в расте?


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

В программе панику обработать нельзя, хотя выше DarkEld3r сообщил, что есть какая-то (сомнительная) возможность перехвата на границе потоков.
Re[17]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 18.05.15 20:08
Оценка:
M>>Потому что в правильных языках даже паника — не причина убивать программу. В частности, если паника произойдет в другом потоке, хорошо бы из вызывающего потока узнать, почему она произошла (желательно — со стектрейсом, например).

ARK>В расте программа не убивается, убивается текущая задача.


Ну, если это произойдет в главном потоке, то убьется вся программа. Что тоже плохо.

M>>Как это будет работать в расте?


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


ARK>В программе панику обработать нельзя, хотя выше DarkEld3r сообщил, что есть какая-то (сомнительная) возможность перехвата на границе потоков.


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


dmitriid.comGitHubLinkedIn
Re[16]: Тенденции языков
От: DarkEld3r  
Дата: 18.05.15 20:36
Оценка: 17 (1)
Здравствуйте, Mamut, Вы писали:

M>Как это будет работать в расте?

Стектрейса не будет, будет возврат ошибки любого типа. Буквально — вернётся Any из которого потом реальный тип, насколько я знаю, не так-то и удобно доставать.
Re[17]: Тенденции языков
От: DarkEld3r  
Дата: 18.05.15 20:38
Оценка: 17 (1)
Здравствуйте, AlexRK, Вы писали:

ARK>В программе панику обработать нельзя, хотя выше DarkEld3r сообщил, что есть какая-то (сомнительная) возможность перехвата на границе потоков.

Вот возвращаемый тип, если что.
Re[14]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 19.05.15 04:20
Оценка:
Здравствуйте, DarkEld3r, Вы писали:

DM>>Знаешь — всегда возможна.

DE>Да ладно?

Деление на ноль или какая-нибудь хрень в unsafe завернутая — возможны где угодно же.
Re[8]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 19.05.15 04:24
Оценка: +1
Здравствуйте, Mamut, Вы писали:

DM>> В Расте же есть нормальные алгебраические типы, и обработка ошибок строится как в хаскеле и прочих ML-ях: паттерн матчингом


M>То есть


M>
case a() of
  _  -> сделай_что_то, невзирая на то, что был возвращен код ошибки?
end


Да, если возвращаемое значение тебе не важно, можно примерно так написать, даже короче. Но это вон как надо расстараться, сколько слов написать. Намеренный отказ от разбора ошибки все же не то же самое, что банальная забывчивость.
Re[12]: Тенденции языков
От: s22  
Дата: 19.05.15 05:26
Оценка: -2 :))) :)))
Здравствуйте, VladD2, Вы писали:

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

"Ясно, что быдлокодеры как сидели на шарпе так и будут сидеть"
Re[15]: Тенденции языков
От: DarkEld3r  
Дата: 19.05.15 09:55
Оценка:
Здравствуйте, D. Mon, Вы писали:

DM>Деление на ноль или какая-нибудь хрень в unsafe завернутая — возможны где угодно же.

Теоретически. Практически есть достаточно функций откуда паники можно не ждать. Опять же, в расте точно такая же "проблема" с деструкторами как в С++ — если выброшена паника при обработке паники — будет сразу terminate.
Re[17]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.05.15 14:15
Оценка:
Здравствуйте, DarkEld3r, Вы писали:

DE>Опять же, авторы ссылаются и на другие языки.


На какие?
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[18]: Тенденции языков
От: DarkEld3r  
Дата: 19.05.15 15:29
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>На какие?

Как они сами говорят:

Rust is not a particularly original language, with design elements coming from a wide range of sources. Some of these are listed below (including elements that have since been removed):

SML, OCaml: algebraic datatypes, pattern matching, type inference, semicolon statement separation
C++: references, RAII, smart pointers, move semantics, monomorphisation, memory model
ML Kit, Cyclone: region based memory management
Haskell (GHC): typeclasses, type families
Newsqueak, Alef, Limbo: channels, concurrency
Erlang: message passing, task failure, linked task failure, lightweight concurrency
Swift: optional bindings
Scheme: hygienic macros
C#: attributes
Ruby: block syntax
NIL, Hermes: typestate
Unicode Annex #31: identifier and pattern syntax

Re[12]: Тенденции языков
От: serb Россия  
Дата: 19.05.15 16:03
Оценка:
VD>Правильно! Нужно долго и нудно протаскивать код возврата через все методы где использована эта функция.

VD>В случае же исключений мы просто обрабатываем исключение прямо в корне GUI-ёвого приложения (ведь, они же прозрачно бегают между клиентом и сервером) и показываем тот самый диалог.


КО подсказывает, что в каком-то месте catch будет пропущен и компилятор это не отловит, и в самый неподходящий момент какой-нибудь сервак отвалится.
Re[19]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.05.15 16:58
Оценка: +1
Здравствуйте, DarkEld3r, Вы писали:

DE>

DE>Rust is not a particularly original language, with design elements coming from a wide range of sources. Some of these are listed below (including elements that have since been removed):
DE> SML, OCaml: algebraic datatypes, pattern matching, type inference, semicolon statement separation
DE> C++: references, RAII, smart pointers, move semantics, monomorphisation, memory model
DE> ML Kit, Cyclone: region based memory management
DE> Haskell (GHC): typeclasses, type families
DE> Newsqueak, Alef, Limbo: channels, concurrency
DE> Erlang: message passing, task failure, linked task failure, lightweight concurrency
DE> Swift: optional bindings
DE> Scheme: hygienic macros
DE> C#: attributes
DE> Ruby: block syntax
DE> NIL, Hermes: typestate
DE> Unicode Annex #31: identifier and pattern syntax


Где здесь хоть слово про коды ошибок?

Зато здесь полно языков поддерживающих исключения. Особо смешно выглядит:

Erlang: message passing, task failure, linked task failure, lightweight concurrency

Ведь в Erlang исключения являются частью их стратегии отказоустойчивости.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[20]: Тенденции языков
От: DarkEld3r  
Дата: 19.05.15 19:03
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Где здесь хоть слово про коды ошибок?

А кто их обещал? Я просто сказал, что разработчики раста смотрели не только на С++.
Re[9]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 19.05.15 19:10
Оценка:
DM>Да, если возвращаемое значение тебе не важно, можно примерно так написать, даже короче. Но это вон как надо расстараться, сколько слов написать. Намеренный отказ от разбора ошибки все же не то же самое, что банальная забывчивость.

Ничем не отличается. В итоге все будет обернуто в try! и прочие похожие макросы.

Ну и да. Реально наугад взял https://github.com/rust-lang/rust/blob/master/src/librustc_typeck/collect.rs

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


dmitriid.comGitHubLinkedIn
Re[10]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 20.05.15 04:11
Оценка: +2
Здравствуйте, Mamut, Вы писали:

M>Везде ошибка банально возвращается вверх по стеку вызовов (как пример: cycle_check). В итоге где-то на самом верху сидит код и пытается понять, что ему делать с ErrorReported, возращенной с пятнадцатого вложенного уровня Или не пытается.


Ну а с исключениями там был бы большой catch, который "пытается понять, что ему делать с ErrorReported, возращенной с пятнадцатого вложенного уровня Или не пытается." Те же яйца, но в профиль. Растаманы просто предпочитают явно это все прописать.
Re[11]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 20.05.15 04:22
Оценка: +2
M>>Везде ошибка банально возвращается вверх по стеку вызовов (как пример: cycle_check). В итоге где-то на самом верху сидит код и пытается понять, что ему делать с ErrorReported, возращенной с пятнадцатого вложенного уровня Или не пытается.

DM>Ну а с исключениями там был бы большой catch, который "пытается понять, что ему делать с ErrorReported, возращенной с пятнадцатого вложенного уровня Или не пытается." Те же яйца, но в профиль. Растаманы просто предпочитают явно это все прописать.


О чем все тут и говорят А в ответ «нет, это намного лучше», «нет, вы ничего не понимаете, тут явно!» и т.п.


dmitriid.comGitHubLinkedIn
Re[21]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 20.05.15 09:11
Оценка:
Здравствуйте, DarkEld3r, Вы писали:

VD>>Где здесь хоть слово про коды ошибок?

DE>А кто их обещал? Я просто сказал, что разработчики раста смотрели не только на С++.

Ты говорил, что они куда-то там смотрели. В списке большинство языков поддерживают исключения. Так где они высмотрели языки без исключений?
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[13]: Тенденции языков
От: hi_octane Беларусь  
Дата: 20.05.15 09:17
Оценка: +1
S>КО подсказывает, что в каком-то месте catch будет пропущен и компилятор это не отловит, и в самый неподходящий момент какой-нибудь сервак отвалится.
Все стандартные логгеры автоматом ставят последний глобальный перехватчик чтобы исключение в стопочку положить и умеют дамп записать. Так что если даже и отвалится — оно в итоге для здоровья всё
Re[22]: Тенденции языков
От: DarkEld3r  
Дата: 20.05.15 09:40
Оценка: +1
Здравствуйте, VladD2, Вы писали:

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

Давай сначала: ты обвинил их в "ограниченности кругозора", мол ничего слаще С++ не видели потому и боятся исключений. Вот конкретно это и оспаривал — разработчики раста знакомы и с другими языками (если, конечно, мы им верим).

А так-то я сам за исключения, о чём сразу и сказал.
Re[23]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 20.05.15 10:08
Оценка:
Здравствуйте, DarkEld3r, Вы писали:

DE>Давай сначала: ты обвинил их в "ограниченности кругозора", мол ничего слаще С++ не видели потому и боятся исключений. Вот конкретно это и оспаривал — разработчики раста знакомы и с другими языками (если, конечно, мы им верим).


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

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

Они молодцы, что провели анализ фич других языков. Но вот результат получился спорным.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[24]: Тенденции языков
От: DarkEld3r  
Дата: 20.05.15 11:28
Оценка: +1 -1
Здравствуйте, VladD2, Вы писали:

VD>Личном не очевидно, что люди из мира С++ и с остальными языками они разве что поигрались.

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

Повторюсь, у меня опыт преимущественно плюсовый. При этом преимущества исключений мне очевидны. Хотя по твоей логике должно быть наоборот.
Re[25]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 20.05.15 11:44
Оценка:
Здравствуйте, DarkEld3r, Вы писали:

VD>>Личном не очевидно, что люди из мира С++ и с остальными языками они разве что поигрались.

DE>Из чего очевидно? Просто из самого отсутствия исключений?

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

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


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

DE>Повторюсь, у меня опыт преимущественно плюсовый. При этом преимущества исключений мне очевидны. Хотя по твоей логике должно быть наоборот.


Ну, значит ты более прогрессивный. Среди плюсовиков много народу который использует С++ как улучшенный С или вообще тупо пишет на С. Идеи вроде "явно выражать все намерения" — часто толкают апологеты С-ей, а не плюсов.

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

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

Эти пойдут тем же путем. Сначала отрицание. Потом тишина. Потом вялое приятие. А, в конце скажут, что они всю жизнь хотели исключений, но их не так поняли.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[12]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 20.05.15 12:32
Оценка:
Здравствуйте, Mamut, Вы писали:

M>О чем все тут и говорят А в ответ «нет, это намного лучше», «нет, вы ничего не понимаете, тут явно!» и т.п.

Ну ведь правда же намного лучше!
Вон языки с exceptions всякий раз скатываются в трэш, как только выходят за пределы банального стека. Ну там — давайте попробуем распараллелить десять тасков; оп! три из них упали. Что с этим делать? Или хотя бы просто попытаться бросить исключение из блока итераторов — уже целая песня получается.
А тут всё более-менее понятно: агрегация для ошибок работает так же, как и для данных.
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[13]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 20.05.15 13:48
Оценка:
M>>О чем все тут и говорят А в ответ «нет, это намного лучше», «нет, вы ничего не понимаете, тут явно!» и т.п.
S>Ну ведь правда же намного лучше!
S>Вон языки с exceptions всякий раз скатываются в трэш, как только выходят за пределы банального стека. Ну там — давайте попробуем распараллелить десять тасков; оп! три из них упали. Что с этим делать?

Ты не поверишь Erlang это «проблему» решил еще в начале 90-х. У Раста, как я понимаю, вообще нет никакой возможности узнать, что произошло, если поток завершился аварийно (паника).

S>Или хотя бы просто попытаться бросить исключение из блока итераторов — уже целая песня получается.

S>А тут всё более-менее понятно: агрегация для ошибок работает так же, как и для данных.

Эээ чо?


dmitriid.comGitHubLinkedIn
Re[14]: Тенденции языков
От: DarkEld3r  
Дата: 20.05.15 14:22
Оценка:
Здравствуйте, Mamut, Вы писали:

M>У Раста, как я понимаю, вообще нет никакой возможности узнать, что произошло, если поток завершился аварийно (паника).

Ну стектрейса не будет, а ошибка — вполне.
Re[15]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 20.05.15 14:43
Оценка:
M>>У Раста, как я понимаю, вообще нет никакой возможности узнать, что произошло, если поток завершился аварийно (паника).
DE>Ну стектрейса не будет, а ошибка — вполне.

Ну так стектрейс — это самое интересное Хотя в Эрланге тоже не будет стектрейса в этом случае

Я тут, правда, внезапно нашел смешное: https://doc.rust-lang.org/std/thread/fn.catch_panic.html

То есть все разговоры про то, что панику отловить нельзя — сказки для дурачков. Все можно, несмотря на грозное «не используйте»


dmitriid.comGitHubLinkedIn
Re[16]: Тенденции языков
От: DarkEld3r  
Дата: 20.05.15 15:13
Оценка:
Здравствуйте, Mamut, Вы писали:

M>Я тут, правда, внезапно нашел смешное: https://doc.rust-lang.org/std/thread/fn.catch_panic.html


M>То есть все разговоры про то, что панику отловить нельзя — сказки для дурачков. Все можно, несмотря на грозное «не используйте»

Эта функция всё-таки "нестабильная", то есть в стабильных (не найтли) сборках языка её использовать не получится.

В остальном, она не делает ничего сверхинтересного — точно так же в мейне можно было создать новый поток и выполнять все действия в нём, чтобы перехватить панику. Хотя её появление хороший знак — может и придут к нормальным исключением, жаль только try! макрос уже занят.
Кстати, сейчас в расте ещё и тип ошибки вытаскивать не особо удобно.
Re[14]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 21.05.15 03:23
Оценка: +1
Здравствуйте, Mamut, Вы писали:

M>Эээ чо?

У тебя после join десяти тасков появляется конструкция из десяти результатов, каждый из которых — либо win либо fail. Тебе не надо для этого изобретать самодельные ThrownExceptionsCollection. Просто любой код, который собирается потреблять результаты, должен придумать стратегию. Например, найти первый же сбой и вернуть его наверх как результат.
Или показать диалог с errorsFound, сохранив успешные результаты. Всё зависит от конкретной задачи, но в любом случае есть все необходимые инструменты — свёртки списков и прочее.
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[4]: Тенденции языков
От: _wqwa США  
Дата: 21.05.15 07:22
Оценка:
Здравствуйте, Mamut, Вы писали:



M>У Apple'а есть Objective-C, в который пытались впихнуть GC, и есть Swift, который должен быть совместимым со всем кодом, написанным на этом самом Objective-C. Вот тут да, возможно и есть задержка в 0.05 секунды банально из-за того, что нельзя натянуть GC на Objective-C.

Почему нельзя, если натягивали уже, и стянули затем?
Кто здесь?!
Re[16]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 21.05.15 11:50
Оценка: +1
Здравствуйте, VladD2, Вы писали:
VD>Дык, все ненавистники исключений обычно и имеют опыт их использования исключительно на С++. Возможно, если бы авторы того же Раста по пользовались бы языками где исключения реализованы качественно, у них и не возникло бы желания возвращаться в прошлые века и городить сахар над кодами возврата.
А можно посмотреть на пример языка, где исключения реализованы качественно?
Скажем, в C# они спроектированы явно коряво. Они плохо работают с многопоточностью (http://ericlippert.com/2009/03/06/locks-and-exceptions-do-not-mix/), с модными фишками типа iterator block (http://blogs.msdn.com/b/ericlippert/archive/2009/07/23/iterator-blocks-part-five-push-vs-pull.aspx), и наверняка ещё в паре мест, о которых я не знаю.
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[17]: Тенденции языков
От: Sinix  
Дата: 21.05.15 12:27
Оценка:
Здравствуйте, Sinclair, Вы писали:

S>Скажем, в C# они спроектированы явно коряво. Они плохо работают с многопоточностью (http://ericlippert.com/2009/03/06/locks-and-exceptions-do-not-mix/), с модными фишками типа iterator block (http://blogs.msdn.com/b/ericlippert/archive/2009/07/23/iterator-blocks-part-five-push-vs-pull.aspx), и наверняка ещё в паре мест, о которых я не знаю.


Это стандартные проблемы для любых короутин/акторов, они не уникальны для шарпа.
Проще всего они решаются для односторонних push-итераторов/обсерверов. Т.е. для дотнета — для await и rx. По большому счёту, единственная неприятность: в стек пролазят детали реализации, но студия позволяет их скрыть без особых на то проблем.
Разумеется, за простоту приходится расплачиваться — или лёгкой сфероконичностью RX, или не совсем очевидными нюансами для await.

И да, когда ты пишешь про проблемы при сборе результатов, то на самом деле проблемы начинаются на несколько шагов выше, при запуске асинхронного кода. Потому что для асинхронного кода по определению нет никаких гарантий, что вызывающий код получит результат за обозримое время. Всё остальное — это уже следствия.
Конечно фреймворк может до определённой степени сохранять иллюзию последовательного выполнения, но она рано или поздно обломится на получении результатов/исключений или на дедлоке из-за блокирующего ожидания (например, в ui-потоке).
Наконец, при попытке не спрятать асинхронность, а дать возможность явно расписывать async codeflow средствами языка мы упрёмся в фундаментальную CAP theorem. Т.е. как ни извращайся, проблемы асинхронности никуда не денутся. И вместо языка общего назначения получатся экзоты типа эрланга/MS Orleans/Cω со своими прелестями и ограничениями.
Re[15]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 21.05.15 12:46
Оценка:
M>>Эээ чо?
S>У тебя после join десяти тасков появляется конструкция из десяти результатов, каждый из которых — либо win либо fail. Тебе не надо для этого изобретать самодельные ThrownExceptionsCollection. Просто любой код, который собирается потреблять результаты, должен придумать стратегию. Например, найти первый же сбой и вернуть его наверх как результат.
S>Или показать диалог с errorsFound, сохранив успешные результаты. Всё зависит от конкретной задачи, но в любом случае есть все необходимые инструменты — свёртки списков и прочее.

Ничем не отличается от exception'ов Пример кода из самого Раста я приводил. Там пятиуровневая конструкция, из недр которой наверх возвращается некий ErrorReport. Чем он отличается от самодельного ThrownExceptionsCollection? Да ничем


dmitriid.comGitHubLinkedIn
Re[17]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 21.05.15 17:02
Оценка:
Здравствуйте, Sinclair, Вы писали:

S>А можно посмотреть на пример языка, где исключения реализованы качественно?

S>Скажем, в C# они спроектированы явно коряво. Они плохо работают с многопоточностью (http://ericlippert.com/2009/03/06/locks-and-exceptions-do-not-mix/),

Ты читал что там написано?

so we’ve fixed that for C# 4.0.


Баг не в исключениях, а в генерации кода была. Да и скорее багом является наличие thread abort exception, который может случиться между случайными инструкциями.

S>с модными фишками типа iterator block (http://blogs.msdn.com/b/ericlippert/archive/2009/07/23/iterator-blocks-part-five-push-vs-pull.aspx), и наверняка ещё в паре мест, о которых я не знаю.


Подумай лучше как с итераторами коды возвратов использовать.

Основная проблема шарпа в том, что он развивается эвалюционно. В его дизайн новые фичи просто не закладывались. В новом языке проблемы можно обойти.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 21.05.15 19:58
Оценка:
M>>У Apple'а есть Objective-C, в который пытались впихнуть GC, и есть Swift, который должен быть совместимым со всем кодом, написанным на этом самом Objective-C. Вот тут да, возможно и есть задержка в 0.05 секунды банально из-за того, что нельзя натянуть GC на Objective-C.
_>Почему нельзя, если натягивали уже, и стянули затем?

Это было как попытка натянуть GC на C++. Натянули, но с кучей оговорок, и он был, емнип, неэффективным. В итоге от него отказались, оставив только подсчет ссылок.

Вполне возможно, что можно было бы и допилить, но в 2007-м подоспел айфон, и времени пилить GC не было, когда рядом был быстрый подсчет ссылок, а SDK надо было выпускать «ужепрямосейчас».


dmitriid.comGitHubLinkedIn
Re[14]: Тенденции языков
От: fddima  
Дата: 22.05.15 00:10
Оценка:
Здравствуйте, VladD2, Вы писали:

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

А в реальности — код обработки ошибки её молча душит, иногда с комментарием (по мотивам: Re[3]: chrome mailto limit
Автор: fddima
Дата: 19.05.15
(смотреть конец функции)).
Отредактировано 22.05.2015 0:11 Mystic Artifact . Предыдущая версия .
Re[13]: Тенденции языков
От: fddima  
Дата: 22.05.15 00:40
Оценка: +1
Здравствуйте, AlexRK, Вы писали:

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

ARK>Ну так пусть функция возвращает нужное значение, в чем проблема? Ах, внутри файл читается? Тогда будьте добры отреагировать на потенциальный сбой.
ARK>Не хотите? Используйте другие языки, никто не против.
ARK>Лично мне нравится подход Rust/Swift.
Как минимум, проблема в том, что код который может бросить исключение или ошибку — может вызываться косвенно, и что именно это будет за код — заранее не известно.
При чём обработка ошибки — не ответственность вызывающего кода.
Однако, не забудь, что разработчики обоих частей кода не знают друг о друге, и о возможных ошибках.

        static int Main(string[] args)
        {
            var fileNames = new string[] { "header.js", "library.core.js",  "library.ext.js", "footer.js" };
            try
            {
                var content = fileNames
                    .Select(x => "// " + x + "\n" + File.ReadAllText(x) + "\n") // лямбда - тот самый код
                    .Aggregate((current, next) => current + next);
                return 0;
            }
            catch (Exception ex) // а тут нам вообще пофиг, что упало, но должно быть записано в лог, да ещё со стек-трейсом, что бы было понятно, кто виноват
            {
                Console.WriteLine("Error! {0}", ex.Message);
                return 1;
            }
        }
Отредактировано 22.05.2015 0:44 Mystic Artifact . Предыдущая версия . Еще …
Отредактировано 22.05.2015 0:42 Mystic Artifact . Предыдущая версия .
Отредактировано 22.05.2015 0:42 Mystic Artifact . Предыдущая версия .
Re[16]: Тенденции языков
От: kaa.python Ниоткуда РСДН профессионально мёртв и завален ватой.
Дата: 22.05.15 02:54
Оценка:
Здравствуйте, VladD2, Вы писали:

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


Несколько раз пролистал ветку и так и не понял, что такое хорошая и что такое плохая реализация исключения. Чем исключение в C# лучше исключения в C++? И почему кто-то может ненавидеть исключения базируясь на плюсовом опыте? С ними же там все в норме, а вот то, что их в вышеупомянутом Rust нет – лажа невероятная
Отредактировано 22.05.2015 2:56 kaa.python . Предыдущая версия .
Re[17]: Тенденции языков
От: Cyberax Марс  
Дата: 22.05.15 03:00
Оценка:
Здравствуйте, kaa.python, Вы писали:

KP>Несколько раз пролистал ветку и так и не понял, что такое хорошая и что такое плохая реализация исключения. Чем исключение в C# лучше исключения в C++? И почему кто-то может ненавидеть исключения базируясь на плюсовом опыте? С ними же там все в норме, а вот то, что их в вышеупомянутом Rust нет – лажа невероятная

В Расте пока думают как их добавить. Вроде бы есть консенсус, что от них в итоге никуда не деться.
Sapienti sat!
Re[18]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 22.05.15 04:50
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Ты читал что там написано?

Да, читал.
VD>

VD>so we’ve fixed that for C# 4.0.

А ты — нет. Потому, что дальше там написано:

So everything is good now, right?
Sadly, no. It’s consistently bad now

VD>Основная проблема шарпа в том, что он развивается эвалюционно. В его дизайн новые фичи просто не закладывались. В новом языке проблемы можно обойти.
Не вижу ответа на свой вопрос.
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[17]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 22.05.15 05:21
Оценка: :))) :))
Здравствуйте, kaa.python, Вы писали:

KP>Несколько раз пролистал ветку и так и не понял, что такое хорошая и что такое плохая реализация исключения. Чем исключение в C# лучше исключения в C++? И почему кто-то может ненавидеть исключения базируясь на плюсовом опыте?

В С++ основная дупа — в том, что нет сборки мусора, а на динамически созданные объекты раскрутка стека не влияет.
Поэтому ты на ровном месте получаешь утечку:
CConnection * pConnection = null;
try 
{
  auto tmp = new CConnection(...);
  tmp.setProxy(...); 
  tmp.attachCertStore(...);
  pConnection = tmp;
} catch(...)
{
   // оппа! 
}
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[18]: Тенденции языков
От: kaa.python Ниоткуда РСДН профессионально мёртв и завален ватой.
Дата: 22.05.15 05:27
Оценка: +3
Здравствуйте, Sinclair, Вы писали:

S>В С++ основная дупа — в том, что нет сборки мусора, а на динамически созданные объекты раскрутка стека не влияет.

S>Поэтому ты на ровном месте получаешь утечку:

Ну вообще-то, в 21 веке, более-менее квалифицированные C++ программисты такого трэша не пишут и пользуются умными указателями
Я правильно понимаю, что это единственная проблема C++ исключений?
Re[19]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 22.05.15 07:15
Оценка:
Здравствуйте, kaa.python, Вы писали:

KP>Ну вообще-то, в 21 веке, более-менее квалифицированные C++ программисты такого трэша не пишут и пользуются умными указателями

Ну, поскольку невозможно запретить программистам быть неквалифицированными, или использовать ключевое слово auto, или потоку прерываться между вызовом конструктора объекта и вызовом конструктора умного указателя, этот аргумент выглядит не очень убедительным.
KP>Я правильно понимаю, что это единственная проблема C++ исключений?
Ну, Влад наверняка знает про другие проблемы. Я написал про то, про что знаю я.
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[20]: Тенденции языков
От: kaa.python Ниоткуда РСДН профессионально мёртв и завален ватой.
Дата: 22.05.15 08:00
Оценка:
Здравствуйте, Sinclair, Вы писали:

S>или потоку прерываться между вызовом конструктора объекта и вызовом конструктора умного указателя, этот аргумент выглядит не очень убедительным.


и это приводит к...?
Отредактировано 22.05.2015 8:01 kaa.python . Предыдущая версия .
Re[19]: Тенденции языков
От: hi_octane Беларусь  
Дата: 22.05.15 08:31
Оценка: 18 (2) -1 :))
Сам на С++ пишу редко (но раньше, до стандарта 11, писал много), так что если в каких-то пунктах ошибаюсь или отстал от жизни то поправьте плиз.

KP>Ну вообще-то, в 21 веке, более-менее квалифицированные C++ программисты такого трэша не пишут и пользуются умными указателями

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

KP>Я правильно понимаю, что это единственная проблема C++ исключений?

То что не нравилось мне:

1) нет finally, поэтому основная идиома "прибрать за собой в любом случае, было исключение или нет", превращается либо в двойные телодвижения, либо в надежду на RAII. Про макросы и библиотеки эмулирующие finally я вкурсе, не устраивают.
2) можно кидать и ловить любую ерунду, с которой потом фиг поймёшь что делать. Вместе с другими зажравшимися программистами из мира интерпретаторов я уже привык к удобному объекту "исключение", с полями, методами, вот этим всем.
3) разные команды используют разные базовые классы для исключений, и ни в стандарте ни в популярных либах нету самого главного — стэк трэйса. В результате на разных платформах и в разных компиляторах нужен разный код для сбора стэктрэйса, котрый вроде как нужно вызывать именно в методе где летело само исключение, потом уже поздно. На MSVC точно было именно так, на GCC чуть легче, на Intel не помню.
4) как следствие 3 большинство глобальных перехватов исключений сводится к "записать memory dump при вылете". В том же C# до мемори дампа дело доходит гораздо реже чем в C++.
5) возникают сложные моменты если исключения летят в конструкторах/деструкторах. Для собеседований оно даже хорошо, для надёжной работы не очень.
6) хотелось бы больше помощи от компилятора/IDE в деле разбора чего как и откуда в принципе может вылететь. Этого хотелось бы от всех компиляторов, но C++ в этом чуть впереди, так как появился noexcept.
Re[14]: Тенденции языков
От: AlexRK  
Дата: 22.05.15 08:53
Оценка:
Здравствуйте, fddima, Вы писали:

F> Как минимум, проблема в том, что код который может бросить исключение или ошибку — может вызываться косвенно, и что именно это будет за код — заранее не известно.

F> При чём обработка ошибки — не ответственность вызывающего кода.
F> Однако, не забудь, что разработчики обоих частей кода не знают друг о друге, и о возможных ошибках.

Да, это распространенное мнение. В нем есть свой резон.

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

TD;LR. Я не считаю описанный вами способ корректным. Подходящим на практике в каких-то случаях (может быть, даже в большом количестве случаев) — может быть. Корректным — нет.
Re[21]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 22.05.15 09:37
Оценка: -1 :)))
Здравствуйте, kaa.python, Вы писали:

KP>и это приводит к...?

Нуу... к тому же самому — утечке, нет?
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[20]: Тенденции языков
От: jazzer Россия Skype: enerjazzer
Дата: 22.05.15 09:38
Оценка: +2
Здравствуйте, hi_octane, Вы писали:

_>Сам на С++ пишу редко (но раньше, до стандарта 11, писал много), так что если в каких-то пунктах ошибаюсь или отстал от жизни то поправьте плиз.


_>То что не нравилось мне:


_>1) нет finally, поэтому основная идиома "прибрать за собой в любом случае, было исключение или нет", превращается либо в двойные телодвижения, либо в надежду на RAII. Про макросы и библиотеки эмулирующие finally я вкурсе, не устраивают.


Что значит "надежда на RAII"? Это все равно что "надежда на то, что sin(x) вернет синус, а не косинус"
RAII — это же не финализаторы в управляемых языках, которые хз когда позовутся и позовутся ли вообще.
Тут все гарантировано самим языком, безо всяких надежд.

_>2) можно кидать и ловить любую ерунду, с которой потом фиг поймёшь что делать. Вместе с другими зажравшимися программистами из мира интерпретаторов я уже привык к удобному объекту "исключение", с полями, методами, вот этим всем.


Все вменяемые разработчики бросают производные от std::exception аж с 98 года.

_>3) разные команды используют разные базовые классы для исключений, и ни в стандарте ни в популярных либах нету самого главного — стэк трэйса. В результате на разных платформах и в разных компиляторах нужен разный код для сбора стэктрэйса, котрый вроде как нужно вызывать именно в методе где летело само исключение, потом уже поздно. На MSVC точно было именно так, на GCC чуть легче, на Intel не помню.


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

_>4) как следствие 3 большинство глобальных перехватов исключений сводится к "записать memory dump при вылете". В том же C# до мемори дампа дело доходит гораздо реже чем в C++.


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

_>5) возникают сложные моменты если исключения летят в конструкторах/деструкторах. Для собеседований оно даже хорошо, для надёжной работы не очень.


То ли дело возвращаемые значения. Так и вижу, как из конструктора/деструктора возвращаются коды ошибок
Как раз исключения в конструкторах гарантируют, что объект не будет создан в кривом состоянии.
При этом RAII прибьет то, что успело создаться к моменту вылета исключения.

_>6) хотелось бы больше помощи от компилятора/IDE в деле разбора чего как и откуда в принципе может вылететь. Этого хотелось бы от всех компиляторов, но C++ в этом чуть впереди, так как появился noexcept.


да, noexcept рулит. Раньше приходилось либо атрибутами пользоваться, либо вообще комментариями (что, в принципе, как-то работало — у меня был специальный doxygen-макрос на эту тему)
jazzer (Skype: enerjazzer) Ночная тема для RSDN
Автор: jazzer
Дата: 26.11.09

You will always get what you always got
  If you always do  what you always did
Re[22]: Тенденции языков
От: jazzer Россия Skype: enerjazzer
Дата: 22.05.15 09:42
Оценка: +1
Здравствуйте, Sinclair, Вы писали:

S>Здравствуйте, kaa.python, Вы писали:


KP>>и это приводит к...?

S>Нуу... к тому же самому — утечке, нет?

Каким образом? Или речь прерывании потока каким-нибудь хакерством за пределами языка, типа KillThread какой-нибудь? Ну тогда да, против лома нет приема. С тем же успехом можно прибить поток, в котором крутится сам сборщик мусора.
jazzer (Skype: enerjazzer) Ночная тема для RSDN
Автор: jazzer
Дата: 26.11.09

You will always get what you always got
  If you always do  what you always did
Re[15]: Тенденции языков
От: fddima  
Дата: 22.05.15 14:39
Оценка:
Здравствуйте, AlexRK, Вы писали:

Банальная задача расширяемости (плагинов) — сводится к той проблеме которую я описал.
Возможно кому-то привычнее видеть краш всего процесса, вместо выгруженного плагина с аккуратно залогированным экзепшном, хотя — похоже все IDE, которые я видел — так не думают. А многие даже позволяют работать дальше.
Задача расширяемости — часто встречается и в рамках одного продукта, как один из видов разделения зон ответственности, владения, жизненного цикла.
Отредактировано 22.05.2015 14:41 Mystic Artifact . Предыдущая версия . Еще …
Отредактировано 22.05.2015 14:39 Mystic Artifact . Предыдущая версия .
Re[2]: Тенденции языков
От: __SPIRIT__ Россия  
Дата: 22.05.15 17:07
Оценка: :)
Здравствуйте, hi_octane, Вы писали:

Что-то очень похоже что ты ищешь замену плюсам. А это малость бессмысленно. Если проект большой и старый с плюсов никто не уйдет. Если проект новый, писать на плюсах по меньшей мере странно. Разве что много сторонних и специфичных либ нужно будет использовать. В 90% случаях писать на плюсах == домножить оценку минимум на 1.5-2

Тот же JS более чем реальная замена на клиентской стороне(гусары молчать! ему еще подрасти нужно). Тренд то вполне уверенный, тонкий клиент + облако. И не важно тонкий клиент это вэб, приложение или мобильник. Как результат динамические языки и функциональщина проникает в мэинстрим. А на сервере плюсы не нужны.

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

З.Ы.
Понятно что очередь умирать не скоро дойдет до CAD/CAM и подобных систем но тренд он такой
Re[16]: Тенденции языков
От: AlexRK  
Дата: 22.05.15 17:14
Оценка: +1
Здравствуйте, fddima, Вы писали:

F>Банальная задача расширяемости (плагинов) — сводится к той проблеме которую я описал.

F>Возможно кому-то привычнее видеть краш всего процесса, вместо выгруженного плагина с аккуратно залогированным экзепшном, хотя — похоже все IDE, которые я видел — так не думают. А многие даже позволяют работать дальше.
F>Задача расширяемости — часто встречается и в рамках одного продукта, как один из видов разделения зон ответственности, владения, жизненного цикла.

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

Понятно, что в существующих ОС такой подход не работает и мы имеем выбор из различных, но плохих вариантов.
Re[17]: Тенденции языков
От: fddima  
Дата: 22.05.15 17:37
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Я немного думал над этим вопросом и пришел к выводу, что с точки зрения корректности лучшим способом является полный запрет расширяемости в рамках одного процесса, как это сделано в Singularity. Там любое расширение — это уникальный процесс, общающийся по типизированным каналам с родителем.

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

ARK>Понятно, что в существующих ОС такой подход не работает и мы имеем выбор из различных, но плохих вариантов.

Во всех существующих ОС такой подход как раз работает, и это единственный путь выполнить что-нибудь в "песочнице". Проблема в том, что это довольно дорого с любой сточки зрения, но в осмысленных случаях — он успешно используется.
Re[18]: Тенденции языков
От: AlexRK  
Дата: 22.05.15 17:45
Оценка:
Здравствуйте, fddima, Вы писали:

ARK>>Я немного думал над этим вопросом и пришел к выводу, что с точки зрения корректности лучшим способом является полный запрет расширяемости в рамках одного процесса, как это сделано в Singularity. Там любое расширение — это уникальный процесс, общающийся по типизированным каналам с родителем.

F> Если под процессом, понимается изолированный юзер-спейс, то — это один из наихудших вариантов, особенно для исходного примера. Код собственно говоря хочет работать с документом (state), используя stateful API, а не с набором сообщений (непосредственно или через прокси — это не так важно).

Да, именно изолированный юзерспейс. В Singularity каналы предоставляют stateful API. Только вот использовать его "как попало" нельзя — для канала задаются четкие правила — что, когда и откуда идет, обойти которые нельзя (компилятор запрещает). Ошибки являются частью контракта канала.

F> Но вообще-то в исходном примере была простая лямбда.


Ну, я в контексте плагинов чуть развил тему.

ARK>>Понятно, что в существующих ОС такой подход не работает и мы имеем выбор из различных, но плохих вариантов.

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

Понятно, что работает. Всё работает. И виндовс работает, и линупс работает, и QNX тоже. Только вот как, сколько в коде ошибок и насколько он устойчив — вопрос риторический.
Re[19]: Тенденции языков
От: fddima  
Дата: 22.05.15 18:17
Оценка: +2
Здравствуйте, AlexRK, Вы писали:

F>> Если под процессом, понимается изолированный юзер-спейс, то — это один из наихудших вариантов, особенно для исходного примера. Код собственно говоря хочет работать с документом (state), используя stateful API, а не с набором сообщений (непосредственно или через прокси — это не так важно).

ARK>Да, именно изолированный юзерспейс. В Singularity каналы предоставляют stateful API. Только вот использовать его "как попало" нельзя — для канала задаются четкие правила — что, когда и откуда идет, обойти которые нельзя (компилятор запрещает). Ошибки являются частью контракта канала.
1. Research проекты это хорошо. Я даже за, когда я его смотрел, мне нравилось. Практической же пользы, для нас, программистов наших дней — толку от него вообще никакого.
2. Как иронично, что когда мы обсуждаем error code vs exceptions — показывать ресерч платформу, где есть exceptions.
3. Коммуникационные каналы сразу станут мусором, как только перестанет быть возможным вложить туда то, что хочется.

F>> Но вообще-то в исходном примере была простая лямбда.

ARK>Ну, я в контексте плагинов чуть развил тему.
Отлично. Независимые куски, процессы — они падают, а IPC отваливается. Это вовлекает необходимость обработки ошибок.
TReply SyncRequest<TRequest, TReply>(TRequest request);

Вот сигнатура метода. Этот метод, может упасть: на сериализации сообщения, на передаче сообщения, на десериализации сообщения. При чём ошибка передачи сегодня одна — завтра другая. Сегодня мы используем WCF over pipe, а потом когда задолбались с тем, что оно нихрена не работает — изменили канал, на собственный (с верой что оно будет работать лучше). Так вот — методу SyncRequest — совершенно пофигу на 3 вещи, и даже не знает о:
1. Реализации сериализатора.
2. Реализации канала.
3. Реализации десериализатора.
При этом внешний (вызывающий) код, на котором лежит отвественность обработки ошибки — с исключениями — получает более-менее внятную диагностику, безо всякого протаскивания кодов ошибок в сигнатуры.

А вот другой метод:
void PostAsync<TMessage>(TMessage request);

Данный метод никогда не валится, потому что складывает сообщения в очереди. Но, исключения всё равно могут пораждаться при отсылке инфраструктурой. Если же я залогирую безликие коды ошибок — это существенно усложнит процесс.
Более того, никто не мешает включить дебаг/трейс (всё есстественно в релизной конфигурации), в .NET в частности, и снять стэк-трэйс при постановки сообщения в очередь, если нужно связать сообщение с местом посылки. И то, это всё ещё будет очень безлико.

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

Я не давно заглянул в код Add-In COM Shim — и увидел сплошную лапшу и макрос навроде:
#define SUCCESS(x) if (!(x)) goto error;
.
Это просто ужасно. Это нормально для небольшого C/C++ кода. Это абсолютно ужасно для нового, якобы безопасного языка.
Sinclair, вот и исключениями, то не очень доволен — но лучше уж исключения, чем уг с протаскиванием кодов ошибок.

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


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

ARK>Понятно, что работает. Всё работает. И виндовс работает, и линупс работает, и QNX тоже. Только вот как, сколько в коде ошибок и насколько он устойчив — вопрос риторический.
Windows, Linux, OSX — имеют отличные стабильные ядра, и собственно говоря пока не предвидится, что бы их кто-нибудь превзошел.
Ошибки безусловно есть везде, но и мир на месте не стоит. А Singularity всё равно содержит какое-то (5%?) количество нативного кода. Увы. Докажете его безопасность?
Отредактировано 22.05.2015 18:22 Mystic Artifact . Предыдущая версия . Еще …
Отредактировано 22.05.2015 18:21 Mystic Artifact . Предыдущая версия .
Отредактировано 22.05.2015 18:19 Mystic Artifact . Предыдущая версия .
Re[20]: Тенденции языков
От: AlexRK  
Дата: 22.05.15 18:44
Оценка:
Здравствуйте, fddima, Вы писали:

F> Вот сигнатура метода. Этот метод, может упасть: на сериализации сообщения, на передаче сообщения, на десериализации сообщения. При чём ошибка передачи сегодня одна — завтра другая. Сегодня мы используем WCF over pipe, а потом когда задолбались с тем, что оно нихрена не работает — изменили канал, на собственный (с верой что оно будет работать лучше). Так вот — методу SyncRequest — совершенно пофигу на 3 вещи, и даже не знает о:

F> 1. Реализации сериализатора.
F> 2. Реализации канала.
F> 3. Реализации десериализатора.
F> При этом внешний (вызывающий) код, на котором лежит отвественность обработки ошибки — с исключениями — получает более-менее внятную диагностику, безо всякого протаскивания кодов ошибок в сигнатуры.
F> А вот другой метод:
F> Данный метод никогда не валится, потому что складывает сообщения в очереди. Но, исключения всё равно могут пораждаться при отсылке инфраструктурой. Если же я залогирую безликие коды ошибок — это существенно усложнит процесс.
F> Более того, никто не мешает включить дебаг/трейс (всё есстественно в релизной конфигурации), в .NET в частности, и снять стэк-трэйс при постановки сообщения в очередь, если нужно связать сообщение с местом посылки. И то, это всё ещё будет очень безлико.

Это все понятно, в общем-то повторение уже написанного ранее.

F> И на фоне таких, богатых возможностей — вы предлагаете использовать обыкновенную лапшу с кодом возврата.


Не согласен с коннотацией терминов (богатые возможности против лапши). Я предлагаю не лапшу, а предсказуемый код, глядя на который можно сразу сказать, что здесь может что-то пойти не так. Впрочем, ИМХО, обсуждение зашло в тупик, позиции сторон ясны, а консенсус вряд ли возможен.

F> Sinclair, вот и исключениями, то не очень доволен — но лучше уж исключения, чем уг с протаскиванием кодов ошибок.


Ну, кому как.

ARK>>Понятно, что работает. Всё работает. И виндовс работает, и линупс работает, и QNX тоже. Только вот как, сколько в коде ошибок и насколько он устойчив — вопрос риторический.

F> Windows, Linux, OSX — имеют отличные стабильные ядра, и собственно говоря пока не предвидится, что бы их кто-нибудь превзошел.

Стабильные ядра, написанные без использования исключений.
(У меня там, кстати, QNX, а не OSX, как пример того, что "работают" ОС с разной степенью надежности.)

F> А Singularity всё равно содержит какое-то (5%?) количество нативного кода. Увы. Докажете его безопасность?


Это возможно, вручную (неверифицируемое ядро маленькое). Вот тут доказали для L4: http://ssrg.nicta.com.au/projects/TS/l4.verified/
А вот подобное доказательство для систем, написанных на C++ с исключениями, уже малореально.
Re[21]: Тенденции языков
От: fddima  
Дата: 22.05.15 19:34
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Это все понятно, в общем-то повторение уже написанного ранее.

Это всё к тому, что исключения, в любом виде — помогают решать практические задачи.

F>> И на фоне таких, богатых возможностей — вы предлагаете использовать обыкновенную лапшу с кодом возврата.

ARK>Не согласен с коннотацией терминов (богатые возможности против лапши). Я предлагаю не лапшу, а предсказуемый код, глядя на который можно сразу сказать, что здесь может что-то пойти не так. Впрочем, ИМХО, обсуждение зашло в тупик, позиции сторон ясны, а консенсус вряд ли возможен.
Я тут в треде приводил пример, как в реальном мире нередко обрабатываются коды ошибок — они тупо душаться.
Об этом же написали и в соседних ветках.

ARK>Стабильные ядра, написанные без использования исключений.

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

ARK>(У меня там, кстати, QNX, а не OSX, как пример того, что "работают" ОС с разной степенью надежности.)

Какие-либо гарантии о времени (я про QNX), — это ещё не показатель надежности, и то сильно упирается в железо.
Боюсь, что надежность QNX невозможно сравнить с линуксом, ввиду гораздо более узкого применения первых, и гораздо более широкого применения последних. Поэтому я его и убрал. Хотя, может кто-то и сравнивал. Х.з.

F>> А Singularity всё равно содержит какое-то (5%?) количество нативного кода. Увы. Докажете его безопасность?

ARK>Это возможно, вручную (неверифицируемое ядро маленькое). Вот тут доказали для L4: http://ssrg.nicta.com.au/projects/TS/l4.verified/
ARK>А вот подобное доказательство для систем, написанных на C++ с исключениями, уже малореально.
Тут спору нет. Но и работающей системы нет.
Re[5]: Тенденции языков
От: antropolog  
Дата: 23.05.15 03:32
Оценка: :)))
Здравствуйте, MTD, Вы писали:

MTD>Это бла-бла-бла про якобы просадку производительности и про завуалированный goto.


это не завуалированный а самый ни на есть непосредственный goto, хотя goto лучше хотя бы тем, что видно по коду где окажешься.
Re[12]: Тенденции языков
От: antropolog  
Дата: 23.05.15 03:35
Оценка: :))
Здравствуйте, MTD, Вы писали:

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


пожалуйста, приведи пример хоть немного реального кода с кодами возврата, который можно переписать на исключения и он не будет выглядеть унылым говном.
Re[10]: Тенденции языков
От: antropolog  
Дата: 23.05.15 03:39
Оценка: :))) :))
Здравствуйте, VladD2, Вы писали:


VD>Основная проблема с кодами возврата не контроль компилятора, а куча болепрлэйт-кода засоряющего код, и необходимость тратить на него время.


да покажите же наконец эту кучу бойлерплейт кода хоть в одном реальном проекте, и заодно покажите как бы это классно выглядело с исключениями, посмеёмся всеми шрёдерами
Re[13]: Тенденции языков
От: s22  
Дата: 23.05.15 03:41
Оценка:
Здравствуйте, antropolog, Вы писали:

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


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


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


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

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

Я думаю по этой причине исключения не используются и в гугл.
Отредактировано 23.05.2015 3:47 s22 . Предыдущая версия .
Re[13]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 23.05.15 06:22
Оценка:
Здравствуйте, antropolog, Вы писали:

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


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

Пример реального кода на кошерных кодах возврата от Adobe
Автор: MTD
Дата: 21.02.13


На досуге предлагаю написать итератор без исключений, с помощью конструктора без исключений создать объект с гарантией, что если объект создан то он в валидном состоянии и т.д.
Re[14]: Тенденции языков
От: AlexRK  
Дата: 23.05.15 07:39
Оценка:
Здравствуйте, MTD, Вы писали:

MTD>Пример реального кода на кошерных кодах возврата от Adobe
Автор: MTD
Дата: 21.02.13


Адский код. Хороший пример, но тут кривое API. Непонятно, зачем возвращается код ошибки из каждого метода. Надо было его засунуть внутрь объектов sAIPanelFlyoutMenu/sAIPanel/etc., если уж у них каждый вызов может закончиться фейлом. Каждый метод такого объекта внутри проверил бы состояние, и в случае ошибки просто сделал бы return, а юзер проверил бы ошибку один раз после всех обращений к объекту.

MTD>На досуге предлагаю написать итератор без исключений, с помощью конструктора без исключений создать объект с гарантией, что если объект создан то он в валидном состоянии и т.д.


Про итератор не знаю, а с конструктором, ИМХО, должно быть так — внутри не должно быть никаких вызовов, которые могут закончиться ошибкой, в противном случае следует применить factory method (мало того, я считаю это хорошей практикой вообще, а не только для языков без исключений).
Re[15]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 23.05.15 08:05
Оценка:
MTD>>Пример реального кода на кошерных кодах возврата от Adobe
Автор: MTD
Дата: 21.02.13


ARK>Адский код. Хороший пример, но тут кривое API. Непонятно, зачем возвращается код ошибки из каждого метода. Надо было его засунуть внутрь объектов sAIPanelFlyoutMenu/sAIPanel/etc.,


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


dmitriid.comGitHubLinkedIn
Re[11]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 23.05.15 08:18
Оценка: +1
VD>>Основная проблема с кодами возврата не контроль компилятора, а куча болепрлэйт-кода засоряющего код, и необходимость тратить на него время.

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



Ну например что-то типа тут.

— Помечаем, что мы ответственны за получение исключений из дочерних процессов
— Запускаем дочерний процесс
— Ждем сообщений из дочернего процесса
— Обрабатываем приходящие сообщения (включая исключения)

Так как это — init функция, у нее в спеках прописано, что она возвращает или {ok, Pid} или {error, Reason). А могла бы выкидывать исключение.

Так же, например, тут. И много где еще.


dmitriid.comGitHubLinkedIn
Re[15]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 23.05.15 08:21
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Адский код. Хороший пример, но тут кривое API. Непонятно, зачем возвращается код ошибки из каждого метода.


Ну так ошибка может возникнуть в любом месте.

MTD>>На досуге предлагаю написать итератор без исключений, с помощью конструктора без исключений создать объект с гарантией, что если объект создан то он в валидном состоянии и т.д.


ARK>Про итератор не знаю


То код работы с коллекциями (которого в реальном коде процентов 80) превращается в что-то типа такого:

Iter i;
if (!GetIter(i, data)) return -1;
while (i.HasNext())
{
    X x;
    if (!i.Get(x)) return -1;
    ...
    if (!i.Next()) return -1;
}


Вместо:

for (Iter i : data)
    X x = i.Current();


Ну круто. И что характерно никаких преимуществ перед исключениями.
Re[16]: Тенденции языков
От: AlexRK  
Дата: 23.05.15 08:32
Оценка:
Здравствуйте, MTD, Вы писали:

MTD>То код работы с коллекциями (которого в реальном коде процентов 80) превращается в что-то типа такого:


MTD>
MTD>Iter i;
MTD>if (!GetIter(i, data)) return -1;
MTD>while (i.HasNext())
MTD>{
MTD>    X x;
MTD>    if (!i.Get(x)) return -1;
MTD>    ...
MTD>    if (!i.Next()) return -1;
MTD>}
MTD>


Непонятно. Это все не нужно. GetIter не должен завершаться с ошибкой. HasNext и Next должны быть одним методом MoveNext, для которого тоже нет резона возвращать ошибку.
Get/Current — тут да, наверное ошибка может быть.

Мой вариант без исключений:

for (Iter i : data)
{
    X x;
    if (i.Get(x))
    {
    }
}
Re[17]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 23.05.15 09:17
Оценка: 3 (1) +4
Здравствуйте, AlexRK, Вы писали:

ARK>Непонятно. Это все не нужно. GetIter не должен завершаться с ошибкой.


Это почему? А если память, например, не удалось выделить?

ARK>HasNext и Next должны быть одним методом MoveNext


На практике это неудобно, например, я не хочу сдвигать итератор, просто хочу проверить, что есть куда сдвигать.

ARK>для которого тоже нет резона возвращать ошибку.


А MoveNext невалидному итератору? Ты уверен, что стоит так замаскировать баг?

ARK>Get/Current — тут да, наверное ошибка может быть.


ARK>Мой вариант без исключений:


В идеальном мире, где ошибки бывают только там где хочет программист.
Отредактировано 23.05.2015 9:19 MTD . Предыдущая версия .
Re[18]: Тенденции языков
От: AlexRK  
Дата: 23.05.15 09:49
Оценка: :))) :)))
Здравствуйте, MTD, Вы писали:

ARK>>Непонятно. Это все не нужно. GetIter не должен завершаться с ошибкой.

MTD>Это почему? А если память, например, не удалось выделить?

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

ARK>>HasNext и Next должны быть одним методом MoveNext

MTD>На практике это неудобно, например, я не хочу сдвигать итератор, просто хочу проверить, что есть куда сдвигать.

Ну пусть будет, мне не жалко. Только не надо его тогда в пример приводить для придания многословности (или, если уж приводить, то в обоих примерах).

ARK>>для которого тоже нет резона возвращать ошибку.

MTD>А MoveNext невалидному итератору? Ты уверен, что стоит так замаскировать баг?

Да, согласен, маскировать в данном случае нехорошо. Если брать обычные коды ошибок, то проверку следует сделать один раз после цикла:
for (Iter i : data)
{
    X x;
    if (i.Get(x))
    {
        ...
    }
}
if (data.IteratorCorrupted)
{
    ...
}


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

Кстати, в С++ с инвалидными итераторами, насколько я понимаю, тоже все "отлично": http://stackoverflow.com/questions/16904454/what-is-iterator-invalidation

Because that error right there? No compiler error, no warning, you lose. You just have to be trained well enough to watch for them and prevent them. Very insidious bugs if you don't know what you're doing. One of the design philosophies of C++ is speed over safety. The runtime check that would lead iterator invalidation to an exception instead of unspecified behavior is too expensive, in the view of C++ language designers.

Re[14]: Тенденции языков
От: antropolog  
Дата: 23.05.15 13:06
Оценка: :)))
Здравствуйте, MTD, Вы писали:


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


MTD>Пример реального кода на кошерных кодах возврата от Adobe
Автор: MTD
Дата: 21.02.13


отличный код. супер. реально. теперь попробуй его переделать на исключения. могу дать подсказку, в одних случаях наличие error ведёт сразу к возврату из функции ( это легко заменить на единственный try/catch ), а в других ( примерно с середины твоего кода ) error в некоторых случаях игнорируется, например здесь:
    error = sAIPanelFlyoutMenu->AppendItem(fPanelFlyoutMenu, 1, ai::UnicodeString("First Item"));
    error = sAIPanelFlyoutMenu->AppendItem(fPanelFlyoutMenu, 3, ai::UnicodeString("Third Item"));
    error = sAIPanelFlyoutMenu->InsertItem(fPanelFlyoutMenu, 3, 2, ai::UnicodeString("Second Item"));
    error = sAIPanelFlyoutMenu->InsertSeparator(fPanelFlyoutMenu, 3, 5);
    error = sAIPanelFlyoutMenu->AppendItem(fPanelFlyoutMenu, 4, ai::UnicodeString("Fourth Item"));


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


MTD>На досуге предлагаю написать итератор без исключений, с помощью конструктора без исключений создать объект с гарантией, что если объект создан то он в валидном состоянии и т.д.

с исключениями у тебя вся программа — одно сплошное невалидное состояние
class Frobber
{
private:
    int m_NumberOfFrobs;
    FrobManager m_FrobManager;

public:

    void Frob()
    {
        m_NumberOfFrobs++;

        m_FrobManager.HandleFrob(new FrobObject());
    }
};


что если new FrobObject кинет исключение? m_NumberOfFrobs пушкин отревертит? а это очень простой пример. Собственно когда "обсасывалось уже сто раз" ты видимо пропустил такой момент, что исключения могут работать только при полной строгой гарантии исключений ( т.е. все методы — транзакционны ), но это бывает только в стране эльфоф и цветных пони.
Отредактировано 23.05.2015 13:07 antropolog . Предыдущая версия .
Re[18]: Тенденции языков
От: antropolog  
Дата: 23.05.15 13:12
Оценка: -1
Здравствуйте, MTD, Вы писали:

MTD>Это почему? А если память, например, не удалось выделить?

бросать исключение. это нарушение инварианта. поломанный assert короче говоря.

MTD>На практике это неудобно, например, я не хочу сдвигать итератор, просто хочу проверить, что есть куда сдвигать.

логика на исключениях? мне вас жаль (с)

MTD>А MoveNext невалидному итератору? Ты уверен, что стоит так замаскировать баг?

бросать исключение. это нарушение инварианта. поломанный assert короче говоря.
Отредактировано 23.05.2015 13:12 antropolog . Предыдущая версия .
Re[15]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 23.05.15 14:25
Оценка: 18 (2) +1 :)
A>
A>    error = sAIPanelFlyoutMenu->AppendItem(fPanelFlyoutMenu, 1, ai::UnicodeString("First Item"));
A>    error = sAIPanelFlyoutMenu->AppendItem(fPanelFlyoutMenu, 3, ai::UnicodeString("Third Item"));
A>    error = sAIPanelFlyoutMenu->InsertItem(fPanelFlyoutMenu, 3, 2, ai::UnicodeString("Second Item"));
A>    error = sAIPanelFlyoutMenu->InsertSeparator(fPanelFlyoutMenu, 3, 5);
A>    error = sAIPanelFlyoutMenu->AppendItem(fPanelFlyoutMenu, 4, ai::UnicodeString("Fourth Item"));
A>


A>здесь любая строка может не отработать, но это игнорируется. Покажи теперь как это (это — весь твой код ) будет на исключениях, аххахаха (зловещий хохот ).



%% Для варианта 1 и 2 ниже
%% нам нужен список элементов и функция, их добавляющая

list_of_items() ->
  ["First Item", "Third Item", separator, "Fourth Item"].

add_to_menu(Item) ->
  try
    fly_out_menu:append_item(panel_flyout_menu, Item)
  catch
    _:Reason -> {error, Reason}
  end.

%% ------------------------
%% Вариант 1
%% лопатим вручную
safe_add([], Errors) ->
  case Errors of
    [] -> ok;
    _ -> %% обработали ошибки, если надо
  end;
safe_add([Item|Rest], Errors) ->
  case add_to_menu(Item) of
    ok -> safe_add(Rest, Errors);
    {error, Reason} = safe_add(Rest, [Reason | Errors])
  end.

%% и дальше в коде где-то

safe_add(list_of_items()).

%% ------------------------
%% Вариант 2
%% foldl

safe_add(Item, Errors) ->
  case add_to_menu(Item) of
    ok -> Errors;
    {error, Reason} -> [Reason | Errors]
  end.

%% где-то в коде
  case lists:foldl(fun safe_add/2, [], list_of_items()) of
    [] -> ok;
    Errors -> %% обрабатываем все ошибки
  end.

%% ------------------------
%% Вариант 3
%% Один в один код из Адоба

adobe_style_adъ() ->
 % игнорируем ошибки
 catch fly_out_menu:append_item(panel_flyout_menu, "First Item"),
 catch fly_out_menu:append_item(panel_flyout_menu, "Third Item"),
 catch fly_out_menu:append_item(panel_flyout_menu, "Second Item"),
 catch fly_out_menu:append_item(panel_flyout_menu, separator),
 
 % не игнорируем ошибки
 fly_out_menu:append_item(panel_flyout_menu, "First Item").

%% где-то дальше в коде
try 
  adobe_style_adъ()
catch 
  _:Reason -> %обработали ошибку


dmitriid.comGitHubLinkedIn
Re[11]: Тенденции языков
От: VladD2 Российская Империя www.nemerle.org
Дата: 23.05.15 14:57
Оценка: +2
Здравствуйте, antropolog, Вы писали:

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


Посмотри любой COM-сервис и его аналог на Дотнете или Яве. Я вдоволь насмотрелся на код для MS VS написанный на С++ и на то как в нем теряется обработка ошибок просто поту что кому-то было в лом ее протаскивать. Аналогичный код на C# в разы понятнее и проще.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[19]: Тенденции языков
От: _NN_ www.nemerleweb.com
Дата: 23.05.15 16:16
Оценка:
Здравствуйте, kaa.python, Вы писали:

KP>Ну вообще-то, в 21 веке, более-менее квалифицированные C++ программисты такого трэша не пишут и пользуются умными указателями

Увы не все из более-меенее квалифицированных не знакомы даже с shared_ptr, а про unique_ptr и про другие тем более не знают.
Так что проблема действительно имеет место быть.
Вот если бы компилятор не компилировал явный 'new'/malloc и подобное , тогда было бы другое дело.
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[20]: Тенденции языков
От: jazzer Россия Skype: enerjazzer
Дата: 23.05.15 17:55
Оценка: +1
Здравствуйте, _NN_, Вы писали:

_NN>Здравствуйте, kaa.python, Вы писали:


KP>>Ну вообще-то, в 21 веке, более-менее квалифицированные C++ программисты такого трэша не пишут и пользуются умными указателями

_NN>Увы не все из более-меенее квалифицированных не знакомы даже с shared_ptr, а про unique_ptr и про другие тем более не знают.
_NN>Так что проблема действительно имеет место быть.
_NN>Вот если бы компилятор не компилировал явный 'new'/malloc и подобное , тогда было бы другое дело.

shared_ptr и unique_ptr — это еще ладно, это либо буст, либо C++11
Но auto_ptr-то сто лет как есть и вполне прилично свою задачу по убийству чего не нужно решает, во всяких фабриках и т.п.
jazzer (Skype: enerjazzer) Ночная тема для RSDN
Автор: jazzer
Дата: 26.11.09

You will always get what you always got
  If you always do  what you always did
Re[21]: Тенденции языков
От: _NN_ www.nemerleweb.com
Дата: 23.05.15 17:59
Оценка:
Здравствуйте, jazzer, Вы писали:

J>shared_ptr и unique_ptr — это еще ладно, это либо буст, либо C++11

J>Но auto_ptr-то сто лет как есть и вполне прилично свою задачу по убийству чего не нужно решает, во всяких фабриках и т.п.
Это конечно так, но основой массе людей нет времени или желания разбираться в тонкостях C++.
К счастью большинство кода на C# и поэтому проблем этого плана меньше
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[19]: Тенденции языков
От: jazzer Россия Skype: enerjazzer
Дата: 23.05.15 18:00
Оценка: 1 (1) +4 :))
Здравствуйте, AlexRK, Вы писали:

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


ARK>>>Непонятно. Это все не нужно. GetIter не должен завершаться с ошибкой.

MTD>>Это почему? А если память, например, не удалось выделить?

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


jazzer (Skype: enerjazzer) Ночная тема для RSDN
Автор: jazzer
Дата: 26.11.09

You will always get what you always got
  If you always do  what you always did
Re[22]: Тенденции языков
От: jazzer Россия Skype: enerjazzer
Дата: 24.05.15 02:02
Оценка: +1
Здравствуйте, _NN_, Вы писали:

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


J>>shared_ptr и unique_ptr — это еще ладно, это либо буст, либо C++11

J>>Но auto_ptr-то сто лет как есть и вполне прилично свою задачу по убийству чего не нужно решает, во всяких фабриках и т.п.
_NN>Это конечно так, но основой массе людей нет времени или желания разбираться в тонкостях C++.

В смысле, что 95% программеров — индусы ленивые идиоты, нежелающие изучать собственный инструмент? Ну да, для них тогда нужен инструмент с хорошей защитой от дурака, с философией "пиши как хочешь и ни о чем не беспокойся, память больше не ресурс (с) и gc за всем приберет".

_NN>К счастью большинство кода на C# и поэтому проблем этого плана меньше


Тогда уж Java.
auto_ptr в С++ был, когда шарпа еще и в проекте не было (ну или как раз в проекте, судя по Вики). И во всех "библиях" типа майерса, саттера и т.п. (а ведь у них сайты/блоги были, не только бумажные книги) и факах самого Бьярне он активно продвигался (вместе с самим принципом RAII)

Вот, например, статья аж 1999 года, посвященная целиком этой теме:
http://www.gotw.ca/publications/using_auto_ptr_effectively.htm
А Синклер вон до сих пор, в 2015, спустя 16 лет (!!!), какой-то трэш на эту тему пишет
jazzer (Skype: enerjazzer) Ночная тема для RSDN
Автор: jazzer
Дата: 26.11.09

You will always get what you always got
  If you always do  what you always did
Re[20]: Тенденции языков
От: Evgeny.Panasyuk Россия  
Дата: 24.05.15 02:30
Оценка:
Здравствуйте, _NN_, Вы писали:

_NN>Увы не все из более-меенее квалифицированных не знакомы даже с shared_ptr, а про unique_ptr и про другие тем более не знают.

_NN>Так что проблема действительно имеет место быть.
_NN>Вот если бы компилятор не компилировал явный 'new'/malloc и подобное , тогда было бы другое дело.

Можно сделать отдельный верификатор запрещающий их везде кроме специально отведённого места. Например на базе Clang AST Matchers. Да даже grep'а хватит(если кто попробует обхитрить grep — то будет расцениваться как диверсия).
Re[20]: Тенденции языков
От: fddima  
Дата: 24.05.15 03:30
Оценка: +1 :)
Здравствуйте, jazzer, Вы писали:

MTD>>>Это почему? А если память, например, не удалось выделить?

ARK>>Если память не удалось выделить, то это крах программы, исключения тут не помогут.
J>
Ну приблизительно по таким вот причинам Windows регулярно в синий экран и выпадало ведь.
А что ещё делать? Вокруг одни коды ошибок, исключений вдобавок нет, ещё и память не выделяеться и бац!
Как синий экран отрисовывали-то — загадка. Да что там синий экран. Вот Windows 8 — вместо синего экрана — красюсюшки рисует. Магия.
... << RSDN@Home 1.0.0 alpha 5 rev. 0>>
Re[20]: Тенденции языков
От: kaa.python Ниоткуда РСДН профессионально мёртв и завален ватой.
Дата: 24.05.15 05:47
Оценка:
Здравствуйте, _NN_, Вы писали:

_NN>Увы не все из более-меенее квалифицированных не знакомы даже с shared_ptr, а про unique_ptr и про другие тем более не знают.


Просто они не квалифицированные C++ разработчики, не более того.

_NN>Так что проблема действительно имеет место быть.


Проблема отсутствия квалифицированных специалистов, разве что.
Отредактировано 24.05.2015 12:24 kaa.python . Предыдущая версия .
Re[15]: Тенденции языков
От: jazzer Россия Skype: enerjazzer
Дата: 24.05.15 07:27
Оценка:
Здравствуйте, antropolog, Вы писали:

A>что если new FrobObject кинет исключение? m_NumberOfFrobs пушкин отревертит? а это очень простой пример. Собственно когда "обсасывалось уже сто раз" ты видимо пропустил такой момент, что исключения могут работать только при полной строгой гарантии исключений ( т.е. все методы — транзакционны ), но это бывает только в стране эльфоф и цветных пони.


А мне зарплату, видимо, Гэндальф платит, ага.
jazzer (Skype: enerjazzer) Ночная тема для RSDN
Автор: jazzer
Дата: 26.11.09

You will always get what you always got
  If you always do  what you always did
Re[21]: Тенденции языков
От: jazzer Россия Skype: enerjazzer
Дата: 24.05.15 07:30
Оценка: +1 :)
Здравствуйте, fddima, Вы писали:

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


MTD>>>>Это почему? А если память, например, не удалось выделить?

ARK>>>Если память не удалось выделить, то это крах программы, исключения тут не помогут.
J>>
F> Ну приблизительно по таким вот причинам Windows регулярно в синий экран и выпадало ведь.
F> А что ещё делать? Вокруг одни коды ошибок, исключений вдобавок нет, ещё и память не выделяеться и бац!
F> Как синий экран отрисовывали-то — загадка. Да что там синий экран. Вот Windows 8 — вместо синего экрана — красюсюшки рисует. Магия.

Это ты еще забыл, что "память больше не ресурс" (с)
jazzer (Skype: enerjazzer) Ночная тема для RSDN
Автор: jazzer
Дата: 26.11.09

You will always get what you always got
  If you always do  what you always did
Re[15]: Тенденции языков
От: Ops Россия  
Дата: 24.05.15 11:53
Оценка:
Здравствуйте, antropolog, Вы писали:

A>что если new FrobObject кинет исключение? m_NumberOfFrobs пушкин отревертит?

Зачем? m_NumberOfFrobs считает количество попыток, в т.ч. и проваленных, так что ничего отворачивать не надо. Ну или у тебя логическая ошибка, если ты от этого счетчика хотел что-то другое. Например, удачные попытки нужно считать после того, как они удались, а считать количество FrobObject должен FrobManager, если он ими владеет а не просто обрабатывает и сразу удаляет.
Переубедить Вас, к сожалению, мне не удастся, поэтому сразу перейду к оскорблениям.
Re[15]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 24.05.15 20:29
Оценка: +1
Здравствуйте, antropolog, Вы писали:

A>отличный код. супер. реально. теперь попробуй его переделать на исключения. могу дать подсказку, в одних случаях наличие error ведёт сразу к возврату из функции ( это легко заменить на единственный try/catch ), а в других ( примерно с середины твоего кода ) error в некоторых случаях игнорируется, например здесь:


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

A>с исключениями у тебя вся программа — одно сплошное невалидное состояние

A>
A>class Frobber
A>{
A>private:
A>    int m_NumberOfFrobs;
A>    FrobManager m_FrobManager;

A>public:

A>    int Frob()
A>    {
A>        m_NumberOfFrobs++;

          FrobObject* f = NULL;
          if (!CreateFrobObject(f)) return -1; // Чем это лучше?
A>        m_FrobManager.HandleFrob(f);
A>    }
A>};
A>


Все-таки смешные вы, уже второй раз пишете говнокод, который будет говнокодом хоть с кодами ошибок, хоть с исключениями и считаете, что это что-то должно доказать.
Re[19]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 24.05.15 20:31
Оценка:
Здравствуйте, antropolog, Вы писали:

A>бросать исключение.


Не понял, ты же кричал, что код с исключениями — УГ по определению.

MTD>>На практике это неудобно, например, я не хочу сдвигать итератор, просто хочу проверить, что есть куда сдвигать.

A>логика на исключениях? мне вас жаль (с)

И где здесь логика на исключениях?
Re[23]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 25.05.15 05:22
Оценка:
Здравствуйте, jazzer, Вы писали:

J>Каким образом? Или речь прерывании потока каким-нибудь хакерством за пределами языка, типа KillThread какой-нибудь? Ну тогда да, против лома нет приема.

А что у вас вместо лома? В managed environment даже при аборте потока есть шанс отработать хэндлеры и прибрать за собой ресурсы. В С++ такого просто вообще нет.
J> С тем же успехом можно прибить поток, в котором крутится сам сборщик мусора.
Фантазии оставьте. Даже если вы сумеете найти хэндл GC-потока и прибить, то среда просто перезапустит его.
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[23]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 25.05.15 05:25
Оценка: +4 :))) :))
Здравствуйте, jazzer, Вы писали:
J>А Синклер вон до сих пор, в 2015, спустя 16 лет (!!!), какой-то трэш на эту тему пишет
В прошлый раз, когда поднималась тема C++, в первом же взятом открытом проекте мы нашли всё подряд — и выделение на голых malloc (хотя "конечно же все серъёзные проекты используют пулы, арены, и прочие продвинутые стратегии выделения/очистки), и raw pointers, и вызовы delete.

Но это да, Синклер виноват в том, что программисты С++ пишут вовсе не так, как о себе думают.
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[24]: Тенденции языков
От: jazzer Россия Skype: enerjazzer
Дата: 25.05.15 06:28
Оценка:
Здравствуйте, Sinclair, Вы писали:

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


J>>Каким образом? Или речь прерывании потока каким-нибудь хакерством за пределами языка, типа KillThread какой-нибудь? Ну тогда да, против лома нет приема.

S>А что у вас вместо лома? В managed environment даже при аборте потока есть шанс отработать хэндлеры и прибрать за собой ресурсы. В С++ такого просто вообще нет.

Ну то есть это единственный сценарий утечки? Низкоуровневый KillThread сразу после выделения памяти?
Ну ОК, осталось только понять, при чем тут исключения
jazzer (Skype: enerjazzer) Ночная тема для RSDN
Автор: jazzer
Дата: 26.11.09

You will always get what you always got
  If you always do  what you always did
Re[24]: Тенденции языков
От: jazzer Россия Skype: enerjazzer
Дата: 25.05.15 06:33
Оценка: +1
Здравствуйте, Sinclair, Вы писали:

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

J>>А Синклер вон до сих пор, в 2015, спустя 16 лет (!!!), какой-то трэш на эту тему пишет
S>В прошлый раз, когда поднималась тема C++, в первом же взятом открытом проекте мы нашли всё подряд — и выделение на голых malloc (хотя "конечно же все серъёзные проекты используют пулы, арены, и прочие продвинутые стратегии выделения/очистки), и raw pointers, и вызовы delete.

S>Но это да, Синклер виноват в том, что программисты С++ пишут вовсе не так, как о себе думают.


Не надо кивать на открытые проекты. Это феерическое ведь ты написал своими руками: "В С++ основная дупа — в том, что нет сборки мусора, а на динамически созданные объекты раскрутка стека не влияет." и дальше рукопашная работа с памятью, как будто ты о RAII вообще никогда не слышал.
jazzer (Skype: enerjazzer) Ночная тема для RSDN
Автор: jazzer
Дата: 26.11.09

You will always get what you always got
  If you always do  what you always did
Re[21]: Тенденции языков
От: hi_octane Беларусь  
Дата: 25.05.15 10:00
Оценка: +1
J>Что значит "надежда на RAII"? Это все равно что "надежда на то, что sin(x) вернет синус, а не косинус"
J>RAII — это же не финализаторы в управляемых языках, которые хз когда позовутся и позовутся ли вообще.
J>Тут все гарантировано самим языком, безо всяких надежд.
Надежда в основном на то что RAII будет достаточно. Порядок свёртки какбы тоже часть RAII, и если он вдруг не устраивает крутись как хочешь. У finally с произвольным кодом гибкости всё-таки больше.

_>>2) можно кидать и ловить любую ерунду, с которой потом фиг поймёшь что делать. Вместе с другими зажравшимися программистами из мира интерпретаторов я уже привык к удобному объекту "исключение", с полями, методами, вот этим всем.

J>Все вменяемые разработчики бросают производные от std::exception аж с 98 года.
И тем не менее в том 98-году не сделали это поведение единственно возможным и ключа компилятора --allowNonC98exceptions что бы приучить старообрядцев к порядку.

_>>3) разные команды используют разные базовые классы для исключений, и ни в стандарте ни в популярных либах нету самого главного — стэк трэйса. В результате на разных платформах и в разных компиляторах нужен разный код для сбора стэктрэйса, котрый вроде как нужно вызывать именно в методе где летело само исключение, потом уже поздно. На MSVC точно было именно так, на GCC чуть легче, на Intel не помню.


J>Во-вторых, "вызывать именно в методе, где летело" означает "вызывать в конструкторе исключения" — именно так все и делают (несколько тем на RSDN было об этом) и никакого лишнего кода в "методе, где летело", не появляется — все спрятано в конструкторе.

Всякие AV или Division By Zero уже вызывают правильный конструктор?

J>То ли дело возвращаемые значения. Так и вижу, как из конструктора/деструктора возвращаются коды ошибок

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

J>Как раз исключения в конструкторах гарантируют, что объект не будет создан в кривом состоянии.

J>При этом RAII прибьет то, что успело создаться к моменту вылета исключения.
И как мне помнится всё ляжет если в процессе прибивания что-то пойдёт ещё более не так.

В общем пока все возражения мне видятся такими же как возражения фанатов .NET когда ругаешь косяки их любимой цацки — "никаких проблем нет а если что-то и есть то в языке полно средств выкрутиться, а значит проблемы нет".
Re[22]: Тенденции языков
От: jazzer Россия Skype: enerjazzer
Дата: 25.05.15 10:41
Оценка: 9 (1)
Здравствуйте, hi_octane, Вы писали:

J>>Что значит "надежда на RAII"? Это все равно что "надежда на то, что sin(x) вернет синус, а не косинус"

J>>RAII — это же не финализаторы в управляемых языках, которые хз когда позовутся и позовутся ли вообще.
J>>Тут все гарантировано самим языком, безо всяких надежд.
_>Надежда в основном на то что RAII будет достаточно. Порядок свёртки какбы тоже часть RAII, и если он вдруг не устраивает крутись как хочешь. У finally с произвольным кодом гибкости всё-таки больше.

Это как посмотреть. Во-первых, RAII работает внутри области видимости try, а finally — снаружи, и поэтому никакого доступа к внутренней области видимости не имеет. Как следствие, все надо вытащить за пределы try — гемор номер раз.
Отсюда сразу вытекает гемор номер два — далеко не все объекты разрешают копирование и/или отложенное конструирование.
Ну и гемор номер три — ты не знаешь внутри finally, что именно отвалилось, и что надо чистить, а что — нет. Так что придется придумывать всякие левые флаги и прочие обходные костыли.
С RAII же у тебя, во-первых, все оказывается внутри try (да и самого try обычно нет, кстати), во-вторых, сработают только те откатные RAII, которые успели сконструироваться к этому моменту — все, что ниже, срабатывать не будет.

J>>Все вменяемые разработчики бросают производные от std::exception аж с 98 года.

_>И тем не менее в том 98-году не сделали это поведение единственно возможным и ключа компилятора --allowNonC98exceptions что бы приучить старообрядцев к порядку.

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

_>Всякие AV или Division By Zero уже вызывают правильный конструктор?


Всякие AV или Division By Zero находятся за пределами языка, это UB.

J>>То ли дело возвращаемые значения. Так и вижу, как из конструктора/деструктора возвращаются коды ошибок

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

Как именно лучше? Критикуя — предлагай.

J>>Как раз исключения в конструкторах гарантируют, что объект не будет создан в кривом состоянии.

J>>При этом RAII прибьет то, что успело создаться к моменту вылета исключения.
_>И как мне помнится всё ляжет если в процессе прибивания что-то пойдёт ещё более не так.

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

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


Я пока не вижу реальных возражений, кроме того, что нет стандартизированного базового типа исключения.
Вернее, он есть, но нет запрета им не пользоваться.
finally мне скорее не нравится, чем нравится — я считаю RAII гораздо более удобной вещью, чем finally (см. выше).
jazzer (Skype: enerjazzer) Ночная тема для RSDN
Автор: jazzer
Дата: 26.11.09

You will always get what you always got
  If you always do  what you always did
Re[24]: Тенденции языков
От: Evgeny.Panasyuk Россия  
Дата: 25.05.15 11:04
Оценка:
Здравствуйте, Sinclair, Вы писали:

J>>Каким образом? Или речь прерывании потока каким-нибудь хакерством за пределами языка, типа KillThread какой-нибудь? Ну тогда да, против лома нет приема.

S>А что у вас вместо лома?

Например cancellation points раскручивающие стэк.

S>В managed environment даже при аборте потока есть шанс отработать хэндлеры


А что с finally?

S>и прибрать за собой ресурсы.


В недетерминированном порядке? Да ещё и в другом потоке.
Отредактировано 25.05.2015 11:19 Evgeny.Panasyuk . Предыдущая версия . Еще …
Отредактировано 25.05.2015 11:18 Evgeny.Panasyuk . Предыдущая версия .
Отредактировано 25.05.2015 11:16 Evgeny.Panasyuk . Предыдущая версия .
Re[16]: Тенденции языков
От: antropolog  
Дата: 26.05.15 00:42
Оценка: +1
Здравствуйте, Mamut, Вы писали:


M> % игнорируем ошибки

M> catch fly_out_menu:append_item(panel_flyout_menu, "First Item"),
M> catch fly_out_menu:append_item(panel_flyout_menu, "Third Item"),
M> catch fly_out_menu:append_item(panel_flyout_menu, "Second Item"),
M> catch fly_out_menu:append_item(panel_flyout_menu, separator),

согласен, в ерланге сделано по-человечески, но это не отменяет уродского синтаксиса в мейнстрим языках, и конечно не отменяет провоцирование невалидного стейта в принципе.
Re[20]: Тенденции языков
От: antropolog  
Дата: 26.05.15 00:42
Оценка:
Здравствуйте, MTD, Вы писали:

MTD>И где здесь логика на исключениях?


покажи код
Re[16]: Тенденции языков
От: antropolog  
Дата: 26.05.15 00:48
Оценка: :))
Здравствуйте, MTD, Вы писали:


MTD>Исключения — это исключительные ситуации игнорирование которых делает дальнейшую работу бессмысленной, это если ты вдруг не в курсе.

капитан, капитан, улыбнитесь

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

смешные как раз вы, ты так и не привёл отчего-то рефакторинг "говнокода от adobe" с исключениями. а всё потому что это будет ещё больший говнокод. Вот mamut привёл, молодец, трудно спорить, в эрланге работа с исключениями удобна. В .NET/Java и тем более в C++ — нет.

а ты милок так и не понял, что я тебе хотел показать в примере. А хотел я тебе показать то — что любой вызов метода — потенциально бросает исключение, поэтому любое действие должно быть транзакционно. И с кодом ошибок всё очевидно — где return, надо зачекать состояние логики. Это можно прочекать просто глядя на код. Теперь полюбуйся на свой собственный код и скажи, а тебе тоже Гэндальф зарплату платит?
Re[20]: Тенденции языков
От: antropolog  
Дата: 26.05.15 00:50
Оценка:
Здравствуйте, MTD, Вы писали:

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


A>>бросать исключение.


MTD>Не понял, ты же кричал, что код с исключениями — УГ по определению.


да, ты же не слушаешь собеседника, и не понимаешь, что кто-то УЖЕ УМЕЕТ НЕ ИСПОЛЬЗОВАТЬ исключения, надеюсь ты дойдёшь когда-нибудь до этого уровня понимания. И да, я использую исключения там, где в коде нарушается утверждение, т.к. альтернатива этому только одна — завершение работы приложения.
Re[21]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 26.05.15 04:26
Оценка: -1
Здравствуйте, antropolog, Вы писали:

MTD>>И где здесь логика на исключениях?


A>покажи код


Ты как себя чувствуешь? Как из моих слов про то, что у итератора удобно иметь 2 метода вместо 1, ты сделал вывод про логику на исключениях? Давай поделись, как твой интеллект к такому выводу пришел, для этого мне показывать какой-то код совершенно лишнее.
Re[21]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 26.05.15 04:30
Оценка:
Здравствуйте, antropolog, Вы писали:

MTD>>Не понял, ты же кричал, что код с исключениями — УГ по определению.


A>да, ты же не слушаешь собеседника


Нет, я слушаю:

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


http://rsdn.ru/forum/philosophy/6056981.1
Автор: antropolog
Дата: 23.05.15


P.S. Далее по тексту — хватит уже демонстрировать детские обиды с попытками унылых оскорблений.
Re[17]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 26.05.15 04:38
Оценка:
Здравствуйте, antropolog, Вы писали:

A>смешные как раз вы, ты так и не привёл отчего-то рефакторинг "говнокода от adobe" с исключениями.


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

A>Вот mamut привёл, молодец, трудно спорить, в эрланге работа с исключениями удобна. В .NET/Java и тем более в C++ — нет.


Увы, с кодами еще хуже.

A>А хотел я тебе показать то — что любой вызов метода — потенциально бросает исключение, поэтому любое действие должно быть транзакционно.


Ну так я тебе и показал, что код ошибки никак это не решает.

A>И с кодом ошибок всё очевидно — где return, надо зачекать состояние логики.


То есть везде.

A>Теперь полюбуйся на свой собственный код и скажи, а тебе тоже Гэндальф зарплату платит?


У меня все отлично, где транзакционность нужна, она там есть.
Re[15]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 26.05.15 05:29
Оценка: 14 (3)
Здравствуйте, antropolog, Вы писали:

A>отличный код. супер. реально. теперь попробуй его переделать на исключения. могу дать подсказку, в одних случаях наличие error ведёт сразу к возврату из функции ( это легко заменить на единственный try/catch ), а в других ( примерно с середины твоего кода ) error в некоторых случаях игнорируется, например здесь:

Да, на этот баг указали сразу. Просто терпения писать if(error) после каждой строчки не хватило, поэтому мы имеем код, который иногда добавляет элементы, а иногда — нет.
Точнее, программист решил, что в реальности эти методы "небросающие", т.к. там нечему ломаться. Через десять лет, когда реализацию AppendItem изменят, его наследников ждёт большой сюрприз.

A>здесь любая строка может не отработать, но это игнорируется.

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

A>Покажи теперь как это (это — весь твой код ) будет на исключениях, аххахаха (зловещий хохот ).

Действительно — исключения затрудняют написание конкретно этого кода с ошибками. Чтобы проигнорировать ошибку, программист будет вынужден написать try {} catch(...){}.

Но пример действительно показательный — сплошной бойлерплейт.
Я плохо знаком с функциональными языками, но мне кажется очевидным вариант, при котором и бойлерплейта меньше, и с валидностью всё хорошо.
Что мы тут делаем? Конструируем структуру меню.
Пусть каждая функция возвращает либо узел, либо ошибку. И алгебра достаточно тривиальная — объединение (узел & ошибка) даёт ошибку, объединение (узел & узел) даёт узел.
Если мы хотим проигнорировать ошибку, то нам придётся вручную заматчить ошибку и превратить её в void.
Результатом функции, естественно, тоже является либо ошибка либо меню.
Основная фишка исключений — "неявная передача информации о сбое выше по стеку" — будет прекрасно работать и в таком варианте, потому что так устроена алгебра.

Примерный аналог — NaN в операциях с плавающей запятой. Как только у нас где-то в выражении встретился NaN, он сам распространится выше по стеку вплоть до того места, где мы хотим и готовы его обработать.
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[16]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 26.05.15 05:57
Оценка:
Здравствуйте, Sinclair, Вы писали:

S>Но пример действительно показательный — сплошной бойлерплейт.


Бойлерплейта здесь больше с кодами ошибки — все эти if ... return. С исключениями у нас один блок try, если мы что-то здесь можем обработать или вообще его отсутствие. Что касается молчаливого игнорирования — это явная диверсия. Если добавление элемента в меню операция не обязательная, то должнен быть метод добавления элемента в приставкой Try или что-то в этом роде, который будет сам глотать исключения, тогда у нас с одной стороны и писанины мало и сразу видна логика.
Re[17]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 26.05.15 06:32
Оценка:
Здравствуйте, MTD, Вы писали:

MTD>Бойлерплейта здесь больше с кодами ошибки — все эти if ... return. С исключениями у нас один блок try, если мы что-то здесь можем обработать или вообще его отсутствие. Что касается молчаливого игнорирования — это явная диверсия. Если добавление элемента в меню операция не обязательная, то должнен быть метод добавления элемента в приставкой Try или что-то в этом роде, который будет сам глотать исключения, тогда у нас с одной стороны и писанины мало и сразу видна логика.

Да, совершенно верно. Данный конкретный код с исключениями выглядит гораздо чище, плюс он "надёжнее" в том смысле, что если в спорном фрагменте что-то упало, мы всё же узнаем об этом где-то выше по стеку.
Проблема решения с исключениями — в том, что к моменту отлова исключения мы находимся в каком-то непонятном состоянии: меню уже перепахано, какие-то элементы добавлены, какие-то нет.
Решительно непонятно, как же вернуться к стабильному состоянию.
immutable и сборка мусора здесь сильно помогли бы: даже если у нас формирование меню было готово на 99%, и упала какая-то финальная операция, то мы возвращаем ошибку, а вся кунсткамера, "созданная" к этому моменту, как будто никогда и не существовала.
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[17]: Тенденции языков
От: AlexRK  
Дата: 26.05.15 06:51
Оценка:
Здравствуйте, MTD, Вы писали:

S>>Но пример действительно показательный — сплошной бойлерплейт.

MTD>Бойлерплейта здесь больше с кодами ошибки — все эти if ... return. С исключениями у нас один блок try, если мы что-то здесь можем обработать или вообще его отсутствие.

Если говорить о бойлерплейте, то в данном случае он просто из-за говнокода, а не по вине кодов ошибок.
Я уже писал тут: если классы построены грамотно (код ошибки сидит внутри и проверяется по необходимости), или как предложил Sinclair — с возвратом алгебраического типа, то никакого бойлерплейта не будет — будет вызов цепочки методов, как обычно.
Re[16]: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 26.05.15 07:21
Оценка: +1
Здравствуйте, Mamut, Вы писали:

A>>Покажи теперь как это (это — весь твой код ) будет на исключениях


M>
add_to_menu(Item) ->
  try
    fly_out_menu:append_item(panel_flyout_menu, Item)
  catch
    _:Reason -> {error, Reason}
  end.

...


Ага, т.е. исключение первым делом конвертируется в возвращаемое значение вроде растовского Result, и с ним уже дальше вся работа. В Расте будет то же, только без вот этого дополнительного этапа конверсии исключения в Result. Просили код на исключениях, получили код на кодах возврата, по сути.
Re[17]: Тенденции языков
От: MTD https://github.com/mtrempoltsev
Дата: 26.05.15 08:13
Оценка:
Здравствуйте, D. Mon, Вы писали:

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


Да Mamut зачем-то повелся на призыв некоего троля совершать диверсию игнорировать ошибки.
Re[18]: Тенденции языков
От: fddima  
Дата: 26.05.15 08:26
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Если говорить о бойлерплейте, то в данном случае он просто из-за говнокода, а не по вине кодов ошибок.

ARK>Я уже писал тут: если классы построены грамотно (код ошибки сидит внутри и проверяется по необходимости), или как предложил Sinclair — с возвратом алгебраического типа, то никакого бойлерплейта не будет — будет вызов цепочки методов, как обычно.
Никакого говнокода. Код либо будет обрабатывать ошибки — либо нет. С кодами возврата — добавляется лишь только ахеревший рукописный бранчинг на ровном месте и в каждом месте, который ведет преимущественно на выход, как в этом примере. А именно это исключения и дают.

Если класс построен грамотно, — он не будет привносить ненужное состояние к себе внутрь, до тех пор, пока в этом не возникнет реальной необходимости. Какая ошибка внутри класса? Классу то оно зачем? А пользователю класса зачем? Поиметь третюю пару Get(Set)LastError, что б было и было грамотно?

Код разумеется не мой — он отсюда Isolating Microsoft Office Extensions with the COM Shim Wizard Version 2.3, но, теперь, как Мамут, нагло поступил с меню — уже не поступишь. Хотя в принципе, и тут кучу методов можно разложить.

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

// stdafx.h
// Ха-ха. На самом деле после этого - дальше можно не смотреть было бы-то, C++-ники называется. :)
#define IfFailGo(x) { hr=(x); if (FAILED(hr)) goto Error; }
#define IfNullGo(p) { if(!p) {hr = E_FAIL; goto Error; } }


Код:
  Скрытый текст
// CLRLoader.cpp
#include "StdAfx.h"
#include "clrloader.h"
#include "metahost.h"  // CLR 40 hosting interfaces

// When loading assemblies targeting CLR 4.0 and above make sure
// the below line is NOT commented out. It enables starting
// CLR using new hosting interfaces available in CLR 4.0 and above.
// When below line is commeted out the shim will use legacy interfaces 
// which only allow loading CLR 2.0 or below.
#define USE_CLR40_HOSTING

#ifdef USE_CLR40_HOSTING
static LPCWSTR g_wszAssemblyFileName =
    L"MyAddin.dll";
#endif

using namespace mscorlib;

static HRESULT GetDllDirectory(TCHAR *szPath, DWORD nPathBufferSize);


CCLRLoader::CCLRLoader(void)
    : m_pCorRuntimeHost(NULL), m_pAppDomain(NULL)
{
}

// CreateInstance: loads the CLR, creates an AppDomain, and creates an
// aggregated instance of the target managed add-in in that AppDomain.
HRESULT CCLRLoader::CreateAggregatedAddIn(
    IUnknown* pOuter,
    LPCWSTR szAssemblyName,
    LPCWSTR szClassName,
    LPCWSTR szAssemblyConfigName)
{
    HRESULT hr = E_FAIL;

    CComPtr<_ObjectHandle>                              srpObjectHandle;
    CComPtr<ManagedHelpers::IManagedAggregator >        srpManagedAggregator;
    CComPtr<IComAggregator>                             srpComAggregator;
    CComVariant                                         cvarManagedAggregator;

    // Load the CLR, and create an AppDomain for the target assembly.
    IfFailGo( LoadCLR() );
    // DebugBreak();
    IfFailGo( CreateAppDomain(szAssemblyConfigName) );

    // Create the managed aggregator in the target AppDomain, and unwrap it.
    // This component needs to be in a location where fusion will find it, ie
    // either in the GAC or in the same folder as the shim and the add-in.
    IfFailGo( m_pAppDomain->CreateInstance(
        CComBSTR(L"ManagedAggregator, PublicKeyToken=d51fbf4dbc2f7f14"),
        CComBSTR(L"ManagedHelpers.ManagedAggregator"),
        &srpObjectHandle) );
    IfFailGo( srpObjectHandle->Unwrap(&cvarManagedAggregator) );
    IfFailGo( cvarManagedAggregator.pdispVal->QueryInterface(
        &srpManagedAggregator) );

    // Instantiate and aggregate the inner managed add-in into the outer
    // (unmanaged, ConnectProxy) object.
    IfFailGo( pOuter->QueryInterface(
        __uuidof(IComAggregator), (LPVOID*)&srpComAggregator) );
    IfFailGo( srpManagedAggregator->CreateAggregatedInstance(
        CComBSTR(szAssemblyName), CComBSTR(szClassName), srpComAggregator) );

Error:
    return hr;
}

#ifdef USE_CLR40_HOSTING

// Convert "vN.N.N" into an array of numbers
static void ParseClrVersion(LPCWSTR wszVersion, int rgiVersion[3])
{
    rgiVersion[0] = rgiVersion[1] = rgiVersion[2] = 0;

    LPCWCH pwch = wszVersion;
    for (int i = 0; i < 3; i++)
    {
        // skip the firtst character - either 'v' or '.' and add the numbers
        for (pwch++; L'0' <= *pwch && *pwch <= L'9'; pwch++) 
            rgiVersion[i] = rgiVersion[i] * 10 + *pwch - L'0';

        if (*pwch == 0)
            break;

        assert ( *pwch == L'.' && L"we should expect a period. Otherwise it is not a proper CLR version string");
        if (*pwch != L'.')
        {
            // the input is invalid - do not parse any further
            break;
        }
    }
}

// compare order of CLR versions represented as array of numbers
static BOOL IsClrVersionHigher(int rgiVersion[3], int rgiVersion2[3])
{
    for (int i = 0; i < 3; i++)
    {
        if (rgiVersion[i] != rgiVersion2[i])
            return rgiVersion[i] > rgiVersion2[i];
    }

    return FALSE;
}

static HRESULT FindLatestInstalledRuntime(ICLRMetaHost* pMetaHost, LPCWSTR wszMinVersion, ICLRRuntimeInfo** ppRuntimeInfo)
{
    CComPtr<IEnumUnknown> srpEnum;
    CComPtr<ICLRRuntimeInfo> srpRuntimeInfo, srpLatestRuntimeInfo;
    ULONG cFetched;
    WCHAR rgwchVersion[30];
    DWORD cwchVersion;
    int rgiMinVersion[3]; //Major.Minor.Build
    int rgiVersion[3]; // Major.Minor.Build
    HRESULT hr = S_OK;

    *ppRuntimeInfo = NULL;

    // convert vN.N.N into an array of numbers
    ParseClrVersion(wszMinVersion, rgiMinVersion);

    IfFailGo( pMetaHost->EnumerateInstalledRuntimes(&srpEnum) );
    while (true)
    {
        srpRuntimeInfo.Release();
        IfFailGo( srpEnum->Next(1, (IUnknown**)&srpRuntimeInfo, &cFetched) );
        if (hr == S_FALSE)
            break;

        cwchVersion = ARRAYSIZE(rgwchVersion);
        IfFailGo( srpRuntimeInfo->GetVersionString(rgwchVersion, &cwchVersion) );

        ParseClrVersion(rgwchVersion, rgiVersion);
        if (IsClrVersionHigher(rgiVersion, rgiMinVersion) == FALSE)
            continue;

        rgiMinVersion[0] = rgiVersion[0];
        rgiMinVersion[1] = rgiVersion[1];
        rgiMinVersion[2] = rgiVersion[2];

        srpLatestRuntimeInfo.Attach(srpRuntimeInfo.Detach());
    }

    if (srpLatestRuntimeInfo == NULL)
    {
        hr = E_FAIL;
        goto Error;
    }

    hr = S_OK;
    *ppRuntimeInfo = srpLatestRuntimeInfo.Detach();

Error:
    return hr;
}

static HRESULT BindToCLR4OrAbove(ICorRuntimeHost** ppCorRuntimeHost)
{
    HRESULT hr;
    CComPtr<ICLRMetaHost> srpMetaHost;
    CComPtr<ICLRRuntimeInfo> srpRuntimeInfo;
    WCHAR rgwchPath[MAX_PATH + 1];
    WCHAR rgwchVersion[30];
    DWORD cwchVersion = ARRAYSIZE(rgwchVersion);

    *ppCorRuntimeHost = NULL;

    IfFailGo( CLRCreateInstance(CLSID_CLRMetaHost, IID_ICLRMetaHost, (void**)&srpMetaHost) );

    // Get the location of the hosting shim DLL, and retrieve the required
    // CLR runtime version from its metadata
    IfFailGo( GetDllDirectory(rgwchPath, ARRAYSIZE(rgwchPath)) );
    if (!PathAppend(rgwchPath, g_wszAssemblyFileName))
    {
        hr = E_UNEXPECTED;
        goto Error;
    }
    IfFailGo( srpMetaHost->GetVersionFromFile(rgwchPath, rgwchVersion, &cwchVersion) );

    // First try binding to the same version of CLR the add-in is built against
    hr = srpMetaHost->GetRuntime(rgwchVersion, IID_ICLRRuntimeInfo, (void**)&srpRuntimeInfo);
    if (FAILED(hr))
    {
        // If we're here - it means the exact same version of the CLR we built against is not available.
        // In this case we will just load the highest compatible version
        srpRuntimeInfo.Release();
        IfFailGo( FindLatestInstalledRuntime(srpMetaHost, rgwchVersion, &srpRuntimeInfo) );
    }

    // we ignore the result of SetDefaultStartupFlags - this is not critical operation
    srpRuntimeInfo->SetDefaultStartupFlags(STARTUP_LOADER_OPTIMIZATION_MULTI_DOMAIN_HOST, NULL);

    IfFailGo( srpRuntimeInfo->GetInterface(CLSID_CorRuntimeHost, IID_ICorRuntimeHost, (void**)ppCorRuntimeHost) );

Error:
    return hr;
}

#endif

// LoadCLR: loads and starts the .NET CLR.
HRESULT CCLRLoader::LoadCLR()
{
    HRESULT hr = S_OK;

    // Ensure the CLR is only loaded once.
    if (m_pCorRuntimeHost != NULL)
    {
        return hr;
    }

#ifdef USE_CLR40_HOSTING
    hr = BindToCLR4OrAbove(&m_pCorRuntimeHost);
#else

#pragma warning( push )
#pragma warning( disable : 4996 )
    // Load the CLR into the process, using the default (latest) version,
    // the default ("wks") flavor, and default (single) domain.
    hr = CorBindToRuntimeEx(
        NULL, NULL, STARTUP_LOADER_OPTIMIZATION_MULTI_DOMAIN_HOST,
        CLSID_CorRuntimeHost, IID_ICorRuntimeHost,
        (LPVOID*)&m_pCorRuntimeHost);
#pragma warning( pop )

#endif

    // If CorBindToRuntimeEx returned a failure HRESULT, we failed to
    // load the CLR.
    if (FAILED(hr))
    {
        return hr;
    }

    // Start the CLR.
    return m_pCorRuntimeHost->Start();
}

// In order to securely load an assembly, its fully qualified strong name
// and not the filename must be used. To do that, the target AppDomain's
// base directory needs to point to the directory where the assembly is.
HRESULT CCLRLoader::CreateAppDomain(LPCWSTR szAssemblyConfigName)
{
    USES_CONVERSION;
    HRESULT hr = S_OK;

    // Ensure the AppDomain is created only once.
    if (m_pAppDomain != NULL)
    {
        return hr;
    }

    CComPtr<IUnknown> pUnkDomainSetup;
    CComPtr<IAppDomainSetup> pDomainSetup;
    CComPtr<IUnknown> pUnkAppDomain;
    TCHAR szDirectory[MAX_PATH + 1];
    TCHAR szAssemblyConfigPath[MAX_PATH + 1];
    CComBSTR cbstrAssemblyConfigPath;

    // Create an AppDomainSetup with the base directory pointing to the
    // location of the managed DLL. We assume that the target assembly
    // is located in the same directory.
    IfFailGo( m_pCorRuntimeHost->CreateDomainSetup(&pUnkDomainSetup) );
    IfFailGo( pUnkDomainSetup->QueryInterface(
        __uuidof(pDomainSetup), (LPVOID*)&pDomainSetup) );

    // Get the location of the hosting shim DLL, and configure the
    // AppDomain to search for assemblies in this location.
    IfFailGo( GetDllDirectory(
        szDirectory, sizeof(szDirectory)/sizeof(szDirectory[0])) );
    pDomainSetup->put_ApplicationBase(CComBSTR(szDirectory));

    // Set the AppDomain to use a local DLL config if there is one.
    IfFailGo( StringCchCopy(
        szAssemblyConfigPath,
        sizeof(szAssemblyConfigPath)/sizeof(szAssemblyConfigPath[0]),
        szDirectory) );
    if (!PathAppend(szAssemblyConfigPath, szAssemblyConfigName))
    {
        hr = E_UNEXPECTED;
        goto Error;
    }
    IfFailGo( cbstrAssemblyConfigPath.Append(szAssemblyConfigPath) );
    IfFailGo( pDomainSetup->put_ConfigurationFile(cbstrAssemblyConfigPath) );

    // Create an AppDomain that will run the managed assembly, and get the
    // AppDomain's _AppDomain pointer from its IUnknown pointer.
    IfFailGo( m_pCorRuntimeHost->CreateDomainEx(T2W(szDirectory),
        pUnkDomainSetup, 0, &pUnkAppDomain) );
    IfFailGo( pUnkAppDomain->QueryInterface(
        __uuidof(m_pAppDomain), (LPVOID*)&m_pAppDomain) );

Error:
   return hr;
}

// GetDllDirectory: gets the directory location of the DLL containing this
// code - that is, the shim DLL. The target add-in DLL will also be in this
// directory.
static HRESULT GetDllDirectory(TCHAR *szPath, DWORD nPathBufferSize)
{
    // Get the shim DLL module instance, or bail.
    HMODULE hInstance = _AtlBaseModule.GetModuleInstance();
    if (hInstance == 0)
    {
        return E_FAIL;
    }

    // Get the shim DLL filename, or bail.
    TCHAR szModule[MAX_PATH + 1];
    DWORD dwFLen = ::GetModuleFileName(hInstance, szModule, MAX_PATH);
    if (dwFLen == 0)
    {
        return E_FAIL;
    }

    // Get the full path to the shim DLL, or bail.
    TCHAR *pszFileName;
    dwFLen = ::GetFullPathName(
        szModule, nPathBufferSize, szPath, &pszFileName);
    if (dwFLen == 0 || dwFLen >= nPathBufferSize)
    {
        return E_FAIL;
    }

    *pszFileName = 0;
    return S_OK;
}

// Unload the AppDomain. This will be called by the ConnectProxy
// in OnDisconnection.
HRESULT CCLRLoader::Unload(void)
{
    HRESULT hr = S_OK;
    IUnknown* pUnkDomain = NULL;
    IfFailGo(m_pAppDomain->QueryInterface(
        __uuidof(IUnknown), (LPVOID*)&pUnkDomain));
    hr = m_pCorRuntimeHost->UnloadDomain(pUnkDomain);

    // Added in 2.0.2.0, only for Add-ins.
    m_pAppDomain->Release();
    m_pAppDomain = NULL;

Error:
    if (pUnkDomain != NULL)
    {
        pUnkDomain->Release();
    }
    return hr;
}

CCLRLoader::~CCLRLoader(void)
{
    if (m_pAppDomain)
    {
        m_pAppDomain->Release();
    }
    if (m_pCorRuntimeHost)
    {
        m_pCorRuntimeHost->Release();
    }
}
... << RSDN@Home 1.0.0 alpha 5 rev. 0>>
Re[18]: Тенденции языков
От: Evgeny.Panasyuk Россия  
Дата: 26.05.15 15:25
Оценка: +1
Здравствуйте, Sinclair, Вы писали:

S>Решительно непонятно, как же вернуться к стабильному состоянию.

S>immutable

А как бы оно здесь помогло? У нас здесь изначально не-immutable API, которое скорей всего под капотом ещё и дёргает императивные системные вызовы.

S>и сборка мусора здесь сильно помогли бы: даже если у нас формирование меню было готово на 99%, и упала какая-то финальная операция, то мы возвращаем ошибку, а вся кунсткамера, "созданная" к этому моменту, как будто никогда и не существовала.


Сборка мусора более-менее подходит только для памяти, для остальных ресурсов не очень — именно поэтому во многих языках появляются конструкции для scope-based lifetime managmenet, а-ля using в C#, try-with-resources в Java, и with в Python, правда им всем до полноценного RAII далеко.
Re[16]: Тенденции языков
От: Evgeny.Panasyuk Россия  
Дата: 26.05.15 15:56
Оценка:
Здравствуйте, Sinclair, Вы писали:

S>Я плохо знаком с функциональными языками, но мне кажется очевидным вариант, при котором и бойлерплейта меньше, и с валидностью всё хорошо.

S>Что мы тут делаем? Конструируем структуру меню.
S>Пусть каждая функция возвращает либо узел, либо ошибку. И алгебра достаточно тривиальная — объединение (узел & ошибка) даёт ошибку, объединение (узел & узел) даёт узел.

Оно там именно так и устроенно — монада Exceptional:
Exception l   >>=   _             =  Exception l
Success  r    >>=   k             =  k r

По сути — те же самые исключения. Особенность в том, что функции для того чтобы "выбросить" исключение нужно менять сигнатуру.

S>Если мы хотим проигнорировать ошибку, то нам придётся вручную заматчить ошибку и превратить её в void.


Тот же try-catch{no-op} вид сбоку.
Re[18]: Тенденции языков
От: vdimas Россия  
Дата: 28.05.15 19:00
Оценка: -3
Здравствуйте, MTD, Вы писали:

MTD>На практике это неудобно, например, я не хочу сдвигать итератор, просто хочу проверить, что есть куда сдвигать.


А он и не сдвигается, если сдвигать некуда.


MTD>А MoveNext невалидному итератору? Ты уверен, что стоит так замаскировать баг?


Нет никакого бага. Итератор находится в своём финишном состоянии, куда он перешел от последнего вызова MoveNext. Последующие вызовы MoveNext ничего не делают.
Re[24]: Тенденции языков
От: vdimas Россия  
Дата: 28.05.15 19:08
Оценка:
Здравствуйте, Sinclair, Вы писали:

S>Фантазии оставьте. Даже если вы сумеете найти хэндл GC-потока и прибить, то среда просто перезапустит его.


"Кто-то" должен перезапустить поток, а этот "кто-то" остановлен.
А найти хендл потока — проще простого, просто перебрать потоки и найти те, которые не текущий (и не были созданы в ходе работы программы).

Да и вообще — это всё спекуляции. В С++ нет способа убить поток, это делается через системный АПИ, через который можно поломать вообще что угодно при должном усердии.
Re[24]: Тенденции языков
От: vdimas Россия  
Дата: 28.05.15 19:40
Оценка:
Здравствуйте, Sinclair, Вы писали:

S>Фантазии оставьте. Даже если вы сумеете найти хэндл GC-потока и прибить, то среда просто перезапустит его.


Ну и еще вырезки отсюда:
https://msdn.microsoft.com/en-us/library/windows/desktop/ms686717(v=vs.85).aspx

If the target thread owns a critical section, the critical section will not be released.
If the target thread is allocating memory from the heap, the heap lock will not be released.
If the target thread is executing certain kernel32 calls when it is terminated, the kernel32 state for the thread's process could be inconsistent.
If the target thread is manipulating the global state of a shared DLL, the state of the DLL could be destroyed, affecting other users of the DLL.


Таким образом, через TerminateThread можно поломать что угодно.

Но можно попробовать от этого защититься:

A thread cannot protect itself against TerminateThread, other than by controlling access to its handles. The thread handle returned by the CreateThread and CreateProcess functions has THREAD_TERMINATE access, so any caller holding one of these handles can terminate your thread.


Итого, для создания потока можно использовать некий хелпер, который вызовет CreateThread с неким security descriptor, в котором запретит THREAD_TERMINATE access, ну или через DuplicateHandle создаст другой дескриптор с ограниченными правами, а старый прибьет..
Re[25]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 29.05.15 03:37
Оценка:
Здравствуйте, vdimas, Вы писали:

V>Таким образом, через TerminateThread можно поломать что угодно.

А через Thread.Abort — нет. В С++, как верно замечено, стыдливо игнорируют наличие потоков, поэтому нет выбора кроме адски небезопасных механизмов ОС.
В управляемой среде есть штатный способ прибить поток (хотя его использование и является порочной практикой)
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[26]: Тенденции языков
От: Evgeny.Panasyuk Россия  
Дата: 29.05.15 05:53
Оценка:
Здравствуйте, Sinclair, Вы писали:

V>>Таким образом, через TerminateThread можно поломать что угодно.

S>А через Thread.Abort — нет.

Он может выкинуть исключение откуда угодно? Или только из обозначенных мест?

S>В С++, как верно замечено, стыдливо игнорируют наличие потоков, поэтому нет выбора кроме адски небезопасных механизмов ОС.


Я же уже выше сказал, что используются cancellation points раскручивающие стэк
Re[27]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 29.05.15 12:06
Оценка:
Здравствуйте, Evgeny.Panasyuk, Вы писали:

EP>Он может выкинуть исключение откуда угодно? Или только из обозначенных мест?

Откуда угодно. Но при этом поток не умирает сразу — в нём отрабатывают секции finally и хэндлеры исключений.


EP>Я же уже выше сказал, что используются cancellation points раскручивающие стэк

Я не знаком с этим термином. Можно посмотреть на его описание?
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[28]: Тенденции языков
От: Evgeny.Panasyuk Россия  
Дата: 29.05.15 20:40
Оценка:
Здравствуйте, Sinclair, Вы писали:

EP>>Он может выкинуть исключение откуда угодно? Или только из обозначенных мест?

S>Откуда угодно.

Очень хрупкая концепция — получается что no-throw кода нет в принципе, что в некоторых случаях сильно затрудняет реализацию транзакционных операций.
Надеюсь оно хоть не выкидывает новое исключение при повтором Thread.Abort в случае когда первое поймано или при выполнении finally/dispose?

S>Но при этом поток не умирает сразу в нём отрабатывают секции finally и хэндлеры исключений.


Это само собой.

EP>>Я же уже выше сказал, что используются cancellation points раскручивающие стэк

S>Я не знаком с этим термином. Можно посмотреть на его описание?

Точки из которых может вылететь thread cancelation exception задаются явным образом.

Например:
https://msdn.microsoft.com/en-us/library/hh749984.aspx
https://msdn.microsoft.com/en-us/library/dd984117.aspx

В итоге получаем и раскрутку стэка с очисткой ресурсов и гарантию no-throw там где она потребуется.
Re[26]: Тенденции языков
От: vdimas Россия  
Дата: 30.05.15 09:16
Оценка:
Здравствуйте, Sinclair, Вы писали:

V>>Таким образом, через TerminateThread можно поломать что угодно.

S>А через Thread.Abort — нет. В С++, как верно замечено, стыдливо игнорируют наличие потоков,

Начиная со стандарта C++11 — все ОК.

S>поэтому нет выбора кроме адски небезопасных механизмов ОС.


Почему "нет выбора"?
Для MSVC есть CRT _beginthread/_beginthreadex, в мире Linux есть библиотека pthread. Ср-ва этих библиотек являются безопасными.


S>В управляемой среде есть штатный способ прибить поток (хотя его использование и является порочной практикой)


А кто мешает вызвать TerminateThread через p-Invoke?

Ну я напомню, что этот "штатный способ" на самом деле — лишь библиотечная хрень, которая реализована даже в boost.
Например, в Linux потоку посылается signal, и при заходе в любое ядерное АПИ вызывается этот сигнал в контексте потока.
В Windows есть аналогичный способ прервать состояние ожидания на другом потоке — через APC.

А дотнетная среда может безопасно прибивать потоки только в "ловушках" для GC, коих нет, например, в коде 10 GOTO 10. Этот случай можно прибить только через TerminateThread и я предполагаю, что после попыток "безопасного" прибивания потока и безуспешного ожидания в течении некоторого времени, дотнетная среда обязательно должна пытаться сделать "опасное" прибивание той самой ситуации 10 GOTO 10. И еще я думаю, что при этом не гарантируется безопасность — вдруг именно в этот самый момент будет вызвано системное АПИ? ))
Re: Тенденции языков
От: s22  
Дата: 05.06.15 19:14
Оценка: :)
Здравствуйте, s22, Вы писали:

Вот и автор ZeroMQ решил, что эта сложность только мешает, и разработчики Rust с ним согласны. У нас нет исключений, а потенциальные ошибки являются частью возвращаемых (алгебраических) типов:
http://250bpm.com/blog:4
Re[2]: Тенденции языков
От: Evgeny.Panasyuk Россия  
Дата: 05.06.15 19:29
Оценка: +6
Здравствуйте, s22, Вы писали:

s22>У нас нет исключений, а потенциальные ошибки являются частью возвращаемых (алгебраических) типов:


Тоже вариант (в C++ есть подобный proposal — expected), но в случае если функция не возвращает значение не особо подходит.

s22>http://250bpm.com/blog:4


А вот это

However, consider what happens when there are two different errors thrown in the same function:

class exception1 {};
class exception2 {};

try {
    ...
    if (condition1)
        throw my_exception1 ();
    ...
    if (condition2)
        throw my_exception2 ();
    ...
}
catch (my_exception1 &e) {
    handle_exception1 ();
}
catch (my_exception2 &e) {
    handle_exception2 ();
}

Compare that to its C equivalent:
...
if (condition1)
   handle_exception1 ();
...
if (condition2)
   handle_exception2 ();
...

It's far more readable and — as a bonus — compiler is likely to produce more efficient code.

И далее всё в таком духе
Re[16]: Тенденции языков
От: vdimas Россия  
Дата: 10.06.15 19:42
Оценка:
Здравствуйте, Mamut, Вы писали:

M>Ничем не отличается от exception'ов Пример кода из самого Раста я приводил. Там пятиуровневая конструкция, из недр которой наверх возвращается некий ErrorReport. Чем он отличается от самодельного ThrownExceptionsCollection? Да ничем


Тебя коллега вводит в заблуждение. Для примера, дотнетный библиотечный Task.WhenAll в дотнете вернет первую же ошибку, если она возникла у любой из ожидаемых асинхронных задач:
https://msdn.microsoft.com/en-us/library/hh160384(v=vs.110).aspx

If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.
If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.
If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state.


Т.е. всё уже есть. В том или ином виде аналогичный WhenAll есть практически во всех фреймворках, оперирующих future/task/deferred.
Re[17]: Тенденции языков
От: Sinclair Россия https://github.com/evilguest/
Дата: 11.06.15 06:15
Оценка:
Здравствуйте, vdimas, Вы писали:

V>Тебя коллега вводит в заблуждение. Для примера, дотнетный библиотечный Task.WhenAll в дотнете вернет первую же ошибку, если она возникла у любой из ожидаемых асинхронных задач:

V>https://msdn.microsoft.com/en-us/library/hh160384(v=vs.110).aspx
V>

V>If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.
V>If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.
V>If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state.

Цитата опровергает ваше утверждение. Но речь не об этом, а о том, что каждое такое решение надо велосипедить заново, никаких готовых механизмов для этого нет.
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[3]: Тенденции языков
От: AlexRK  
Дата: 11.06.15 07:09
Оценка:
Здравствуйте, Evgeny.Panasyuk, Вы писали:

EP>И далее всё в таком духе


А что еще, например, "в таком духе"?

Это вот что — неправда?

Consider the case when the exception is not handled in the function that raises it. In such case the handling of the error can happen anywhere, depending on where the function is called from.

While the possibility to handle the exceptions differently in different contexts may seem appealing at the first sight, it quickly turns into a nightmare.


Просто у него приложение такое, что ошибки надо обрабатывать близко к месту возникновения, а не просто кидать куда-то в самый верх и писать там в лог.
Об этом он тоже, кстати, пишет.
Re[4]: Тенденции языков
От: Evgeny.Panasyuk Россия  
Дата: 11.06.15 09:37
Оценка: +6
Здравствуйте, AlexRK, Вы писали:

EP>>И далее всё в таком духе

ARK>А что еще, например, "в таком духе"?

Например вот это:

With C, the raising of the error and handling it are tightly couped and reside at the same place in the source code. This makes it easy to understand what happens if error happens:

int rc = fx ();
if (rc != 0)
    handle_error ();

With C++ you just throw the error. What happens then is not at all obvious:
int rc = fx ();
if (rc != 0)
    throw std::exception ();

The problem with that is that you have no idea of who and where is going to handle the exception.



ARK>Это вот что — неправда?

ARK>

Consider the case when the exception is not handled in the function that raises it. In such case the handling of the error can happen anywhere, depending on where the function is called from.
ARK>While the possibility to handle the exceptions differently in different contexts may seem appealing at the first sight, it quickly turns into a nightmare.


Это демагогия и передёргивание. При return error_code; — получаем ровно тоже самое "handling of the error can happen anywhere", только с на порядок большим колличеством boilerplatе'а типа ручных цепочек goto cleaunpN; на всём пути от места исключения до обработчика
Если же обработка ошибки происходит сразу же — то никаких исключений кидать не надо, также как не надо фигурно вырезать goto cleaunpN;.
Re[6]: Тенденции языков
От: Vain Россия google.ru
Дата: 12.06.15 11:14
Оценка:
Здравствуйте, VladD2, Вы писали:

s22>>в инете много про это....

s22>>часто компиляторы не инлайнят код, если во вложенной функции есть вызов исключения.
VD>Это проблемы не исключений, а С++ и его компиляторов. И не смотря на эти проблемы С++ считается одним из самых "быстрых" языков (т.е. его компиляторы порождают самый быстрый код).
Чтобы нормально ловить и обрабатывать исключения приходится их перебрасывать (т.н. трюк с rethrow) либо в макросе (чтобы гарантировать что макрос вставили в конце цепочки catch'ей) либо в функции (для эстетов, но также с переброской). Это приводит к "испарению" преимущества по производительности исключений по сравнению с кодами возвратов.
А теперь расскажи нам какой компилятор сможет перебрасывать исключения без потери производительности?
[In theory there is no difference between theory and practice. In
practice there is.]
[Даю очевидные ответы на риторические вопросы]
Re[7]: Тенденции языков
От: Ops Россия  
Дата: 16.06.15 22:09
Оценка: +2
Здравствуйте, Vain, Вы писали:

V>Чтобы нормально ловить и обрабатывать исключения приходится их перебрасывать (т.н. трюк с rethrow) либо в макросе (чтобы гарантировать что макрос вставили в конце цепочки catch'ей) либо в функции (для эстетов, но также с переброской). Это приводит к "испарению" преимущества по производительности исключений по сравнению с кодами возвратов.

V>А теперь расскажи нам какой компилятор сможет перебрасывать исключения без потери производительности?
Уж сколько раз твердили миру... Исключения — они вылетают в _исключительных_ ситуациях, которые случаются _редко_. И в этом случае мы имеем высокую производительность пока их не происходит. Если же их использовать как goto, то конечно, про производительность можно забыть.
Ну вот есть функция, которая возвращает да/нет, и в зависимости от результата идет ветвление. Глупо было бы это делать на исключениях. А вот если по какой-то причине (нехватка ресурсов, поврежденные данные, и т.п.) она не может вернуть корректный результат, то можно и бросить.
Переубедить Вас, к сожалению, мне не удастся, поэтому сразу перейду к оскорблениям.
Re[8]: Тенденции языков
От: s22  
Дата: 21.06.15 13:13
Оценка:
Здравствуйте, Ops, Вы писали:

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


V>>Чтобы нормально ловить и обрабатывать исключения приходится их перебрасывать (т.н. трюк с rethrow) либо в макросе (чтобы гарантировать что макрос вставили в конце цепочки catch'ей) либо в функции (для эстетов, но также с переброской). Это приводит к "испарению" преимущества по производительности исключений по сравнению с кодами возвратов.

V>>А теперь расскажи нам какой компилятор сможет перебрасывать исключения без потери производительности?
Ops>Уж сколько раз твердили миру... Исключения — они вылетают в _исключительных_ ситуациях, которые случаются _редко_. И в этом случае мы имеем высокую производительность пока их не происходит. Если же их использовать как goto, то конечно, про производительность можно забыть.
Ops>Ну вот есть функция, которая возвращает да/нет, и в зависимости от результата идет ветвление. Глупо было бы это делать на исключениях. А вот если по какой-то причине (нехватка ресурсов, поврежденные данные, и т.п.) она не может вернуть корректный результат, то можно и бросить.

goto выполняется 0 тактов
так же как и условный переход, если он правильно предсказан.
Re[9]: Тенденции языков
От: Ops Россия  
Дата: 21.06.15 17:16
Оценка:
Здравствуйте, s22, Вы писали:

s22>goto выполняется 0 тактов

s22>так же как и условный переход, если он правильно предсказан.

И? Не вижу противоречий с тем, что я написал.
Переубедить Вас, к сожалению, мне не удастся, поэтому сразу перейду к оскорблениям.
Re[10]: Тенденции языков
От: s22  
Дата: 22.06.15 04:28
Оценка:
Здравствуйте, Ops, Вы писали:

Ops>Уж сколько раз твердили миру... Исключения — они вылетают в _исключительных_ ситуациях, которые случаются _редко_. И в этом случае мы имеем высокую производительность пока их не происходит. Если же их использовать как goto, то конечно, про производительность можно забыть.


Код с исключениями медленнее кода без исключений.... из за проблем с инлайнингом, это существенно на уровне оптимизации 2 или 3.
Отредактировано 22.06.2015 4:38 kaa.python . Предыдущая версия .
Re: Тенденции языков
От: D. Mon Великобритания http://thedeemon.livejournal.com
Дата: 16.07.15 15:57
Оценка: 39 (3)
Здравствуйте, s22, Вы писали:

s22>Смотрю на новые компилируемые языки вижу следующие вещи:

s22>1. Отказ от исключений
s22>Rust,Swift и т д

Расходимся, в Swift уже добавили исключения:
http://austinzheng.com/2015/06/08/swift-2-control-flow/
throw, catch все обыденно.
Re[2]: Тенденции языков
От: AlexRK  
Дата: 16.07.15 16:09
Оценка:
Здравствуйте, D. Mon, Вы писали:

s22>>Смотрю на новые компилируемые языки вижу следующие вещи:

s22>>1. Отказ от исключений
s22>>Rust,Swift и т д

DM>Расходимся, в Swift уже добавили исключения:

DM>http://austinzheng.com/2015/06/08/swift-2-control-flow/
DM>throw, catch все обыденно.

Ну, язык типа "для масс", так что особого удивления не испытываю. Хорошо хоть throws есть и сопутствующий анализ, все ли обработано.
Re[2]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 16.07.15 17:02
Оценка:
DM>Расходимся, в Swift уже добавили исключения:
DM>http://austinzheng.com/2015/06/08/swift-2-control-flow/
DM>throw, catch все обыденно.

Ой, гарды какие интересные Не удивлюсь, если на фоне примера про IPv4 еще и binaries как в Эрланге появятся


dmitriid.comGitHubLinkedIn
Re[2]: Тенденции языков
От: _NN_ www.nemerleweb.com
Дата: 16.07.15 18:27
Оценка: +1
Здравствуйте, D. Mon, Вы писали:

DM>Расходимся, в Swift уже добавили исключения:

DM>http://austinzheng.com/2015/06/08/swift-2-control-flow/
DM>throw, catch все обыденно.

Ждём исключения в Rust
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[3]: Тенденции языков
От: Mamut Швеция http://dmitriid.com
Дата: 16.07.15 20:55
Оценка:
DM>>Расходимся, в Swift уже добавили исключения:
DM>>http://austinzheng.com/2015/06/08/swift-2-control-flow/
DM>>throw, catch все обыденно.

_NN>Ждём исключения в Rust


Они там точно скоро будут, имхо. https://doc.rust-lang.org/std/thread/fn.catch_panic.html Просто в какой-то момент достаточно народа скажет exception'ы — дорога, а такси на каждый чих не дорого?

Я умолчу о том, что им настолько свой же механизм не нравится, что они городят костыли в виде http://doc.rust-lang.org/std/macro.try!.html поверх, лишь бы все по-человечески выглядело.


dmitriid.comGitHubLinkedIn
 
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.