Собственно, речь о технологиях.

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

Современный веб ужасен, это явление глобальное и всеобъемлющее, в том числе весьма способствующее глобальному загрязнению окружающей среды в силу того, что веб требует мощностей, абсолютно несоизмеримых с решаемыми задачами. Слабые попытки исправить его AJAX'ом и WebSocket'ами - не решают проблему хотя бы по той причине, что бузинес зачастую против JavaScript (а то вдруг драгоценный клиент его у себя отключил в браузере) и предпочитает генерировать тонны УГ на стороне сервера средствами для забивания гвоздей наподобие монструозных Java-фреймворков.

Я могу легко и непринуждённо перечислить как минимум 100 причин того, почему современный веб - это просто уродливейший из продуктов человеческого «ума». Но не стану, ибо моё мнение мало кому интересно.

Кто в курсе, современный OpenNMS всё также конфигурируется в основном через xml? Или уже приделали всё это в его морду?

Дело в том, что тут уже Илон Маск собирается на Марс, графен вовсю юзают... Неужели в OpenNMS всё по-старому?

Собственно, когда-то очень давно пользовался MASM'ом (верси 6.11, если мне склероз не изменяет), так там был встроенный макроязык, который сначала было очень трудно освоить, но зато после того, как я им проникся, я начал писать асм-код в разы быстрее, поскольку генерировал львиную часть кода именно им.

И давеча подумал я на досуге: вот мне трудно осваивать LISP с нуля, но если бы он был встроен в какой-то другой язык, вполне себе общего назначения - скорее всего мало-помалу я бы стал использовать его всё больше и больше и в конечном итоге код на LISP'е стал бы как и в случае с макроассмеблером составлять вообще большую часть кода, после чего перейти на любой полнойценный LISP-based язык не составило бы труда.

Внимание, вопрос: в каком «обычном» ЯП можно использовать LISP в качестве встроенного макроязыка?

Спасибо!

Нужно так:

Есть список, в нём лежат ссылки на элементы хэша:

my $h={split //,q(abcdefghijklmn)};
my $a=[map \$h->{$_}, keys $h] ;

При удалении каких-то элементов из хеша хотелось бы, чтобы и в $a удалялись элементы... автомагически.

delete @{$h}{qw(a c m g)};
print Dumper $a;

Однако же:

$VAR1 = [
          \'f',
          \'d',
          \'l',
          \'b',
          \'h',
          \'n',
          \'j'
        ];

Если не удалять, а делать undef элементов хеша - ситуация уже становится полегче (можно виртуозно грепать список), вот только одна беда: таких списков over дофига, т.е. на самом деле $a является «одним-из-миллиарда» элементов другой структуры данных - и при удалении элементов из хеша проходить по всем таким спискам - это эпичнейший геморрой.

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

А есть ещё какие-то варианты? Как обеспечить некоторую связность структур данных, при которой если удаляются элементы из одной структуры - они исчезают из другой тоже?

Поставил yum'ом пакет perl-Log-Log4perl, а он за собой потянул библиотеки векторной графики, векторные шрифты, библиотеки для 3D-графики, какие-то огромные куски от иксов...

Собственно пруф: http://pastebin.com/ZtQVMt6i

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

Что за ад зависимостей такой в CentOS 7 и зачем rrdtools Log4perl'у?

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

Не обязательно IT.

К серверу MySQL подключен клиент, висит постоянно, можно спокойно узнать о нём всё, что нужно.

Но не знаю, собственно, как это сделать.

Клиентом является бинарник, который что-то внутри у себя не так переварил и стал вместо UTF8 отправлять строки в Latin-1.

Нужно убедиться в том, что действительно кодировка на стороне клиента некорректна, пользуясь, скажем, учётной записью root.

Как это сделать?

Спасибо!

Я вот думаю: где можно пообщаться с горячими поклонниками языка R, поспрошать чего, научиться уму-разуму? :)

В идеале всё же оффлайн.

Понимаю, что все занятые и вообще время не то... но вдруг. Ну вот мало ли - бывает ведь в жизни «+8» распределений, отличных от нормального.

Как так? Почему Земля вращается вокруг Солнца по слабоэллиптической орбите, но это не приводит к тому, что 2 раза в год на всей Земле средняя температура максимальна и 2 раза в год - минимальна?

Кто так строит? (С)

Почему??

Доколе???

Правильно ли я понимаю, что ни одной реализации http://man7.org/linux/man-pages/man7/sem_overview.7.html для Perl'а не существует?

Там есть semget, semop, semctl, но это не POSIX-семафоры и семантика у этих функций весьма неудобная, особенно всякие чудесные константы для формирования флагов...

Я снова хочу невозможного в Perl :(

А именно (речь идёт о Linux, только о Linux, и да, мне абсолютно срать хотелось на переносимость кода в какую-либо иную ОС) :

1) Хочу, чтобы в виртуальное адресное пространство процессов отображалась одна и та же физическая страница

2) Хочу чтобы где-либо на этой странице памяти нашлось место для одного-единственного байта

3) Хочу, чтобы в этот байт можно было делать некий аналог ассемблерного BTS (bit-test-and-set): чтобы атомарным образом содержимое бита сначала сохранялось, а потом тут же устанавливалось

4) Таким образом у меня были бы целых 8 флагов, которые я мог бы использовать для блокировки процессов от повторного запуска: по сохранённому биту я бы определял, была ли блокировка, а если её не было - то я бы изменял значение бита на 1 и последующие инстансы уже не смогли бы сделать те или иные пакости.

Ура?

Подозреваю, что нет.

Мне кажется, и меня это немного пугает, что в Perl5 принято делать блокировки файлами, а гвозди забивать микроскопом, для обладания которым нужно сдать экзамен по вождению марсохода (намекаю на геморрой с правами и путями на любой ФС). Я прав?

P.S. Я пробовал IPC::ShareLite: мало того, что оно вообще не о том (мне НЕ нужно блокировать ресурс в shared memory, у меня самоцель - сам lock), так ещё и работает в на скорую руку состряпаннях тестах - весьма странно (flock вёл себя куда адекватнее).

Есть, например, такие задачи: 1) нужно брать поля для SQL-вставки из ну очень длинного списка. Если формировать всю команду INSERT одним залпом - будет фейл. Формирую, стало быть, частями, разбивая исходный список на удобоваримые «порции». Кстати, такую же вставку можно было бы делать и вообще распараллелено

2) есть у меня список, который нужно обрабатывать как «упорядоченный хеш», т.е. что-то вроде

["Great"=>"Britain", "Northern"=>"Ireland", "Patrice"=>"Lumumba", "Communism"=>"Young of world"]

Но тут у меня на пути встаёт пресловутый TMTOWTDI. А именно то, что на Perl-е совсем не хочется писать нормальные циклы, а хочется каких-нибудь лютых извращений наподобие такого:

@a=split //,do { open my $fh, q(/etc/fstab); join ("",map { chomp; $_ } <$fh>)};
say
  join("\n", 
    map {
      join("",grep defined $_, @a[$_*20..($_+1)*20]) 
    } 0..int(@a/20-1)
  );

В общем... фундаментальный вопрос: как правильно, а главное - эстетично (ведь Perl - это прежде всего язык эстетов) решить задачу обработки массива по частям, не прибегая к дурацким вычислениям и уж упаси Боже - к мелкобуржуазным циклам for(;;)?

На что я намекаю... В «примитивном» BASH есть, например, такая вот архиполезная конструкция:

$ echo {0..115..20}
0 20 40 60 80 100

Неужели на Perl'е это без чудесной арифметики никак не реализуется?

Спасибо! :)

Собственно, нужно, чтобы после компиляции кода на Си - через strings exe_file, либо просто fgrep 'строка' exe_file было видно строку, включенную туда просто как «сигнатура» - признак того, что это именно тот файл, который я компилировал.

При этом строка текста не используется никак. Я проверял: неиспользуемые строки, потенциально засоряющие сегмент данных компилятор с обычным уровнем -O2 конечно же удаляет. Как бы это так сделать, чтобы всё же некий «неудаляемый» признак можно было оставить в исходниках, при этом не изменяя ничего в рабочем коде или изменяя абсолютно минимально?

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

Пишу приложение, работающее в режиме «демона».

Использую PID-файл и как блокировку от повторного запуска, и как просто файл, содержащий PID процесса.

В принципе мне бы хватило алгоритма «сделал flock(LOCK_EX) после форка - сделал flock(LOCK_UN) на выходе». Для самого Perl'а этого бы хватило за глаза. Но для удобства и для порядку так сказать хотелось бы невозможного: закрывать PID-файл и затем удалять его.

Есть опасения race conditions: я могу закрыть файл, потом следующий мой инстанс получит управление и откроет его, после чего я возьму и удалю уже открытый файлик. Таким образом, будет существовать инод, содержащий PID следующего инстанса, но у файла уже не будет записи в каталоге и с точки зрения Shell-скриптов, например, PID-файл уже не будет существовать.

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

А вообще кто что думает по этому поводу?

Очень нужно некое гибридное хранилище данных. Изначально это кеш медленных данных, получаемых из БД Zabbix'а Но в процессе работы приложения, запускаемого под hypnotoad (all glory to Mojolicious в первую очередь, но hypnotoad тоже молодец :)) - AnyEvent'ом запускается целая куча процессов под разные задачи:

1) Расчёт состояния IT-подсистем на разных уровнях иерархии

2) Выдача текущего слепка данных пользователю по запросу

3) Обновление структуры данных (иерархии объектов инфраструктуры мониторинга) из БД Zabbix'а

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

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

С этим нет проблем, например, у Cache::FastMmap. Я потестил его - на 700-ах конкурирующих процессах блокировки отлично работают, процессы по сути «выстраиваются в беспорядочную очередь», с минииальными накладными расходами. Модуль мне очень понравился, но... мне ужасно неудобно то, что я в этот кеш должен запихивать json-строки. Потому что это кеш, а мне нужно именно хранилище двойного назначения, позволяющее обращаться непосредственно к РСУБД раз в минуту за совсем небольшими порциями данных и раз в час - за относительно крупными.

Вопрос: есть ли что-то подобное Cache::FastMmap, но позволяющее хранить не строки и числа, а структуры данных Perl? При этом работающее достаточно быстро. Мне было бы достаточно какого-нибудь XS-ного аналога упомянутого кеш-движка, внутри хранящего всё в BSON (Binary JSON), но отдающего всё-таки структуры данных Perl.

Заранее спасибо за советы!

Я в принципе не люблю ООП, а в Perl5 и тем более (реализация просто ужасная). Но вопрос реализации объектов через благословение closure меня заинтересовал.

Я уже не первый объектный класс так пишу, и в общем могу сказать, что полноценный «закрытый» доступ к свойствам объекта, гарантирующий, что пользователь не полезет в твой объект напрямую, даже если он этого очень захочет - это вполне здравая идея, которая уже давно реализована везде и всюду, но почему-то только не в Perl5. Замечу, что в том же Moose мне удавалось «расковырять» объект и получить доступ к его свойствам, минуя все хитросплетения has-определений, всяких private'ов и «ro».

А вот с closure'ами такие вещи не прокатывают: достаточно локализовать набор переменных в конструкторе, благословляющем ссылку на процедуру - и все эти переменные будут доступны уже только внутри blessed closure.

Самая идея не нова: она упоминается в толстых книгах O'Reily (Например, «12.7.5. Using Closures for Private Objects» в самой известной из них), откуда я её и почерпнул. Тем не менее, я поискал в гугле на эту тему, изучил некоторые реализации ООП-шных нахлобучек, выложенных на CPAN'е - и не нашёл тех перловиков, которые тоже предпочитают благословлять замыкания.

Вопрос: почему так? Чем плоха идея-то?

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

Но, возможно, я и неправ. Кто-нибудь в курсе, какой алгоритм используется в микропрограмме процессоров Intel-семейства?

Есть AnyEvent-обработчик, внутри которого происходит ошибка - и он тихо валится без всякого зазрения совести. Подумываю над Try::Tiny или даже eval'ом, но интересуют best practices по ловле таких проблем внутри AnyEvent-handler'ов. Искал в гугле - не нашёл. Складывается впечатление, что у разработчиков под AnyEvent всегда всё работает идеально и никогда ничего не падает (во что, конечно, слабо верится).

Что посоветуете?

Спасибо!

Почему такой матчинг регулярным выражением работает неверно?

$a=qq("jkj"kjkkj");
say "captures: \n\t".join(', '=>do { my $c=0; map $c++.': ('.$_.')', @l } ) 
 if @l=$a=~m/^\s*(?<Q>['"])([^\g{Q}]+)\g{Q}\s*$/;

Выводит:

captures: 
        0: ("), 1: (jkj"kjkkj)

И это печально: непонятно, почему

[^\g{Q}]

Я пробовал вместо этого

[^(??{ $+{Q} })]

ЧЯДНТ?

Ответ:

В [] можно использовать только классы символов. Всё остальное будет принято «as is», внутри [] правила интерполяции отличаются от правил для остального регулярного выражения.

Если нужно делать «негативный матчинг» для паттерна известной длины, можно использовать конструкцию:

(?!\g{name}).{LENGTH}

LENGTH нужно подставить числом

Если длина паттерна равна 1 (символ), то просто

(?!\g{name}).

- что имеет смысл «символ, для которого предыдущий символ в предпросмотре не видел \g{name}» :)

Есть «веб-сервис»,в котором хотелось бы кешировать операции запросов в РСУБД с целью делать запросы в РСУБД по поводу состояния объектов мониторинга не чаще, чем «период кеширования».

Как обычно: если объекта в кеше нет или объект есть, но он неактуален - сделать запрос в РСУБД (после чего создать новый или обновить старый объект в кеше), иначе - взять из кеша.

Мне бы хватило кеша полностью in-memory, на структуре данных Perl.

Модификация переменной-«кеша» уровня модуля - работает. То есть, к некоторому моему удивлению, можно запросто при вызове curl http://localhost:port/mojo/route1 и http://localhost:port/mojo/route2 - модифицировать одну и ту же глобальную переменную, и все модификации будут благополучно сохраняться.

Как так может быть и к чему это может привести?

То ли запросы обрабатываются и morbo, и hypnotoad'ом последовательно, то ли... здесь мысль заходит в тупик, поскольку параллельность запросов вроде бы обеспечивается не fork'ом (ведь кеш успешно модифицируется из двух разных запросов), но, очевидно, и не thread'ами. В таком случае, учитывая тот факт, что на уровне ОС кроме процессов, потоков исполнения («тредов») и прерываний ничего в общем-то нет и та же асинхронная обработка происходит в потоках исполнения... что же всё-таки внутри параллельности обработки запросов hypnotoad'ом?