[00:00:08] <vlad2> По-моему получилось довольно жалкое зрелище.
[00:01:02] <vlad2> (я конечно не спец, может посадить ЛА в траву это нихилая задача)
[00:01:34] <vlad2> (просто ожидал большего - после рассказов про ариан-5 :)
[00:03:09] <vаlexey> vlad2: новость - баян.
[00:03:17] <vаlexey> еще летом было известно же. и я про это тут писал
[00:03:25] <vаlexey> Это то ли Брат то ли Брат-2 :-) ДЛНА
[00:03:40] <vаlexey> И да, сами пишут. Я с челом общался на эту тему.
[00:03:48] <vаlexey> То есть это сам производитель.
[00:05:09] <vаlexey> насколько я понимаю, там ничего особо интересного. ну, то есть там нет системы распознования образов и автоматической ориентации ЛА.
[00:05:37] <vlad2> operators.ob почти готов, 6 тестов отсалось валящихся :) Скоро мир увидит настоящий синтаксический оверхед :)
[00:05:44] <vаlexey> просто потому, что там используется что-то вроде ARM7TDMI-S
[00:06:23] <vlad2> А что там тогда есть? Высотомер/датчик набегания/гироскоп и все?
[00:06:57] <vаlexey> ну типа того. нет, камера там тоже есть, но она не для автоматики, а для съемки. + можно издалека этой штукой управлять.
[00:07:12] <vаlexey> Дас. А вот что на плюсах пишут: http://www.youtube.com/watch?v=54-qFLK9ky8
[00:07:14] <vаlexey> :-)
[00:07:43] <vlad2> Да, распознавание образов на О7... Даже не знаю...
[00:08:42] <vаlexey> да не, можно на самом деле. там ничего от языка не требуется в общем то. это ж машинное обучение - там ты собстенно логику распознавания не программишь особо. ты пишешь базу, а затем учишь компутер на подготовленных выборках.
[00:09:07] <vаlexey> (по результатам обучения оно обычно работает, но ты не знаешь как и почему оно работает :-) )
[00:09:35] <vаlexey> другое дело что там нужен действительно оптимизирующий компилятор. сложный.
[00:10:34] <vаlexey> без инлайна функцию например будет тяжко
[00:10:45] <vаlexey> а без структурных литералов - будет убого.
[00:11:35] <vlad2> /me собрал и выдал девелоперам первый билд Xcode5/clang :)
[00:11:40] <vаlexey> А в БРАТе автопилот - для облета по маршруту, и чтобы не свалился (то есть устойчивость чтобы держал)
[00:11:52] <vаlexey> О-о! Поздравлямс!
[00:12:02] <vlad2> Правда попытка включить С++11 тут же обломалась - там определен "свой" nullptr :)
[00:12:10] <vаlexey> гы-ы
[00:12:25] <vlad2> Но это уже не страшно. Это можно инкремантами.
[00:13:03] <vlad2> И таки я попробвал заменить boost::bind на родные люмбды - работает и на виндовом студии тоже. Так что все круто. Еще чуть-чуть :)
[00:13:30] <vаlexey> угу. в студии работает.
[00:13:45] <vаlexey> и в gcc работает (в современном)
[00:13:51] <vаlexey> лямбды они везде теперь работают :-)
[00:14:10] <vаlexey> а вот выйдет c++14, будет вообще ня - лямбды станут обобщенными!
[00:14:10] <vlad2> Надо бы еще буст посовременнее...
[00:14:28] <vlad2> Да, я там сразу же воткнулся в то, что таки типы надо прописывать.
[00:15:02] <vаlexey> будет вообще ня! почти как в хаскелле!
[00:15:32] <vаlexey> (с тем отличием, что в С++ ты сможешь контроллировать оверхеды и детали как оно работает)
[00:16:18] <vаlexey> но синтаксис из за возможности контроля, конечно более тяжеловесный у плюсатых лямбд нежели у хаскельных
[00:17:52] <vаlexey> с лямбдами наконец можно теперь полноценно stl пользоваться!
[00:18:17] <vаlexey> а то по факту stl - это либа для функционального языка. в плюсах оно смотрелось притянутым за уши
[00:33:42] <Jordan> vаlexey Лень на форум писать. Число овер 99999, не должно компилироваться, допустим у того же INTEGER свой диапазон на 32 бит архитектуре.
[00:34:12] <vаlexey> почему не должно? исходя из какого пункта репорта? :-)
[00:34:23] <Jordan> INTEGER оствлен на откуп компиляторопесателя.
[00:34:23] <vlad2> Jordan: да, не должно. Это я схалявил на парсинге - заиспользовав js aeyrwb./
[00:34:25] <vаlexey> ну, и до кучи, где в репорте сказано что INTEGER он 32битный? :-)
[00:34:47] <Jordan> Ну разумный предел же должен быть?
[00:35:09] <vаlexey> на самом деле нужно различать - рантайм вычисления (делаются на target-машине) и компайл-тайм вычисления -- эти делаются на машине где оно компиляется
[00:35:22] <vаlexey> Jordan: совсем не факт. INTEGER может быть безразмерным.
[00:35:47] <vаlexey> так вот, в compile time вполне может быть работа с большими числами.
[00:35:50] <Jordan> Но в архитектуре процессора, диапазоны конечны?
[00:35:57] <Jordan> Отобразить же их нужно.
[00:36:22] <vаlexey> Не нужно. Возможна реализация с безразмерными INTEGER'ами - влезет любое число которое в ОЗУ поместится
[00:36:48] <vаlexey> короче, это точно репорту не противоречит. ни в каком месте.
[00:36:54] <Jordan> Это уже длинная арифметика, обычно такое в отдельном модуле есть.
[00:37:06] <Jordan> Либовая реализация
[00:37:11] <vаlexey> Есть лишь неудобняшка и некая небрежность в реализации. Это не ошибка, это неудобство.
[00:37:36] <vаlexey> Jordan: скажем в haskell'e оно в языке. Там именно такой Integer
[00:37:39] <vаlexey> в erlang'e - тоже
[00:37:52] <vаlexey> Говорю же - это уже нюансы реализации.
[00:38:07] <vаlexey> Тем более что не путай рантайм и компайлтайм
[00:38:18] <vаlexey> в компайлтайме вполне может быть длинная арифметика.
[00:38:21] <vаlexey> а в рантайме уже нет
[00:38:25] <vlad2> Оно не противорчечит репорту только потому, что репорт куцый. Потому как Вирт додуматься до таких извращений не мог (примерно как и до трансляции в js :)
[00:39:05] <vаlexey> vlad2: а вот скажи ка, какая разрядность у compile time целочисленных вычислений в С++? :-)
[00:39:27] <vаlexey> ну вот скажем мы берем и факториал считаем на этапе компиляции - что там будет? :-)
[00:39:38] <vlad2> ICE? :)
[00:40:04] <Jordan> Ага, только твоя неудобняшка, выдаёт ноль.
[00:40:07] <Jordan>
MODULE test;
IMPORT JS;

VAR
  A: INTEGER;
  B: INTEGER;

BEGIN
   A := 999999999999999999999999999;
   B := 9999999999999999999999999999;
   JS.alert(A + B);

END test.
[00:40:12] <vаlexey> ice - это что?
[00:41:01] <vаlexey> Jordan: ну да, обычное переполнение, которое для не модулярных типов вечно UB :-)
[00:41:27] <Jordan> Ну так значит, компилер должен отлавливать такое?
[00:41:50] <vаlexey> угу. вдруг ты умный и знаешь что у тебя будет правильный UB? :-)
[00:42:02] <vаlexey> но неплохо бы конечно варнинг выдавать.
[00:42:30] <vаlexey> а из модулярных типов в Обероне разве что BYTE есть :-)
[00:42:44] <Jordan> Варнинг, ну вы блин даёте. :-)  Это ясная ошибка.
[00:43:06] <Jordan> Репорт одно, всё же нужно сделать по людски.
[00:43:13] <vаlexey> c точки зрения языка - ошибки нет :-)
[00:43:39] <vаlexey> а чем тебя варнинг не устраивает? поставишь галку - считать все варнинги ошибками, и всё :-)
[00:43:46] <Jordan> Ага, потом объясняй программерам, что это фича, всё крут. закидают помидорами...
[00:44:11] <Jordan> Что, в рапорте об это не написано...
[00:44:30] <vаlexey> а вот как бы ты написал в репорте?
[00:45:30] <Jordan> INTEGER оставил на откуп. Но пометил, что INTEGER не менее, -2... до +2..
[00:45:53] <Jordan> И LONGINT добавил
[00:45:53] <vаlexey> ась? чего +-2?
[00:46:13] <vаlexey> ненене, вот пусть даже у нас четко прописано в репорте что INTEGER это 32бита
[00:46:19] <vаlexey> в данном случае это ничего не меняет.
[00:46:32] <Jordan> −2 147 483 648 до 2 147 483 647
[00:46:59] <Jordan> Меняет значит, на 64 бит, он 8 байт
[00:47:06] <vаlexey> ты правило то скажи, по которому на строчку  A := 999999999999999999999999999; надо ругаться на этапе компиляции :-)
[00:47:46] <Jordan> Значение A превышает объявленный тип INTEGER
[00:48:28] <vаlexey> А если так?  A := Foo()*999999999999999999999999999;
[00:48:55] <vаlexey> Ругаться, или уже не надо? :-)
[00:49:05] <Jordan> Ругаться
[00:49:13] <Jordan> Так как будет переполнение
[00:49:19] <vаlexey> почему? ведь Foo всегда возвращает 0 :-)
[00:49:32] <vаlexey> так что A всегда будет 0
[00:49:38] <vаlexey> и никаких переполнений ;-)
[00:49:50] <Jordan> Потом изменять реализация Foo и приехали.
[00:49:59] <Jordan> Трудноуловимая ошибка.
[00:50:22] <vаlexey> ок. а тогда так: A := 999999999999999999999999999*foo +zoo;
[00:50:38] <Jordan> Алексей ты троллишь..
[00:50:44] <Jordan> Сам всё знаешь.
[00:50:48] <vаlexey> Нет, я разные варианты показываю
[00:50:57] <vаlexey> foo и zoo - это константы
[00:51:18] <Jordan> Ну не может INTEGER быть 999999999999999999999999999
[00:52:17] <Jordan> Даже в 64 бит архитектуре,
[00:52:19] <Jordan> -9.223.372.036.854.775.808
+9.223.372.036.854.775.807
[00:52:19] <vаlexey> да ладно? а если так: A := 9; FOR I=0 TO log(999999999999999999999999999) DO A:=A*10+9 END;
[00:52:22] <vаlexey> :-)
[00:52:24] <Jordan> 19 знаков
[00:52:46] <vlad2> ICE - internal compiler error. Было очень популярно во времена VC6.
[00:53:15] <vаlexey> vlad2: не, на самом деле ICE не будет.
[00:53:37] <vаlexey> хотя, ICE я видел например у адского компайлера. тогда я что-то там написал, а оно возьми, да и шлепнись :-)
[00:53:39] <Jordan> Ошибка, правильно так log("999999999999999999999999999")
[00:53:49] <Jordan> Выводим строку
[00:54:05] <vаlexey> Jordan: ошибка, правильно так: log(999999999999999999999999999.0)
[00:54:07] <vаlexey> :-)
[00:54:16] <vаlexey> и нет, строку оно никуда не возвратит :-)
[00:54:23] <vаlexey> десятичный логарифм как бэ
[00:54:43] <Jordan> А, я спутал с Std.Log
[00:54:58] <Jordan> Но ошибка.
[00:55:29] <vаlexey> На этапе компиляции - никакой ошибки нет и быть не может :-)
[00:56:30] <vаlexey> точнее вру конечно - может. вот данный конкретный цикл можно посчитать на этапе компиляции. но шаг вправо-влево и уже нельзя ничего посчитать.
[00:56:39] <Jordan> main.cpp(9) : error C2177: слишком большая константа
[00:56:44] <vаlexey> (и чтобы посчитать - нужен ОЧЕНЬ умный компилятор)
[00:56:47] <Jordan> int a = 9999999999999999999999999999999;
[00:57:16] <Jordan> В чём проблема?
[00:57:23] <vаlexey> ты про цикл?
[00:57:33] <Jordan> код С++
[00:57:34] <Jordan> int a = 9999999999999999999999999999999;
[00:57:45] <Jordan> MSVC выдал main.cpp(9) : error C2177: слишком большая константа
[00:57:55] <Jordan> Чем такой вариант не устраивает.
[00:58:05] <Jordan> Это не варнинг, а ошибка.
[00:58:11] <vаlexey> ну да. в С++ в стандарте это дело описано :-)
[00:58:40] <vаlexey> а в репорте Оберона - нет. разные языки, разные компиляторы. ошибка это то, что противоречит стандарту/репорту.
[00:58:43] <vаlexey> остальное - варнинг
[00:59:10] <Jordan> Репорт слишком мал, в любом случае такое нужно уточнять.
[00:59:12] <vаlexey> и да, я знаю что репорт надо переписать.
[00:59:28] <vаlexey> то есть сделать его непротиворечивым и полным.
[00:59:32] <vаlexey> а не как сейчас.
[01:00:08] <vаlexey> (по сути львиная доля информации о языка находится не в репорте, а в операционке Оберон, то есть вне контекста репорт ну очень коце и убого смотрится)
[01:00:36] <vаlexey> вне Оберон ОС даже не понятно почему Вирт выпилил нафиг массивы с неизвестной на этапе компиляции длиной.
[01:00:49] <Jordan> Мифический оберон язык получается, в реализации он есть, на бумаге нет.
[01:00:51] <vаlexey> Зато в рамках Оберон ОС все становится ясно, понятно и логично :-)
[01:01:36] <Jordan> Как по мне, без уточнения таких вещей, язык не очем.
[01:01:52] <vаlexey> равно как и без стандартной либы.
[01:02:17] <Jordan> Ну хоть в чём то сошлись. :-)
[01:03:04] <vаlexey> вообще, из оберонов, ближе всех к нормальному языку для прикладного программиста, в свое время подошел Оберон-2
[01:03:47] <vаlexey> там же даже дубовые требования были - там уточнялись многие нюансы, там вводились прагмы для расширизмов (стандартным образом прагмы), и там была минимальная стандартная либа
[01:04:32] <vаlexey> а вот КП в плане именно что языка, развился пожалуй еще больше. Зато в плане стандартизованности у него все плохо - ибо это язык одной конторы по сути, под свой проект (ББ).
[01:04:46] <vаlexey> КП - это такой Делфи
[01:04:46] <Jordan> Язык Еберон по мотивам оберон.
[01:05:08] <Jordan> Можно самим стандарт написать, язык Еберон.
[01:05:15] <Jordan> Вариант?
[01:05:16] <vаlexey> В то время как Оберон-2 это скорее паскаль :-) (То есть множество более-менее совместимых реализаций)
[01:05:28] <vаlexey> вариант
[01:05:56] <Jordan> И не ломать голову, как написать без дин массивов. :-)
[01:05:57] <vаlexey> можно даже просто на оберон стандарт написать :-) он не будет противоречить репорту. он будет его повторять и уточнять.
[01:06:12] <Jordan> Или так. Главное он должен быть.
[01:06:43] <Jordan> Читал о нужности встроенных строк?
[01:06:48] <Jordan> На оберкоре.
[01:07:29] <Jordan> Хорошо бы такие строки, тоже в стандарт добавить
[01:07:45] <vаlexey> или в либу :-)
[01:08:18] <Jordan> Это если шаблоны будут.
[01:08:29] <Jordan> С перегрузкой операторов
[01:08:33] <vаlexey> а зачем строкам шаблоны? это конкретный тип
[01:08:46] <Jordan> Точно.
[01:10:09] <vаlexey> перегрузка хороша, но и без нее жить можно вполне. вон в java живут, и в objc живут :-) и много где еще.
[01:10:26] <vаlexey> да даже в Си живут :-)
[01:10:39] <Jordan> Просто что бы нормально по строкам бегать S[i]
[01:11:04] <Jordan> А не GetStr(S, I)
[01:11:22] <vаlexey> ну, эмм.  а это не всегда возможно :-) ну, то есть представь что у тебя строка в utf8
[01:11:34] <vаlexey> и все, приплыли. S[i] уже никак нельзя
[01:11:43] <vаlexey> Только GetStr(S,I)
[01:11:51] <Jordan> Встроить utf строки
[01:12:04] <Jordan> юникод больная тема.
[01:12:31] <vаlexey> еще хуже - тогда программист по аналогии с массивами будет думать, что S[i] по трудоемкости тоже O(1)
[01:12:35] <vаlexey> а это ж не так :-)
[01:13:03] <Jordan> Но по строке всё равно проходить нужно.
[01:13:16] <Jordan> Накладных расходов не избежать.
[01:13:23] <vаlexey> угу. привет итератор, или как там всякие оберонщики говорят - rider
[01:14:02] <vаlexey> просто for i=0 to len(s) do somefunc(S[i]); end;
[01:14:15] <Jordan> Хорошо бы избежать шаманства с юникодом.
[01:14:18] <vаlexey> даст O(len(s)^2) трудоемкость
[01:14:31] <vаlexey> а через итератор - будет ок, будет O(len(s))
[01:14:37] <vlad2> А я так и не понял, почему в оберон ОС не нужны динамические массивы
[01:14:37] <vаlexey> то есть линейная вместо квадратичной
[01:14:58] <vаlexey> А они были пожертвованы ради красоты :-)
[01:15:15] <Jordan> Красоты однозадачной оси?
[01:15:16] <vаlexey> красоты реализации дескрипторов типов, то есть менеджера памяти по сути.
[01:15:27] <vlad2> Чего?
[01:15:30] <vаlexey> надо будет по подробней написать что-ли.
[01:15:40] <Jordan> Для сборщика мусора.
[01:15:44] <Jordan> Упростит и его.
[01:16:05] <Jordan> Одним блоком выделять.
[01:16:20] <Jordan> Хотя, что мешает так же писать и с дин массивом.
[01:16:47] <Jordan> С другой стороны если дин массив будет, никто не станет заморачиваться со статическим массивом.
[01:16:55] <Jordan> Хитрый план. :-)
[01:17:19] <vаlexey> короче, там тема такая - раньше в дескрипторе, в метаинформации про вот этот вот объект (инфа про объекте в куче лежит в предыдущем слове, перед самим объектом) содержался либо дескриптор типа (id типа, ссылка на тип, если угодно. в дескрипторе типа уже про размер сказано), либо сразу размер этого объекта - в этом случае это массив хз. какого размера.
[01:17:51] <vаlexey> то есть был эдакий union там. Приходилось смотреть больше или меньше эта числека некоторого значения. (грубо говоря)
[01:18:37] <vаlexey> а теперь все хорошо - теперь никаких неоднозначностей! В куче теперь бывают только рекорды, указателей на массивы не бывает!
[01:18:45] <vаlexey> Теперь все приведено к одному знаменателю.
[01:19:02] <vаlexey> Немного сумбурно изложил, и по памяти. Обложусь книжками - напишу пост.
[01:19:18] <Jordan> Но ведь, можно в рекорде объявить указатель на массив?
[01:19:24] <vаlexey> Не указатель.
[01:19:30] <vаlexey> Сам массив.
[01:19:36] <Jordan> Ок
[01:19:47] <vаlexey> RECORD arr : ARRAY 100500 OF INTEGER END;
[01:20:23] <vаlexey> так что в куче теперь только рекорды.
[01:20:41] <Jordan> Я не совсем понял, как итератор поможет ускорить перебор строки?
[01:20:51] <vаlexey> и нет, фрагментация памяти от этого всего меньше не стала. и скорость сборщика мусора тоже не увеличилась пожалуй.
[01:21:21] <vаlexey> Jordan: так что он будет тебе выдавать каждую следующую букву. utf8 строка больше похожа на двусвязный список чем на массив по методу доступа к элементам
[01:21:45] <vаlexey> да, менеджер памяти тоже не упростился. просто система стала без хаков :-)
[01:22:02] <Jordan> указатель на массив хак.
[01:22:22] <Jordan> Что, то я плохо соображаю ночью.
[01:22:53] <Jordan> Я спать. Пока.
[01:22:57] <vаlexey> бай
[01:22:58] <vаlexey> :-)
[01:23:50] <vаlexey> вирт по сути избавился от одного union'а в одном месте реализации оси. (в обероне юнионов нет, так что там видимо приходилось напрямую через SYSTEM работать). мелкая побочка - в языке исчезли динамические массивы :-)
[01:27:11] <vlad2> Понятно. Т.е. он ими и так не пользовался?
[01:27:53] <vаlexey> видимо да.
[01:28:24] <vаlexey> ну это все конечно предварительные выводы. надо еще поковырять. но с вероятностью процентов 85 картина именно такая.
[01:29:24] <vаlexey> ну, кроме того, ты же видел - Вирт не стесняется SYSTEM пользовать везде и всюду. Так что если ему надо, то он сделает себе через SYSTEM в данном конкретном месте :-)