Почему lua?

Потому что лучший среди всех в своей сфере применения.

Да я ему в том числе и пишу)

Ну, мне объяснять не надо, я не забиваю гвозди микроскопом. Но так как я использую awesome в качестве менеджера окон, то кое-где приходится; подгорает, но я успокаиваю себя тем что это не прод ☺.

и в lua настраивается, берёшь и начинаешь с 0, массивы же на самом деле словари. Только # и стандартную библиотеку к такому массиву не применишь, ну на ней всё равно далеко не уедешь

не заброшен

/usr/bin/time -f "user time: %U s; memory: %M kb"  luajit mandel.lua > /dev/null
user time: 0.33 s; memory: 2152 kb
/usr/bin/time -f "user time: %U s; memory: %M kb"  lua5.3 mandel.lua > /dev/null
user time: 8.48 s; memory: 2444 kb
$ /usr/bin/time -f "user time: %U s; memory: %M kb"  luajit fasta.lua 1000000 > /dev/null
user time: 0.29 s; memory: 2292 kb
$ /usr/bin/time -f "user time: %U s; memory: %M kb"  lua5.3 fasta.lua 1000000 > /dev/null
user time: 7.51 s; memory: 2580 kb
$ /usr/bin/time -f "user time: %U s; memory: %M kb"  luajit binary-trees.lua 12 > /dev/null
user time: 0.17 s; memory: 5904 kb
$ /usr/bin/time -f "user time: %U s; memory: %M kb"  lua5.3 binary-trees.lua 12 > /dev/null
user time: 1.08 s; memory: 6932 kb
$ /usr/bin/time -f "user time: %U s; memory: %M kb"  lua5.3 scimark.lua
Lua SciMark 2010-12-10 based on SciMark 2.0a. Copyright (C) 2006-2010 Mike Pall.
FFT         3.33  [1024]
SOR         7.36  [100]
MC          2.05  
SPARSE      2.22  [1000, 5000]
LU          2.86  [100]

SciMark     3.56  [small problem sizes]
user time: 24.13 s; memory: 3084 kb
$ /usr/bin/time -f "user time: %U s; memory: %M kb"  luajit scimark.lua
Lua SciMark 2010-12-10 based on SciMark 2.0a. Copyright (C) 2006-2010 Mike Pall.

FFT       888.41  [1024]
SOR      1332.96  [100]
MC        429.34  
SPARSE    879.76  [1000, 5000]
LU       2392.53  [100]

SciMark  1184.60  [small problem sizes]
user time: 29.30 s; memory: 2652 kb

Если бы ты потестил на реальных задачах, то увидел бы, что lua и без jit быстрая, и жрёт не намного больше luajit

Вот про «быстрая» — это точно не про Lua. И речь идет про один-два порядка.

Плохому танцору….

массивы же на самом деле словари

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

ну на ней всё равно далеко не уедешь

Предлагаете жить без информации о длине массива?

Это возмущение из-за неграмотности, т.к. индексы - это натуральные числа, а с нуля считаются сдвиги, поэтому в си *(arr + i) = arr[i], потому что i - сдвиг, а не индекс. Поэтому индексы с 1, сдвиги с 0.

Количество lua кода к Garry's mod значительно превышает объем пользовательского lua кода к упомянутому WOW. Фактически, почти весь код не относящийся к движку в GM - это lua код. И все довольны.

А то что сравнивают js jit, против интерпретируемого lua вас не смущает ?

А то что сравнивают js jit, против интерпретируемого lua вас не смущает ?

На больных не обижаются. ☺

метаметод длины меняешь и тоже будет работать, хотя на самом деле спор по поводу того что в луа массивы с 1 даже туповаты, т.к. так зато последний индекс = длине и возможен сахар в духе a[#a + 1] = 5 для заполнения массива и a[#a] = nil как для сброса крайнего, поэтому это срач ради срача, т.к. язык оправдывает такое использование индексов + многие забывают что с 0 начинаются сдвиги, а не индексы, а индексы как раз с 1.

метаметод длины меняешь и тоже будет работать

Ломает оптимизатор.

хотя на самом деле спор по поводу того что в луа массивы с 1 даже туповаты

Не туповаты, они ломают паттерны работы с массивами и провоцируют ошибки. Там где в массивах с нуля всё просто и понятно, в массивах с 1 надо будет везде писать +-1 и постоянно путаться.

возможен сахар в духе a[#a + 1] = 5 для заполнения массива

В массивах с нуля это будет a[#a] = 5, что короче и логичнее.

Ноль — следствие адресации, а не «потому что так захотели».

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

В чем разница?

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

В общем случае примения для него нет

Ты как всегда в своём репертуаре, проецируешь своё мнение на весь мир. Lua популярен и применяется очень много где по назначению.

всегда есть язык получше

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

1. НЕ может оно ломать «паттерны» в среде в которой нет таких «паттернов»

2. a[#a] = 5 будет выглядеть как выход за границы массива в сишной логике, а не как обращение к следующему, да и ирония в том, что тогда удаление будет a[#a-1] = nil, что мягко говоря, то что и было(вы просто поменяли местами логику обращения при вставке/удалении) и что тут понятнее и логичнее «стало» - не ясно - стало сишнее, т.к мы перешли от понятия индексируемого массива к массиву по виртуальному сдвигу, о котором придётся постоянно помнить, т.к. вы по сути «сифицируете» массивы, поэтому говнобагокод так писать будет проще, но нужно оно только религиозным фанатикам, т.к. язык эту фишку с индексами вместо сдвигов использует вполне лаконично.

потому что это сдвиг относительно адреса, а не индекс с которым путают - сдвиги с 0, индексы с 1.

индексы - это натуральные числа

Индексы - это «символы» (именованные значения), которые обозначают некоторое значение в некоторой области (знаний): индекс массы, индекс Доу Джонса. В качестве «символов» можно использовать счетное множество натуральных чисел, можно использовать строки в ассоциативном массиве . Значение a[-1] может означать последний элемент.

В общем, терминология такая терминология.

У меня обратная информация.

Я ему про общий, он про частный. «Ты как всегда в своём репертуаре».

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

К слову, не ради срача. А ты вообще разраб? Чем занимаешься?

Твоя информация не верна, если верить TIOBE.

в среде в которой нет таких «паттернов»

Альтернативно-одарённые среды, под которые надо переучиваться, не нужны.

стало сишнее

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

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

Не стоит так обобщать, обратное справедливо иногда и для массивов с единицы.

Пример – представление полных двоичных деревьев или тех же куч в виде массива. Если по индексу i у нас находится родительский узел, то 2 * i + 1, 2 *i + 2 – индексы его дочерних узлов для массивов с нуля и 2 * i, 2 * i + 1 для массивов с единицы.

Считать что сдвиги == индексы это тоже самое что считать массивы == ассоциативные массивы. Это фундаментальная матчасть. Если ты программируешь на языке в котром именно массивы данных и перемещаясь по ним думаешь что используешь индексы… У меня для тебя плохие новости, твои паттерны работы неверны от слова фундаментально.

Там где в массивах с нуля всё просто и понятно

Дело не в просто и понятно, а в том как на самом деле всё происходит.

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

«Не такие как все» язычки идут лесом. Хотя в остальном, конечно, Lua — приятный игрушечный язычок.

Ноль — следствие адресации

Нет. «Ноль» - это «ноль». «Ноль» в адресации с «ноля» - это следствие адресации с «ноля».

Не стоит так обобщать

Ещё как стоит. Возьмите хотя бы полуинтервалы и разбиение массива на подмассивы.

int a, b, c;
c = a + (b - a)/2;
for (int i = a; i < c; i++) arr[i] = i;
for (int i = c; i < b; i++) arr[i] = -i;

и i, i + 1 для массивов с единицы.

Почему у дочернего элемента индекс вдруг такой же, как и у родительского?

Нужно больше грибов.

Это фундаментальная матчасть

Нет, это пустой терминологический спор. Индексы с нуля и точка. По определению. Никакие «сдвиги» не нужны.

Не стоит так обобщать

Why numbering should start at zero (c) E. W. Dijkstra. Вирт тоже за нулевые индексы. Их сложно заподозрить в любви к Си. Даже в некоторых областях математики индексы с нуля.

Нужно больше грибов.

Иди лучше, борщ вари до превращения в прозрачные щи.

Нужны i=0 нулевой сдвиг arr[i] первый элемент массива что тоже самое что и просто arr. Это нужно знать и понимать как минимум потому что тут для доступа к элементу нужно только взятие адреса и всё. А для i=1 нужно взятие адреса, смещение, MMU проверка, возможно смена таблицы адресов, выгрузка из кеша предыдущих значений, переключение контекста, ещё раз взятие адреса и уже можно читать данные. (Это для пограничного случая, но такие в любой программе случаются сотни миллионов раз в минуту тормозя себя и все другие программы). Индекс это часто просто обиходное слово.

Не цветом борщ ценен.

Почему у дочернего элемента индекс вдруг такой же, как и у родительского?

Там 2 * i, я через 30 секунд поправил, а ты уже успел ответить.

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

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

более простые формулы с меньшим числом действий без +-1.

Без свеклы это уже щи ::)

Альтернативно-одарённые среды, под которые надо переучиваться, не нужны.

Новорожденные с вами полностью согласны, ведь «эти тупые взрослые» учат в своей среде ходить и говорить как все другие люди….

понижает риск ошибок

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

Только для сишников, которые не умеют приспосабливаться

E. W. Dijkstra. Вирт тоже за нулевые индексы. Их сложно заподозрить в любви к Си. Даже в некоторых областях математики индексы с нуля.

мне в целом без разницы

Значит вы не писали сложных алгоритмов и использование массивов ограничивалось паттерном foreach.

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

в луа нет указателей

Есть. Там таблицы со встроенным указателем. Пример:

a = {a=1}
b = a
b.b = 2
print(a.b)

Выводит 2.

более того один из прародителей луа - паскаль

В следующей версии Паскаля — Обероне тоже сделали индексы массивов с нуля

Значит вы не писали сложных алгоритмов и использование массивов ограничивалось паттерном foreach.

Быстро же ты сдулся, писатель сложных алгоритмов.

Только для сишников, которые не умеют приспосабливаться

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

Луа юзают в 80% случаев именно с Си. И сишники же пишут и на том и на том, понимая что в некоторых случаях lua выгоднее, удобнее и прикольнее одновременно с монолитной по сути организацией вместе с сишным кодом. И никаких проблем с массивами нет если понимаешь как они работают там и там. Это проблемы у тех у кого только синтаксис языка в голове и краткая инструкция что оно делает. А почему и как похеру, от того и возмущения мол «а чё тут не так как тут!» Понятное дело что унификация подобных вещей ценна и было бы возможно лучше если бы в lua была подгонка небольшая, но в целом проблем нет.

Как вы образование то получали, если вы предлагаете язык сценариев использовать для написания сложных алгоритмов ?(может молотком и плов кушать предложите?) В остальном это зависит от алгоритма и его понимания и тут бывают как усложения, так и упрощения, например повторюсь взятие последнего элемента это a[#a] и достойным контраргументом было бы не абстрактное «есть такие сложные алгоритмы», а непосредственный пример алгоритма, который при такой индексации выглядит дико по сравнению с алгоритмом адресующемся по сдвигу.

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

В том и вся суть, что Lua — игрушечный язык, а всё серьёзное пишется на Си. Обработка массивов скорее всего будет написана на Си, а для Lua будет только интерфейс.

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

а непосредственный пример алгоритма, который при такой индексации выглядит дико по сравнению с алгоритмом адресующемся по сдвигу.

Почему lua? (комментарий)

http://lua-users.org/wiki/CountingFromOne

Просто обычным людям удобно считать с 1 вот и вся причина. :)

Ссылки, а не указатели, указатели в это не столь косвенная адресация, сколько адресная арифметика, обращение к «сырым» данным, а не псевдонимы.

А ничего, что он встраиваемый?

как это противоречит тому, что я написал ? Я сам пишу на си и люблю луа и отссылка к «сишникам» была отсылкой к закостенелым ребятам, для которых «индексы с 1 - конец света» и у меня лично это никаких трудностей не вызывает.

Это проблемы у тех у кого только синтаксис языка в голове и краткая инструкция что оно делает.

Вы хотели чего-то другого от зубрилок ?)

Ссылки, а не указатели

Ссылка — это void Do(int &x);.

указатели в это не столь косвенная адресация, сколько адресная арифметика

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