это форма проявления кретинизма
вы - слабак
мозгов не хватает?
идти на поводу своей быдловатой натуры с рефлексами

Ну нихрена себе бугурт.

Да-да.

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

2. Мать его, IDA Pro, но некоторые никак не понимают что структура программы не зависит от ее представления. Не можете осилить смысл инструкции x86? Печально, но вы - слабак. А декомпилировать и разобрать суть исполнения программы - снова мозгов не хватает? Может хотя бы немного стоит обрабатывать ситуацию интеллектом прежде чем идти на поводу своей быдловатой натуры с рефлексами? Но тут похоже клиника: поскольку людям принципы архитектуры исполняемых файлов не знакомы, то и влиять на исход ситуации вовремя они не способны, поскольку для этого нужен интеллект и мышление чтобы ориентироваться в пространстве событии и вариантов. Насколько мне известно, питон в основе своей как раз базируется на примитивизме и, как следствие, воспитывает это в своих поклонниках-программистиках.

3. А что в asm? - А в asm можно все.

Ничего не напоминает? «Все вокруг дебилы, одни пёрл-хэцкеры во всём белом»

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

... sizeof(a)/sizeof(a[0])) ...

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

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

смотри и учись:

#include <iostream>

template<class T> struct ConstArrayRef
{
  const int length;
  const T* const value;
  template<unsigned int n> ConstArrayRef( T(&value)[n] ): length(n), value(value) {}
};

void say(ConstArrayRef<int> arg)
{
  for(int i=0; i<arg.length; ++i)
    std::cout << arg.value[i] << ' ';
}

int main()
{
  int a[] = {1,2,3,4,5};
  say(a);

#ifdef TEST
  int *b = a;
  say(b); // не компилируется
#endif

  return 0;
}

Такие события нужно отмечать ИРЛ. Чтоб можно было дать в морду несогласным любителям пресмыкающихся.

гораздо интереснее бокс по переписке

Бэтти, откуда такая ненависть к systemd? На относительно слабом железе грузится ощутимо быстрее сисвинита.

ЧТО грузится? Ленартоподелка?

Была бы возможность - и на 486DX2 потестил бы.

сначала найди 486 с гигабайтом памяти.

PS: ненависть к быдлокодерам, которые используют инструмент неадекватный задаче. В ините надо юзать sh или сабж, дабы можно было починить на коленке, одним ed. Скорость всё равно не имеет значения, ибо железо в любом случае инициализируется дольше на _любом_ компьютере.

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

разупорись: у меня не только третий пень. видел я это ваше говно.

Ничуть не ставил под сомнение. И никаких удобств по чтению кода скобочки не создают(исключение лиспы). За обозначение блоков кода фигурными скобочками ратуют рабы привычки.

какая разница, чем обозначать? главное - обозначать. вот пример:

#!/bin/sed -rnf

/^$/ b ctrl_end

G
:begin_loop
		s/^([^\n])([^\n]*)(.*)\n\1~([a-g]+)/\2\n\1~\4a\3/
		t continue_loop
		# символа нет в базе или этот символ последний
		/^\n/	b last_sym

		# новый символ
		s/^(.)([^\n]*)\n$/\2\n\1~a/
		t begin_loop
		s/^(.)(.*)$/\2\n\1~a/
		t begin_loop

:continue_loop
		s/(\n.*)a{10}/\1b/;	T begin_loop
		s/(\n.*)b{10}/\1c/;	T begin_loop
		s/(\n.*)c{10}/\1d/;	T begin_loop
		s/(\n.*)d{10}/\1e/;	T begin_loop
		s/(\n.*)f{10}/\1g/;	T begin_loop
		s/(\n.*)g{10}/\1i/;	T begin_loop
		q 77

	:last_sym
	# последний символ
	s///
	x

:ctrl_end
$ {
	# последняя строка
	s/.*/&/
	t convert_start
:convert_loop
		s/a{9}/9/;		t convert_end_loop
		s/a{8}/8/;		t convert_end_loop
		s/a{7}/7/;		t convert_end_loop
		s/a{6}/6/;		t convert_end_loop
		s/a{5}/5/;		t convert_end_loop
		s/a{4}/4/;		t convert_end_loop
		s/a{3}/3/;		t convert_end_loop
		s/a{2}/2/;		t convert_end_loop
		s/a/1/;			t convert_end_loop
		s/^[a-g]*/&0/;	t convert_end_loop
:convert_end_loop
		y/bcdefg/abcdef/
		s/[a-g]/&/
		t convert_loop
	G
	s/^([0-9]+)\n(.*)([^\n])~[a-g]+(.*)/\2'\3' \1\4/
	x
	t convert_start
	:convert_start
	g
	s/.*[^\n]~([a-g]+).*/\1/
	t convert_loop
	s/\n([^\n]+)\n([^\n]+)\n/\t\1\t\2\n/g
	p
}

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

clisp посмотри.

а можно посмотреть как это выглядит на лиспе?

да. читай SICP, начни с потоков (stream). там много букв.

Потому без пробелов можно и обойтись в принципе.

«разве это жизнь»? Давайте ещё от чего-нибудь откажемся.

оппонент кричал, что «во всех ЯП без пробелов нельзя». Я доказал, что в сишечке вполне можно.

посади человека который никогда компов не видал и спроси что ему понятнее - окошки или коммандная строка? Вряд ли его мнение совпадёт с твоим.

ты разве не знал, что в Linux'е есть X11? С чего ты взял, что у меня _только_ командная строка?

Просто с текстом удобно работать в CLI, а с графикой - в GUI. Всегда ваш К.О.

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

слушай, зачем тебе перл? пиши прямо в двоичных кодах, это быстрее, компактнее, и круче. Или ты слабак?

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

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

А что в perl? - А в perl можно все.

кретин! сколько раз повторять, что «всё» можно и в BF и в sed. Вопрос: нужно-ли? Нужно ли писать нечитаемые закорючки с неведомой целью?

Более того, все как-то можно - можно и по-другому.

что в этом хорошего? если путей много, и выбор лучшего не очевиден, то нетрудно догадаться, что многие выберут не оптимальный путь. Перловка имеет внутренний фильтр отсева новичков от задротов, которые 10 лет пишут одностроки на ЛОР?

Сделать оценку языка perl сможет ИИ. Его можно создать с использованием модуля AI-Prolog (доступен из cpan), который реализует парадигму логического программирования в perl.

твоя оценка никому не интересна.

смотри и учись:

  for(int i=0; i<arg.length; ++i)
    std::cout << arg.value[i] << ' ';

чему, дядя? хранить вместе с массивом его размер? тебя засмеёт даже пхпшник:

foreach($a as $i)
	echo "$i\t";

Про nanoblogger только....

... молчите, коллега, молчите, я Вас умоляю! :D Ни когда, ни кто, ни при каких условиях не должен узнать про blog-engine на чистом, незамутнённом bash4. Он лежит здесь — http://nanoblogger.sourceforge.net/ и посвящается (наверное) systemd, в котором решили отказаться от скриптов на bash.

Только тсссс... :D

/* Надеюсь, применение тега <sarcasm> здесь очевидно. :D */

Про лифт и яйца это забавно... :D

... Но вот более реальный пример:

static int f(const char *uri){
int  rc;
char *x = (char *)alloca(strlen(uri) * sizeof(char));
/* Здесь делаем какую-то _полезную_ работу, для которой зарезервировали нужный нам массив. В случае успеха срабатывания ф-ии возвращаем 0, в случае неуспеха -- -1. */
return rc;
} /* А вот теперь лифт пусть едет. Вот здесь и находится это самое "выстрелил и забыл". */

У меня нет malloc()/free(). Вместо этого, при выходе из области видимости массив будет зачищен С runtime автоматически, без моего участия (и именно потому, что это стек, а не куча). В случае с кучей — free(x), я ещё должен сделать х=0; чтобы менеджер памяти его действительно зачистил. Я ещё и на сисколлах экономлю, да... ;)

Да считать-то умею... Вот только иной раз считай-не считай, хрен его знает что может получиться. Самый тупой пример из последнего Т.З. Заказчик хочет чтобы мы ему дали некий демон, но чтобы тот резво отдавал результаты (что-то типа dnsbl, но не совсем). Выход — использовать хранение данных в памяти. Можно, конечно, сгородить огород с хешами из glibc, а можно просто взять berkeley db и сделать in-memory database. Это работает, проверял, использую берклю. Так вот — какой размер памяти отдать под хранение данных? Можно (например) 1/3 от RAM. Но... Сколько у Заказчика RAM? 192Gb? 32Gb? 512Kb (на каком-нибудь говнороутере типа asus wl-500gpv2 (тут _много_ чего есть и можно использовать))? Вот и приходится... Считать. ;)

Ты не поверишь, детка :D Сегодня нет времени, завтра найду в книге по перлу пример, как выполнять поиск по области видимости. Если забуду - ты не стесняйся, сбрось напоминание.

Склероз меня не подвёл. «Программирование на Perl, 3-е издание», Ларри Уолл, Том Кристиансен, Джон Орвант

Часть II, Анатомия Perl
10. Пакеты
Таблицы имён

Все переменные из области видимости хранятся в

%main::<область видимости>, т.е.

• глобальная область видимости: %main::, или %main::main, или %main::main::main и т.п.
• область видимости пакета abc: %main::abc

Спецсимволы в имени переменых воплне можно сделать, есть способ, хотя код получится некрасивым и трудночитаемым

$!@#$% = 0; # НЕВЕРНО, синтаксическая ошибка
${'!@#$%'} = 1; # Ок, хотя не квалифицирована
${'main::!@#$%'} = 2; # Можно Квалифицировать в строке
print ${ $main::{'!@#$%'}  }; # Ок, выводит 2!

хранить вместе с массивом его размер?

Не обязательно, можно в compile-time держать:

#include <iostream>

template<class T, size_t n>
struct arr {
    const T* const ptr;
    arr(T(&ref)[n]) : ptr(ref) {}
};

template<size_t n>
void say(arr<int, n> arg)
{
    for(size_t i = 0; i < n; ++i)
        std::cout << arg.ptr[i] << ' ';
}

int main()
{
    int a[] = {1, 2, 3, 4, 5};
#ifdef TEST
    say<4>(a); // не компилируется
#endif
    say<5>(a);

#ifdef TEST
    int *b = a;
    say(b); // не компилируется
#endif
}

Поздравляю со второй звездой м0кишы.

... О, чёрт! В примере накосячено!

Не char *x = (char *)alloca(strlen(uri) * sizeof(char));, а

char *x = (char *)alloca(strlen(uri));

strlen и так вернёт реальную длину uri + 1 символ. Прошу прощения за косяк.

смотри и учись:

чему, дядя? хранить вместе с массивом его размер?

гы-гы, ты даже не понял, чему тебе учиться

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

т.е. чтобы вызов функции say(a) записывался именно так — say(a), и не приходилось вручную добавлять костыли вида say(a, sizeof(a)/sizeof(a[0])), которые, к тому же, глючат

то же самое, кстати, касается двумерных и многомерных массивов

тебя засмеёт даже пхпшник: foreach($a as $i) echo «$i\t»;

гы-гы, давай померим скорость работы их так называемого массива (который на самом деле хэш)

... молчите, коллега, молчите, я Вас умоляю! :D Ни когда, ни кто, ни при каких условиях не должен узнать про blog-engine на чистом, незамутнённом bash4. Он лежит здесь — http://nanoblogger.sourceforge.net/ и посвящается (наверное) systemd, в котором решили отказаться от скриптов на bash.

я сам хотел привести эту ссылку нашему Леннарту, но мне было лень её искать. Спасибо.

Вместо этого, при выходе из области видимости массив будет зачищен С runtime автоматически, без моего участия (и именно потому, что это стек, а не куча). В случае с кучей — free(x), я ещё должен сделать х=0; чтобы менеджер памяти его действительно зачистил. Я ещё и на сисколлах экономлю, да... ;)

int *f1()
{
	int *a = alloca(sizeof(int)*10);
	a[5] = 7;
	return a;//лифт поехал...
}

я вот одного не понимаю, почему нельзя использовать локальный массив? Даже в случае ошибки, будет:

int *f()
{
	int a[10];
	a[5] = 7;
	return a;//предупреждение: функция возвращает адрес локальной переменной
}

say<5>(a);

«5» должно выводиться, а не указываться вручную

мой пример был специально заточен под бэтти, не знающего с++ то, чтобы быть поближе к людям, пишущим си:

1. say это не шаблонная функция, и может быть заявлена как extern «C»

2. ConstArrayRef, хотя и имеет шаблонные конструкторы, по memory layout совместим с чисто сишной структурой

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

если же мы согласны на шаблонную функцию say, то все пишется намного проще:

template<class T, size_t n> void say( T (& array) [n])
{
    for(size_t i = 0; i < n; ++i)
        std::cout << array[i] << ' ';
}

Так вот — какой размер памяти отдать под хранение данных?

выделить динамически нужное. Будет мало - выделить вдвое больше, и перекинуть туда старое. Даже если мы выделили 1М, то до гигабайта всего 10 прыжков - мелочь, для масштабирования в тысячу раз.

Не обязательно, можно в compile-time держать:

можно и в #define, или на бумажке записать. Какая разница? В любом другом ЯП размер массива хранит компилятор/интерпретатор, а не как в сишечке - хранить-то хранит, только очень недолго. А костыли городить я тоже умею.

strlen и так вернёт реальную длину uri + 1 символ. Прошу прощения за косяк.

sizeof(char)==1 по стандарту. Потому это не косяк. Косяк в том, что strlen(3) возвращает без «+1»

int main()
{
	char *s = "12345";
	return strlen(s);// вернёт 5.
}

гы-гы, ты даже не понял, чему тебе учиться

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

т.е. чтобы вызов функции say(a) записывался именно так — say(a), и не приходилось вручную добавлять костыли вида say(a, sizeof(a)/sizeof(a[0])), которые, к тому же, глючат

я уж лучше sizeof допишу, чем лишний шаблонный класс.

то же самое, кстати, касается двумерных и многомерных массивов

там нужны вложенные шаблоны?

гы-гы, давай померим скорость работы их так называемого массива (который на самом деле хэш)

ну померь. Потом расскажи, кому нужны -10мс рантайма и +20 минут компиляции. И да, это не хеш, ибо хеш не обеспечивает последовательного доступа (0,1,2,3...), а в php обеспечивает.

мой пример был специально заточен под бэтти, не знающего с++

про костыль в C++, который позволяет узнать размер массива в шаблоне я знал. Но да, я его не юзаю. ИМХО не нужен.

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

2002 — 2007 были годами застоя. Сейчас язык именно что активно развивается.

clisp посмотри.

Не хочу, я предпочту Chicken.

Я говорил об использовании скобочек(и фигурных) во время поиска переменных при выполнении кода, а не при компиляции/трансляции.

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

Я понял в чём проблема.

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

Но кому-то непременно нужны именно фигурные «скобочки». Я предлагал как нужно сделать интерпретатор что бы любые предложения использовать отступы можно было обоснованно назвать маразмом, не просто от балды

Я говорил об использовании скобочек(и фигурных) во время поиска переменных при выполнении кода, а не при компиляции/трансляции.

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

во что там оно переводится, меня мало волнует. Чуть менее, чем никак. Это проблемы создателей компиляторов. Мне нуден такой ЯП, что-бы достаточно было ОДНОГО взгляда на код, что-бы мне было всё ясно. Понятно, что такого ЯП нет, и быть не может, но пайтон куда ближе к идеалу, чем перловка. А уж во что там оно внутри что переводит - мне ||.

С чего начиналось?

Мы же ненавидим отступы пробелами или табуляцией.

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

Нет. Я просто забыл насчёт strlen...

... уточнить что у меня это самопальный макрос с возвращаемым значением. Это хорошо укладывается в GCC Extensions. Просто, как я писал выше, в С нет «строк», пришлось вот наваять себе аналог. Вот только настолько привык уже, что забываю уточнять что это _не_ стандартный вариант. Прошу прощения. В С каст не нужен, компиль его не будет делать. Но у меня ещё и С++ с Java попадаются. Привык делать для совместимости и иной раз splint ругается на недостаточную строгость. Уж лучше так.

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

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

Но кому-то непременно нужны именно фигурные «скобочки»

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

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

Либо я не понял твою мысль, либо она претерпела сильные изменения:

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

все пишется намного проще

Это да, я хотел подвести к идее массивов параметризованных числами в шаблонах (такие встречаются, например, в коде LLVM). В пределе такие массивы должны давать ещё и безопасную индексацию без проверок границ во время выполнения - для всех выводимых длин массивов и индексов (выделено от слоя IO), для этого система типов должна быть достаточно богатой чтобы можно было выразить понятие «меньше или равно» для type-level чисел в время компиляции. Причём в C++ что-то такое даже можно сделать:

// type -> term

struct Z { enum { encode = 0 }; };
template<typename A> struct S { typedef A Prev; enum { encode = A::encode + 1 }; };

// term -> type

template<unsigned n> struct Decode { typedef S<typename Decode<n - 1>::Type> Type; };
template<> struct Decode<0> { typedef Z Type; };

// <= relation

template<typename A, typename B> struct LessEq { typedef S<typename LessEq<typename A::Prev, typename B::Prev>::Witness> Witness; };
template<typename B> struct LessEq<Z, B> { typedef Z Witness; };

// some proofs

int main()
{
    typedef LessEq<Decode<0>::Type, Decode<0>::Type> LessEq_0_0_Prop;
    typedef LessEq<Decode<0>::Type, Decode<1>::Type> LessEq_0_1_Prop;
    typedef LessEq<Decode<0>::Type, Decode<2>::Type> LessEq_0_2_Prop;
    typedef LessEq<Decode<0>::Type, Decode<3>::Type> LessEq_0_3_Prop;
    typedef LessEq<Decode<1>::Type, Decode<0>::Type> LessEq_1_0_Prop;
    typedef LessEq<Decode<1>::Type, Decode<1>::Type> LessEq_1_1_Prop;
    typedef LessEq<Decode<1>::Type, Decode<2>::Type> LessEq_1_2_Prop;
    typedef LessEq<Decode<1>::Type, Decode<3>::Type> LessEq_1_3_Prop;
    typedef LessEq<Decode<2>::Type, Decode<0>::Type> LessEq_2_0_Prop;
    typedef LessEq<Decode<2>::Type, Decode<1>::Type> LessEq_2_1_Prop;
    typedef LessEq<Decode<2>::Type, Decode<2>::Type> LessEq_2_2_Prop;
    typedef LessEq<Decode<2>::Type, Decode<3>::Type> LessEq_2_3_Prop;
    typedef LessEq<Decode<3>::Type, Decode<0>::Type> LessEq_3_0_Prop;
    typedef LessEq<Decode<3>::Type, Decode<1>::Type> LessEq_3_1_Prop;
    typedef LessEq<Decode<3>::Type, Decode<2>::Type> LessEq_3_2_Prop;
    typedef LessEq<Decode<3>::Type, Decode<3>::Type> LessEq_3_3_Prop;

    LessEq_0_0_Prop::Witness proof_0_0;
    LessEq_0_1_Prop::Witness proof_0_1;
    LessEq_0_2_Prop::Witness proof_0_2;
    LessEq_0_3_Prop::Witness proof_0_3;
    LessEq_1_0_Prop::Witness proof_1_0;
    LessEq_1_1_Prop::Witness proof_1_1;
    LessEq_1_2_Prop::Witness proof_1_2;
    LessEq_1_3_Prop::Witness proof_1_3;
    LessEq_2_0_Prop::Witness proof_2_0;
    LessEq_2_1_Prop::Witness proof_2_1;
    LessEq_2_2_Prop::Witness proof_2_2;
    LessEq_2_3_Prop::Witness proof_2_3;
    LessEq_3_0_Prop::Witness proof_3_0;
    LessEq_3_1_Prop::Witness proof_3_1;
    LessEq_3_2_Prop::Witness proof_3_2;
    LessEq_3_3_Prop::Witness proof_3_3;
}

clang напишет

q.cc:15:106: error: no type named 'Prev' in 'Z'
  ...LessEq { typedef S<typename LessEq<typename A::Prev, typename B::Prev>::Witness> Witness; };
                                                          ~~~~~~~~~~~~^~~~
q.cc:43:5: note: in instantiation of template class 'LessEq<S<Z>, Z>' requested here
    LessEq_1_0_Prop::Witness proof_1_0;
    ^
q.cc:15:106: error: no type named 'Prev' in 'Z'
  ...LessEq { typedef S<typename LessEq<typename A::Prev, typename B::Prev>::Witness> Witness; };
                                                          ~~~~~~~~~~~~^~~~
q.cc:47:5: note: in instantiation of template class 'LessEq<S<S<Z> >, Z>' requested here
    LessEq_2_0_Prop::Witness proof_2_0;
    ^
q.cc:6:65: error: type 'int' cannot be used prior to '::' because it has no members
template<typename A> struct S { typedef A Prev; enum { encode = A::encode + 1 }; };
                                                                ^
q.cc:48:30: note: in instantiation of template class 'S<int>' requested here
    LessEq_2_1_Prop::Witness proof_2_1;
                             ^
q.cc:15:106: error: no type named 'Prev' in 'Z'
  ...LessEq { typedef S<typename LessEq<typename A::Prev, typename B::Prev>::Witness> Witness; };
                                                          ~~~~~~~~~~~~^~~~
q.cc:51:5: note: in instantiation of template class 'LessEq<S<S<S<Z> > >, Z>' requested here
    LessEq_3_0_Prop::Witness proof_3_0;
    ^
q.cc:15:106: error: no type named 'Prev' in 'Z'
  ...LessEq { typedef S<typename LessEq<typename A::Prev, typename B::Prev>::Witness> Witness; };
                                                          ~~~~~~~~~~~~^~~~
q.cc:15:69: note: in instantiation of template class 'LessEq<S<S<Z> >, Z>' requested here
  ...B> struct LessEq { typedef S<typename LessEq<typename A::Prev, typename B::Prev>::Witness>...
                                           ^
q.cc:52:5: note: in instantiation of template class 'LessEq<S<S<S<Z> > >, S<Z> >' requested here
    LessEq_3_1_Prop::Witness proof_3_1;
    ^
q.cc:15:106: error: no type named 'Prev' in 'Z'
  ...LessEq { typedef S<typename LessEq<typename A::Prev, typename B::Prev>::Witness> Witness; };
                                                          ~~~~~~~~~~~~^~~~
q.cc:15:69: note: in instantiation of template class 'LessEq<S<Z>, Z>' requested here
  ...B> struct LessEq { typedef S<typename LessEq<typename A::Prev, typename B::Prev>::Witness>...
                                           ^
q.cc:15:69: note: in instantiation of template class 'LessEq<S<S<Z> >, S<Z> >' requested here
  ...B> struct LessEq { typedef S<typename LessEq<typename A::Prev, typename B::Prev>::Witness>...
                                           ^
q.cc:53:5: note: in instantiation of template class 'LessEq<S<S<S<Z> > >, S<S<Z> > >' requested here
    LessEq_3_2_Prop::Witness proof_3_2;
    ^

Но совершенно неюзабельно, конечно.

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

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

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

молодец. Если-бы все писали как ты, то Гвидо не стал-бы вводить обязательные отступы.

Какая разница?

http://en.wikipedia.org/wiki/Curry–Howard_correspondence. Пусть даже и жалкие зайчатки в нынешних шаблонах плюсов.

В принципе, я тоже пользуюсь таким подходом, ...

... равно как и реаллоком. Просто, иной раз выясняется что у заказчика система «особонагруженнная» и вот купить ещё памяти оне не могуть. Тогда приходится придумывать. Отсюда и ряд подходов, которые, слава K&R возможны, в отличие от «единственно правильных путей».

Могу ещё добавить что 6M для «однострочного» веб-сервера, это многовато. Если, правда, добавить поддержку CGI туда (для руления всякими разными девайсами через web-интерфейс), то будет не одна строка а что-то типа:

#!/usr/bin/env python

import BaseHTTPServer
import CGIHTTPServer
import cgitb; cgitb.enable()  ## This line enables CGI error reporting

server = BaseHTTPServer.HTTPServer
handler = CGIHTTPServer.CGIHTTPRequestHandler
server_address = ("", 8000)
handler.cgi_directories = [""]

httpd = server(server_address, handler)
httpd.serve_forever()

По-моему, в таком случае лучше было бы «сервер для кофеварок» использовать — boa http://www.boa.org/ ЕМНИП, он там что-то в районе 50-80K в скомпилированном виде весит, а реализует и веб-сервер и поддержку CGI в нём. И ни каких «смехобайтов»... :D

/* Так, вроде, ни чего не забыл? :D */

Новость: «Сегодня языку Perl исполнилось бы 25 лет!» смотрелась бы намного лучше.

Так где же список твоих программ?

www.linux.org.ru/add_comment.jsp?topic=8603896&replyto=8609979

www.linux.org.ru/add_comment.jsp?topic=8603896&replyto=8610818

Вооот! Воооот! Уже где-то писал же...

... в каком-то флейме с поклонниками языка Ребе, по-моему...

«Любая программа, написанная на английском, может быть написана на С». Я ещё больше продолжу мыслю — в идеале был бы интересен транслятор с _любого_ естественного языка на... Да хоть на С, чесслово! Для С в зачаточном состоянии такой транслятор «слегка» есть — http://www.cdecl.org. Вот было бы интересно развитие такого подхода. Формальная спецификация на естественном языке <-> С (или что угодно по вкусу). :D

Спасибо за адекватное пояснение, в этом треде они - редкость. Без сарказма.

systemd загружает систему (в данном случае Arch) быстрее сисвинита. Это факт. Я верю только тому, что можно пощупать. И помню, как на моем железе 2006-7 года выпуска тормозил запуск старого арча и сейчас тормозит запуск кранчбэнга (и это при том, что инит там уже оптимизирован). И апстарт бубунтовский тоже тормозил, кстати. При этом на ещё более слабом железе новый арч с systemd грузится моментально. Короче, УМВР, ЧЯДНТ?

А вот ленартоподелки типа пульсы и мамонтоподелки типа ed терпеть не могу. Чем хоть встроенный в любой роутер бизибоксовский vi не устраивает, не говоря уж об отдельном vim?

Да, не будет. Мне это и не нужно...

... Я, как правило, пишу функции (макросы) так, чтобы они выполняли какую-то конечную задачу. Одну, но хорошо. И, при вызове ф-ии, я просто проверяю возвращаемое значение, по которому сужу — работа сделана или надо заново её попытаться сделать/воспользоваться «планом спасения» (восстановления работоспособности). Так просто удобнее.

Вот пример такого подхода. Есть (уже обсуждали в треде) сисколл write(). С ним всё хорошо — он работает, но есть один довольно частный случай — EINTR, т.е., write по какой-то причине был прерван. Да, понятно что можно в цикле повторять попытки записи, пока write не отпустит, но я лучше использую что-то вроде:

ssize_t nbytes = TEMP_FAILURE_RETRY (write(fd, buffer, count));

И, само собой, буду проверять errno на наличие других ошибок. При таком подходе ф-я write, которая просто пишет буфер куда-то, в случае блокировки просто будет повторять свои действия пока не достигнет успеха, либо пока мы не словим другую ошибку. В случае «другой ошибки» мы можем принять решение что делать. Т.е., иметь «план спасения» приложения. Или просто exit(EXIT_FAILURE);, что тоже выход, конечно.

Пусть даже и жалкие зайчатки в нынешних шаблонах плюсов.

ох... Бывает же такое...

... равно как и реаллоком. Просто, иной раз выясняется что у заказчика система «особонагруженнная» и вот купить ещё памяти оне не могуть. Тогда приходится придумывать. Отсюда и ряд подходов, которые, слава K&R возможны, в отличие от «единственно правильных путей».

ППКС (про то, что alloca нужно для экономии я писал уже выше).

Так где же список твоих программ?

вот ещё! могу коротких примерчиков только дать. Остальное денег стоит.

«Любая программа, написанная на английском, может быть написана на С».

именно!

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

а вот с этим - плохо... Естественный язык практически не поддаётся формализации - практически нет правил, одни исключения. К такому разве что ГА прикручивать, но не ясна функция качества (как оценивать правильность понимания фразы на естественном языке?)

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

2. Мать его, IDA Pro, но некоторые никак не понимают что структура программы не зависит от ее представления. Не можете осилить смысл инструкции x86? Печально, но вы - слабак. А декомпилировать и разобрать суть исполнения программы - снова мозгов не хватает? Может хотя бы немного стоит обрабатывать ситуацию интеллектом прежде чем идти на поводу своей быдловатой натуры с рефлексами? Но тут похоже клиника: поскольку людям принципы архитектуры исполняемых файлов не знакомы, то и влиять на исход ситуации вовремя они не способны, поскольку для этого нужен интеллект и мышление чтобы ориентироваться в пространстве событии и вариантов. Насколько мне известно, питон в основе своей как раз базируется на примитивизме и, как следствие, воспитывает это в своих поклонниках-программистиках.

3. А что в asm? - А в asm можно все.

Ничего не напоминает? «Все вокруг дебилы, одни пёрл-хэцкеры во всём белом»

Ты действительно считаешь что приведенный тобой пример с бинарным дампом равносилен однострочнику? Ну а насчет разбора структуры под IDA - тут вообще все просто. Что может быть проще asm?

Ты не понимаешь о чем тебе говорят из-за того рефлексы отрабатывают раньше чем включается интеллект (если он у тебя включается вообще). Люди беруться судить о perl не осилив его в достаточной мере. Более того, люди вязнут уже на этапе анализа однострочника. Однострочник - тот же самый код, но лишь без пробелов/табов и переноса строки. Структура исполнения кода сохранена и не скрыта. Структура программы в однострочнике явная. Я об говорю о том что еще не успели разобрать структуру исполнения кода (а завязли на самой поверхности) а кричите что код нечитаем.

Понимаешь ли ты суть слова «однострочник» ? «Одно»+«строчник», то есть одной строкой. А что будет с одной строкой если добавить перенос строки? Твоя недалекость - это проблема личного характера или это характерно для программистиков на питоне?

Не можешь разобрать код как он представлен - открой для себя perltidy.

systemd загружает систему (в данном случае Arch) быстрее сисвинита. Это факт.

этот факт доказывает только кривизну SysV в арче. В systemd арчеводы ещё не успели запустить свои потные ручки - это не проблема, качай апдейты...

Короче, УМВР, ЧЯДНТ?

откуда я знаю, чем у вас там инит занят? Явно не bash'ем. Лично мне вообще непонятно, ЧТО делает инит? Железо инициализирует? Сеть включает? Тогда как программно можно повлиять на это? Вот расскажи мне, если я поставлю себе systemd, то dhcpd моего провайдера будет быстрее выдавать мне IP? Или может HDD будет быстрее монтировать ФС? Или ЧТО?

А вот ленартоподелки типа пульсы

ну вот davfs например вполне годно. Яндексдиск тупит, но это скорее к яндексу.

и мамонтоподелки типа ed терпеть не могу.

кто тебя заставляет юзать ed?