Повторюсь: если у тебя бесконечное количество времени и ресурсов — вперед писать только хороший код и «чуть-чуть» думать.

Если разница между «в лоб» и «красиво» занимает тыщу строк — я выберу в лоб в рамках реалий/времени

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

Если на задачу у меня есть неделя — решение одно. Если полгода — другое. Умение принимать решения исходя из этих переменных и есть уровень профессионализма

в лоб - это как раз обычно 1000 строк, а красиво и подумав в 50 строк умещается и работает в 5 -10 раз лучше

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

Да, да, испортить можно что угодно, и переписывать всякую ерунду.

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

вот корутины я так еще нигде и не прикрутил

даже вебсокеты на libev взял

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

все возможно, если логи правильно писать

я о том, что он непредсказуем

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

я так только первые разы думал, а потом оказалось что все предсказуемо, если есть опыт

я имею ввиду, что автоматические тесты на нем могут иметь false positive

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

function readfile(filename, mode)
 local block, done = {}, false
 local function pipe(async_chunk)
   if not async_chunk or #async_chunk == 0 then
     done = true
   end
   block[#block + 1] = async_chunk
 end
 asyncioread(filename, mode, pipe)
 while not done do coroutine.yield() end
 return table.concat(block)
end


local userfunction = function(...)
 something = readfile("myfile.txt")
 anotherthing = readfile("myfile2.txt")
 ...
end

local routines = {}
table.insert(routines, coroutine.new(userfunction))

while 1 do
 for i, co in ipairs(routines) do
   if not coroutine.resume(co) then
     table.remove(routines, i)
   end
 end
 process_events_like_asyncioread()
end

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

Соответственно, если все потенциально лочащие функции асинхронны (сетевые запросы всякие, чтение с диска преимущественно) — оно параллельно в одном потоке обрабатывает тысячи пользовательских функций, и они как бы не мешают друг другу, а пользователь пишет самый тупой и прямой в мире код без единого колбека, который просто выполняется асинхронно.

Я просто уже насмотрелся на такое (в более патологических случаях), и дошёл до того что везде (ВЕЗДЕ) в жаваскрипте дёргаю async-await, который суть то же самое что я сейчас набросал на корутинах, только более явное, чтобы писать нормальные, прямые тупые последовательные штуки с околонулевой вложенностью, и не трахаться с колбеками ))

Кстати, сюда же можно пихнуть sleep в таком виде:
function co_sleep(delay)
 local timeout = os.clock() + delay
 while os.clock() < timeout do
   coroutine.yield()
 end
end

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

Ооо, телега продолжается. Я ещё вспомнил что чинил этим же способом проблемы многопоточности и остановки потоков у lanes — оно требует, чтобы "код двигался" для проверок, может ли тред самоубиться по внешнему сигналу или нет. Про него конечно можно "забыть", мол "закроется когда-нибудь потом, а результат мы выдадим уже сейчас" но оно может привести к переполнению тредов в ОС и падению всей приложули на всяком хайлоаде. Соответственно всё io можно сделать асинхронным/на корутинах, чтобы корректно убивать поток в любой момент, и я это уже делал, для отрубания тасок.

И даже без lanes — всякие sleep'ы и прочие хттп-запросы могут возвращать специальную ошибку, мол "данная задача истекла по времени, завершайся", и пользователь быстро свернёт свой код, остановив корутину по внешнему таймауту. Тут уже, правда, нужна минимальная дисциплина, и при внедрении этой фигни в уже существующую платформу может потребовать кучи переписываний.