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

Последние 7 лет я пишу сугубо на C, и только под Linux (да, да -std=gnu99 и accept4, dup3, __attribute__((cleanup(dtor))) и прочие приятности, позволяющие сделать волосы шелковистее на 15.5%) и не понимаю, для чего вообще нужен C++? То, что на сишке делается красиво и элегантно, в крестах напоминает соитие парализованных дцпшников (к сожалению, утерял картинку, но именно этот образ всплывает в голове, когда вижу очередную порцию крестолапши).

Давайте посмотрим на типичного C++ разработчика: он использует STL, boost, многие любят Qt (не только для GUI), якобы чтобы «писать кроссплатформенный код». В итоге болезный не знает током ни WinAPI, ни POSIX — ничерта. Он абсолютно не разбирается, как работает целевая система, для которой пишет код! Крестокодер просто не осознает, какой лютый ужас кроется за его любимыми iostream-ами, какое лютое говно лежит в boost::filesystem::path, насколько убого-низкоуровневым является boost::asio в 2016 году.

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

Также эти убогие завистливо смотрят на type inference в языках, проектировавшихся не как «C на стероидах», и в ответ начинают лепить template и auto не к месту, от чего код адово пухнет и даже IDE перестает его понимать.

Серьезно, просто прекратите писать на этом языке. В следующий раз, начиная новый проект, выберите java (щютка)/go/swift/rust/c. Прекратите насиловать труп и отравлять зловонием все вокруг!

Перемещено true_admin из talks

Довольно длительное время сидел в дуалбутной винде, с виндовым firefox-ом, обмазанным всякими плагинами «чтоб youtube смотреть и не тормозило».

Сейчас решил компильнуть мир немного обновиться. Обновил флеш до 24-й версии, зашел на парочку тяжелых сайтов, и просто не узнал FF — он летает! В youtube скроллинг плавный, видео играются и не сильно нагружают CPU.

Но самое главное, браузер-то работает ощутимо быстрее, чем в windows. И WM такой удобный, в отличие от виндоговна (чего только шизанутое поведение Alt-Tab-а на полноэкранных DirectX играх приложениях стоит).

Да хрен с ним, с браузером. Понятно, чем занята система: если я ничего не делаю, в системе полтора процесса, не считая kworker-ов. Если в терминале десяток вкладок — будет десяток bash-ей. И, черт возьми, как это приятно, когда нет непонятных говносервисов, внезапного громкого насилия над жестким диском, если отойти минут на 5.

А софт? Весь софт ставится и обновляется легким движением руки из репозиториев, со всеми зависимостями, в автоматическом режиме без этих бесконечно-мудацких «next-next-are-you-sure».

Неужели наконец-то наступил светлый день, когда Linux готов для десктопа?

Выпаршиваю URL-ы для проигрывания страницы и через while read url подаю их на вход mplayer-у. В итоге цикл завершается на первой же итерации. Заменяем mplayer на ffplay => все ок.

В какую сторону копать?

# mplayer завершается и цикл не идет дальше
curl http://www.divx.com/en/devices/profiles/video | grep -Eo 'href=.http[^"]*' | sed -nre 's/^href="(.*\.divx)$/\1/p' | while read url; do mplayer $url; done
# ffplay, mpv отрабатывают без проблем
curl http://www.divx.com/en/devices/profiles/video | grep -Eo 'href=.http[^"]*' | sed -nre 's/^href="(.*\.divx)$/\1/p' | while read url; do ffplay $url; done

По стандарту из union можно писать только то поле, которое было в него записано последним. А если речь идет о структурах?

struct type_a {
  int field1;
  char field2;
};

struct type_b {
  struct type_a a;
  double field3;
};

void do_a(struct type_a *a);
void do_b(struct type_b *b);

typedef union {
  struct type_a a;
  struct type_b b;
} super_type;

/* x->b гарантированно был инициализирован */
void do_c(super_type *x) {
  do_a(&x->a);
  do_b(&x->b);
}

Или вообще вот так (при условии что безымянная структура внутри union-а всегда совпадает с S):

struct S {
  char field1;
  int field2;
};

void do_S(struct S *s);

struct M {
  double x, y;
  union {
    struct {
      char field1;
      int field2;
    };
    struct S s;
  };
};

void do_M(struct M *m)
{
  m->field1 = '5';
  m->field2 = 5;
  do_S(&m->s);
}

Не далее чем вчера, находясь под впечатлением от http://www.computerra.ru/65749/steps/ (в частности, TCP стек в 160 строк), я озаботился поиском вменяемых средств кодогенерации с выводом в сишку и не обнаружил особого разнообразия. Конечно, есть просто обалденные bison, ragel, да тот же protobuf, наконец — но какого-то generic решения я не нашел.

Точнее говоря, есть autogen и m4, но они настолько инопланетными, что идея запилить свой транслятор на сишке, используя bison + flex, не кажется чем-то диким.

Может многоуважаемый all подскажет что-то новое?

P. S. основное пожелание: чтобы входной DSL был легко читаем и модифицируем без изучения тотально нового языка.

После обновления системы для монтирования ntfs-разделов всегда используется ntfs-3g. А мне, в общем-то большую часть времени нужен только RO доступ к общим данным.

Вот строчки в fstab:

/dev/sdc1	/mnt/win_c	ntfs	ro,showexec,noauto,users	0 0
/dev/sdc5	/mnt/win_d	ntfs	ro,showexec,noauto,users	0 0

А вот что получается:

$ ps awux | grep ntfs
root      4144  0.0  0.0  16840  1896 ?        Ss   13:15   0:00 /usr/sbin/mount.ntfs /dev/sdc1 /mnt/win_c -o ro,noexec,nosuid,nodev,showexec,users
root      4152  0.0  0.0  16840  1952 ?        Ss   13:15   0:00 /usr/sbin/mount.ntfs /dev/sdc5 /mnt/win_d -o ro,noexec,nosuid,nodev,showexec,users

Естественно, ntfs-драйвер в ядре есть:

$ find /lib/modules/ -name 'ntfs*'
/lib/modules/4.4.6-gentoo/kernel/fs/ntfs
/lib/modules/4.4.6-gentoo/kernel/fs/ntfs/ntfs.ko

И он предоставляет файловую систему ntfs:

$ cat /proc/filesystems | grep ntfs
	ntfs

И тем не менее

$ mount | grep sdc
/dev/sdc1 on /mnt/win_c type fuseblk (ro,nosuid,nodev,noexec,relatime,user_id=0,group_id=0,allow_other,blksize=4096)
/dev/sdc5 on /mnt/win_d type fuseblk (ro,nosuid,nodev,noexec,relatime,user_id=0,group_id=0,allow_other,blksize=4096)

У меня складывается ощущение, что виноват mount, который использует mount.ntfs. Раньше это совершенно точно называлось mount.ntfs3g. Как быть?

По дурости решил накатить уютненькую генточку с поддержкой UEFI. Разметил диск в GPT, распаковал stage3, собрал кучу всего. Но вот засада: не могу добиться загрузки ядра. Использую rEFIND — после выбора ядра «что-то происходит», а затем reboot (я так полагаю, что случается паника). При этом ядро на экран вообще ничего не выводит.

Эта петушиная феерия маркетоидной бредотехнологии под названием EFI меня порядком утомила, поэтому просто хочу спросить: каким образом преобразовать GPT => MBR без потери данных и вернуться в свой уютненький grub-0.97? Compatibility mode поддерживается материнкой (собственно, и гружусь с флешки безо всяких efi).

Задумал делать апгрейд. С процессором определиться было довольно легко: Core i7 6700 (без K, чтобы не перегревал мне помещение в жаркое лето) —, а вот с материнскими платами какие-то непонятки.

Хочу мигрировать без смены носителей, поэтому хочется поддержки Legacy mode, а выяснить, поддерживается ли он ASUS Z170-P D3 из интернета не получается. Может кто поделится историей успеха на сокете LGA1151 + MBR? А то как-то не хочется прийти к патовой ситуации, когда нельзя загрузиться ни на новом, ни на старом железе.

Пробовал эту хипстерскую поделку неоднократно, и каждый раз, плюясь, сносил, ибо

make && ./binary

make; and ./binary

Поскольку ребята кладут болт эту пользовательскую хотелку, взял инициативу в свои шаловливые лапки.

• patch для версии 2.2.0: https://github.com/radioneko/gentoo-overlay/raw/master/app-shells/fish/files/...
• path для гитовой версии: https://github.com/radioneko/gentoo-overlay/raw/master/app-shells/fish/files/...
• ebuild для ленивых: https://github.com/radioneko/gentoo-overlay/raw/master/app-shells/fish/fish-2...

Слегка ломается подсветка синтаксиса, но мне как-то фиолетово, каким цветом «&&» и «||» отображаются до тех пор, пока работают, как мне надо.

Допустим, у нас есть сложная структура данных, которая представима в виде s-expressions, внутри которых встречаются самые разнообразные атомы, в том числе keywords и symbols. Вопрос: позволяет ли какая-либо из реализаций CL провернуть подобное?

Уверен, что ecl может, но относительно интересующих меня clozurecl и clisp никак не могу накопать в хидерах что-то похожее.

Конечно же, можно взять cffi, через defcstruct/defcunion «открыть скобочному миру» сишные структуры, и в самом лиспе преобразовать это в нужный вид, но выглядит

• костыльно (int => keyword/symbol)
• небыстро
• двойная работа: генерируем списки в сишечке, чтобы пройтись по ним лиспом и сделать нормальные cons-ы

Есть некоторое внутреннее API, которое хочется «оживить» с помощью настоящего языка программирования, ибо конвейеры из grep/sed/awk с cli-тулзой тяжелы в написании/понимании/эксплуатации. В связи с этим хочется иметь язык, в который я впихну имеющиеся вызовы, красиво их оберну и буду наслаждаться использованием.

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

В идеале хотелось бы, чтобы язык: - имел именованные параметры у функций - имел консольный REPL с историей с действительно умным дополнением (в частности, предлагал эти самые именованные параметры) - имел выразительные структуры данных (вот по этому пункту лисп с его s-exp'ами явный фаворит, т. к. через keyword'ы + s-exp выражается практически вся моя предметная область) - дружил с C++ (желательно без swig, т. к. на моей памяти отображение 1-в-1 ни разу не выглядело «родным и удобным» для целевого языка) на самом примитивном уровне: временем жизни плюсовых объектов я хочу управлять сам

О чем слышал:

• для python-а есть ipython, с двумя вариантами: браузерная и qt-шная консоль — выглядит вкусно, но в ssh с таким не побалуешь
• для lisp-а есть slime, однако комплит в нем подозрительно тупой:

  (defun my-sum (&key arg-1 arg-2)
    (+ arg-1 arg-2))
  (my-sum :arg-1 1 :arg-2 2)
  

  во-первых, arg-1 и arg-2 не предлагаются к дополнению внутри функции (точнее говоря, предлагается куча разного всякого г-на, на фоне которых аргументы теряются) во-вторых, при вызове этой функции keyword-ы для именованных аргументов также предлагаются в последнюю очередь

В каком направлении можно покопать? Или плюнуть на все, писать свой парсер для s-exp'ов к readline и костылить нужное мне дополнение полностью вручную (выглядит жуть как геморно, я лучше с sed/grep/awk посношаюсь)?

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

То есть, если есть правило

let_stmnt:
  TOK_LET TOK_IDENTIFIER TOK_ASSIGN expr;

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

let_stmnt:
  TOK_LET variable TOK_ASSIGN expr;

variable:
  TOK_IDENTIFIER { add_completion(COML_VAR, @$); }

В процессе гугления находил только рекомендации использовать push parser для такого, но без конкретики или примеров.

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

Допустим, я хочу странного: использовать edge-triggered epoll (всегда мечтал, но руки все не доходили) + splice для работы с диском (отправка/получение файлов). При этом splice между (pipe => disk) и (net => pipe) происходят в отдельных тредах (в linux же не могут завести человеческое дисковое aio).

Проблема в том, что когда splice возвращает EAGAIN как-то очень нетривиально догадаться, кто виноват. Если использовать level-triggered IO, все просто: мониторим pipe и source/destination socket на готовность к чтению/записи и пишем/читаем. Получили EAGAIN — не паримся и уходим в epoll, позже видно будет, кто виноват.

Если использовать ioctl, чтобы понять, не переполнился ли пайп, можно наступить на race (splice file => pipe и pipe => socket происходят в разных потоках). Если узнать максимальный размер буфера pipe, также пойдут race, потому как операции «атомарно сделать splice и изменить userspace счетчик» не завезли. Можно обмазаться mutex'ами, но это убьет производительность (splice сможет делать только один поток).

С level-triggered все просто: получил событие, позвал splice и если наткнулся на EAGAIN, значит виновата «другая сторона», т. к. файловый дескриптор готов к чтению записи — гарантировано epoll'ом. Но level-triggered делают все, и в нем время от времени придется делать EPOLL_CTL_DEL. В edge-triggered не нужно в принципе изменять набор дескрипторов, но splice нужно проводить до победного EAGAIN, а там уже фиг поймешь, кто виноват.

Может есть какой-то красивый трюк, о котором никто не пишет?

P. S. Любители nginx и прочих готовых «быстрых веб-серверов» идут лесом — у меня душа странного требует.

Сижу на 24-м ESR, некоторые сайты уже перестают работать. Набрался смелости перейти на 38-й ESR с австралисом и ужасным интерфейсом, но ебилдов пока не видно (ну или я плохо в багзилле искал)

P. S. firefox-bin не предлагать — оно сходу выжрало почти 300 метров, не открывая ни одной страницы. Планирую собрать лису с -Os

Захотел сделать свою приблуду для глобальных хоткеев, полез в сырцы xbindkeys (y u no docs, opensource?), а там...

static void
my_grab_button (Display * dpy, unsigned int button, unsigned int modifier,
		Window win)
{
  modifier &= ~(numlock_mask | capslock_mask | scrolllock_mask);

  XGrabButton (dpy, button, modifier, (win ? win : DefaultRootWindow (dpy)),
	       False, ButtonPressMask | ButtonReleaseMask,
	       GrabModeAsync, GrabModeAsync, None, None);

  if (modifier == AnyModifier)
    return;

  if (numlock_mask)
    XGrabButton (dpy, button, modifier | numlock_mask,
		 (win ? win : DefaultRootWindow (dpy)),
		 False, ButtonPressMask | ButtonReleaseMask,
		 GrabModeAsync, GrabModeAsync, None, None);


  if (capslock_mask)
    XGrabButton (dpy, button, modifier | capslock_mask,
		 (win ? win : DefaultRootWindow (dpy)),
		 False, ButtonPressMask | ButtonReleaseMask,
		 GrabModeAsync, GrabModeAsync, None, None);

  if (scrolllock_mask)
    XGrabButton (dpy, button, modifier | scrolllock_mask,
		 (win ? win : DefaultRootWindow (dpy)),
		 False, ButtonPressMask | ButtonReleaseMask,
		 GrabModeAsync, GrabModeAsync, None, None);

  if (numlock_mask && capslock_mask)
    XGrabButton (dpy, button, modifier | numlock_mask | capslock_mask,
		 (win ? win : DefaultRootWindow (dpy)),
		 False, ButtonPressMask | ButtonReleaseMask,
		 GrabModeAsync, GrabModeAsync, None, None);

  if (numlock_mask && scrolllock_mask)
    XGrabButton (dpy, button, modifier | numlock_mask | scrolllock_mask,
		 (win ? win : DefaultRootWindow (dpy)),
		 False, ButtonPressMask | ButtonReleaseMask,
		 GrabModeAsync, GrabModeAsync, None, None);

  if (capslock_mask && scrolllock_mask)
    XGrabButton (dpy, button, modifier | capslock_mask | scrolllock_mask,
		 (win ? win : DefaultRootWindow (dpy)),
		 False, ButtonPressMask | ButtonReleaseMask,
		 GrabModeAsync, GrabModeAsync, None, None);

  if (numlock_mask && capslock_mask && scrolllock_mask)
    XGrabButton (dpy, button,
		 modifier | numlock_mask | capslock_mask | scrolllock_mask,
		 (win ? win : DefaultRootWindow (dpy)), False,
		 ButtonPressMask | ButtonReleaseMask, GrabModeAsync,
		 GrabModeAsync, None, None);
}

Интересно, если бы лампочек на клавиатуре было больше трех, сдесь бы была портянка из 15 копипастнутых if'ов?

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

Допустим, есть бранч develop, от которого сначала отпочковывается бранч release, а спустя еще несколько коммитов — feature branch. Фича доводится до ума и мержится в develop. Однако фича получается настолько хорошей, что ее страшно хочется пропихнуть в release.

Как это правильно сделать?

То есть, грубо говоря, нужно влить в release все коммиты, которые показывает git log develop.., будучи сделанным из feature-branch'а. Очевидно, что можно сделать кучу cherry-pick'ов, или заsquash'ить все нужные коммиты в feature и перенести их уже за один cherry-pick, но это не очень хорошо, т. к. коммиты будут разными, что вызовет немало проблем.

По манам выходит, что можно сделать

git checkout release
git merge-base feature develop # запоминаем "точку ветвления" $BASE
git merge -s ours $BASE # делаем вид, что в release есть все, что в feature на момент ее "отпочковывания" от develop
git merge feature

Чисто теоретически это должно работать, но напрягают дополнительные «левые» merge. Может я чего-то не знаю или делаю что-то не так?

Решил было попробовать хваленые «игры под Linux». Запустил ваш говностим (отдельный вопрос о том, сколько 32-битной параши пришлось для этого пересобрать с abi_x86_32) и решил предаться игромании, благо список тайтлов выглядел внушительно (аж целых 35 штук!).

№1: Symphony (http://store.steampowered.com/app/207750/). Запустилсь. При попытке просканировать директорию с музыкой закрашилась, видимо слишком много треков, ниасилило. Позасовывал альбомы по отдельности, чуть-чуть повозил мышкой — вроде бы работает.

№2: Borderlands 2 — запустилась, в коопчик с друзяфками нипаиграть, а в соло оно мне надо, как плавающая точка в финансовых вычислениях

№3: Age Of Wonders 3 — ох, какие у меня были хорошие предчувствия, только поганое Qt5 (для которого нет ебилдов с поддержкой multilib) все испортило. Ну ладно, вытащил недостающие 32-битные либы из дебиановских репозиториев, ldd показывает полную готовность, запускаю — какой-то assert на multibyte string. В общем, дальше ldd дело не продвинулось.

№4 Xenonauts — к новому икскому испытываю стойкое отвращение, а тут «дух старой школы™», да и по скринам понравилось. Качаю, запускаю, а оно мне в консоли выдает:

which: no wine in (/mnt/media/steam/ubuntu12_32:/mnt/media/steam/ubuntu12_32/steam-runtime/amd64/bin:/mnt/media/steam/ubuntu12_32/steam-runtime/amd64/usr/bin:/usr/lib/colorgcc/bin:/usr/lib/colorgcc/bin:/usr/local/bin:/usr/bin:/bin:/opt/bin:/usr/x86_64-pc-linux-gnu/gcc-bin/4.8.4://home/inferno/exec/bin:/opt/xmms/bin)
WINE not found. Please install before running.

И тут я понял, что несмотря на всю проделанную Valve работу, поиграть в Linux по-прежнему можно только в тарый добрый Unreal Tournament 2004, линуксовую версию которого в стим почему-то не завезли.

P. S. при всем этом линуксовый стим жрет непотребно много ресурсов, скорость скачивания примерно в 4 раза, чем в винде, ну а к вылетам и нештабильншти я, в принципе, был вполне готов — это же коммерческое ПО под Linux, тут по-другому никак.

P. P. S. зато теперь я точно знаю, что steam machines и steamos просто пустой звук, там ведь будет полторы инди-казуалки, два с половиной AAA-тайтла через wine и куча кривых портов, которые только и могут, что в библиотеке присутствовать без возможности запуска.

Решил сделать в vim нормальную навигацию по тексту при включенном wrap-е длинных строк. Сделал это как-то так:

noremap  <down> gj
inoremap <down> <C-o>gj
noremap  <up>   gk
inoremap <up>   <C-o>gk
noremap  <home> g^
inoremap <home> <C-o>g^
noremap  <end>  g$
inoremap <end>  <C-o>g$

Существует ли workaround, чтобы избежать такого мигания кроме как «не показывать индикатор/не использовать airline»?

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

Есть ли какой-либо удобный язык, которым можно перемалывать гигабайты логов, время от времени рисовать GUI к перемалывалке логов, который бы был лаконичным, эффективным и вот с такенными здоровыми аккумуляторами?

Первым делом на ум приходит perl, но как-то он мне не очень приятен. python и ruby выглядят неплохо, но до лаконичности perl'а им далековато.

Какие еще есть варианты? Слышал много хорошего про haskell, но так и не понял, можно ли на нем писать быстро и «на коленке».

Какой грязный трюк посоветует многоуважаемый $all, если нужно передать параметр, который может означать либо целочисленный интервал (допустим <= 10000000), либо указатель. Переносимость не требуется. Linux x86/x86_64, userspace.

Навскидку хочется сравнивать переданный параметр с какой-то константой. Для 32 бит вроде как можно передавать константу как x < 1G, т. к. нижняя часть адресного пространства отдана ядру. Валидна ли подобная магия для 64 бит?