Alex

Во всех примерах это работает именно так...

Не верю.

bot.register_next_step_handler() принимает обработчик следующего сообщения, а не кнопки. Собственно, твоя функция и получает объект сообщения.

1. Как происходит связь между кодом js, c++. На самом гитхабе Nodejs можно открыть папки с функциями, которые я импортирую в коде. А также их реализации в файлах .cc расширения. Но не могли бы подробнее описать механизм, которые позволяет 2 разных языка использовать.

JS движок (например V8) предоставляет платформе (Node.js) некоторый C++ api, через который платформа может движком управлять. Например через это api можно дать движку строчку с JS кодом и попросить его выполнить, а в ответ получить указатель на результат выполнения (V8 например возвращает результат последнего выражения в коде). Так же, если у нас есть указатель на JS функцию, можно попросить движок ее выполнить с определенными аргументами и this, а в ответ получить результат этого выполнения (функция что-то вернула или бросила исключение). Ну и наконец, мы можем дать этому api указатель на C/C++ функцию, а движок сделает из нее JS функцию и вернет указатель на нее, когда JS функция вызывается движок вызовет нашу C/C++ функцию и даст ей на вход контекст выполнения, из которого можно извлечь this и аргументы функции, так же через контекст можно установить результат выполнения JS функции, указав что JS функция должна вернуть некоторое JS значение или бросить некоторое исключение.

2. V8 - движок для исполнения JS кода, то есть превращения его в машинный код для исполнения комманд. Libuv написана на с++. Они же не работают в паре? Я так понимаю, что часть кода исполняется на движке v8, а различные асинхронные вызовы, которые через Nodejs api делегируются библиотеке Libuv - уже от неё превращаются в низкоуровневый машинный код, который исполняется компьютеров?Можете чуть пролить свет на исполнения уже между этими компонентами Libuv, V8.

V8 ничего не знает о libuv, как и libuv ничего не знает о V8.
V8 занимается компиляцией/интерпретацией/выполнением JS кода, управлением JS памятью и некоторыми другими связанными с JS вещами. В V8 нет никаких event loop и чего-то подобного, он запускает JS код только когда ему об этом скажет платформа (например Node.js).
Libuv занимается асинхронными операциями. Что-то переадресует операционной системе, например сетевые сокеты можно собрать в пачку и отдать в epoll в Linux или kqueue в MacOS, заблокировав лишь один поток сразу на тысячи сокетов. А что-то просто блокируется на фоновых потоках, например обращения к файловой системе. Event loop нет и здесь, но зато есть очередь задач, которые потенциально готовы.
Ну и наконец сама платформа (Node.js) реализует event loop (по сути просто бесконечный цикл), в котором получает потенциально готовые задачи от libuv и раскладывает по своим очередям готовые, а неготовые планирует в libuv, спрашивает у V8 не хочет ли он сделать сборку мусора, ну и наконец говорит V8 вызвать некоторые JS функции.

3. После того, как Nodejs передает асинхронный вызов Libuv на исполнение. То callback функция помещается позже в стэк для исполнения, а исполнятся начинается после того, как система просигнализирует о завершении процесса, например считывания файла. Или вначале считывается файл, а потом система об этом сигнализирует и помещается callback функция в стэк Event Loop'a для исполнения?

Выше уже расписал как Node.js взаимодействует с libuv в теле event loop, так же расписал как JS код может вызвать C++ функцию. Рассмотрим на сильно упрощенном примере, что происходит когда в JS коде на Node.js мы вызываем fs.readFile(filepath, callback):
1. fs.readFile - это обычная JS функция, но внутри она вызывает некоторую C++ функцию из Node.js, которая получает указатель на строку filepath и указатель на JS функцию callback, но эта C++ функция будет запущена на том же потоке где и event loop (по сути где-то внутри цикла), а блокировать нам нельзя. Поэтому она просто планирует вызов другой C++ функции на фоновых потоках и завершается, возвращая тем самым управление JS коду.
2. В какой-то момент до запланированной C++ функции дойдет очередь на выполнение на одном из фоновых потоков, она прочитает файл в память и добавит в очередь готовых задач некоторый объект, который является результатом операции чтения из файла, этот объект будет хранить в себе указатель на прочитанные данные и указатель на JS функцию callback.
3. Еще через некоторое время поток с event loop извлечет из очереди этот объект результат и скажет V8 вызвать функцию callback с данными из файла.

4. Можете более подробней рассказать про исполнение кода на инстансах приложения в зависимости от количества ядер процессора и управления потоками:

4.1 Есть к примеру приложений на Nodejs. На компьютере 4 ядра. Я на каждом ядре могу запустить инстанс этого приложения. И у каждого инстанса в pool thread'e будет по 4 потока дополнительных, которые создаются по умолчанию?

Каждый инстанс Node.js - это отдельный процесс операционной системы. У каждого процесса своя изолированная память. И да, каждый может запускать несколько потоков (у Node.js кстати 4 потока - это минимум, при большой нагрузке она может добавить в пул до 128 потоков), но в случае с Node.js большая часть потоков почти всегда что-то ждут (пока тот же файл прочитается например) и почти не тратят ресурсы CPU, а активно работает лишь один - тот в котором event loop.

4.2 Если отойти от ноды и запустить приложение на php фреймворке на Apache и этот сервер выделяет под каждый запрос свой поток.В данном случае - это такой же условно поток, который может выделяться и библиотекой Libuv или это абсолютно разные понятия? И сколько инстансов php приложения запущено, когда Apache под каждый создает свой поток? Как соотносится поток с инстансом приложения на php.

С точки зрения операционной системы - да, это такие же потоки. Разница заключается в том, что в этих потоках происходит. В php только 1 поток, который то что-то полезное делает, то ждет ответа от БД/файловой системы/еще чего-то. А в Node.js это разделено, 1 поток занят только полезной работой (выполнением JS кода) и несколько только ждут ответа.
Насчет какие там лимиты на количество инстансов php у Apache я не скажу, но они точно не бесконечные, а значит если лимит будет исчерпан, то клиенты (браузер) будут ждать пока какой-то из инстансов php не завершит свою работу полностью. А в node.js мы на одном инстансе можем обслуживать сразу множество клиентов, выполняя задачи для каждого по чуть-чуть, пока для одного клиента ждем ответ из БД можем заняться обработкой запроса от другого клиента.

4.3 Может в дополнение расскажите про потоки в системе, их ограничения и т.д

Тут целую лекцию можно читать. Думаю это стоит вынести в отдельный вопрос.

Не претендую на правду. Просто несколько мыслей.

В чем минусы событийно ориентированного подхода?
Насколько я понимаю, Алан Кей (тот кто придумал термин Объекто-ориентированный) старался придерживаться именно этого подхода. т.е. кто-то отправляет сообщение, а объекты в системе на него реагируют, каждый по-своему.
По сути у нас есть message bus, в который добавляется сообщение, а объекты системы слушают этот самый message bus.

Мысль первая. Наследие.

Когда мы говорим о наследии Алана Кея - надо просто глянуть что он создал практически.
А создал он язык Smalltalk. Поэтому логично изучать минусы событийного подхода на
примере софта который написан с использованием Smalltalk. Кто из коллег в топике
знает примеры такого софта? Я - к сожалению не знаю.

По ссылкам википедии https://en.wikipedia.org/wiki/Smalltalk можно видеть в категории
influenced мы просто видим что Smalltalk
влиял на Java, Go, Swift. Но я здесь не согласен потому что мы не можем измерить глубину
этого влияния. Это все равно что сказать что Сталин влиял на Черчилля. Как влиял? На 10%?
Или более чем половину? Сложно. Насчет Java я тут сказал-бы что сомнительно. ООП? Может быть.
Акторы? Нет. В Java изначально нет акторов. Они существуют позже в виде фреймворков но
языком не поддерживаются.

По поводу MessageBus. Если брать технологию акторов которая используется в Erlang.
то там скорее не message bus а очереди сообщений между потоками-акторами.
Если про Smalltalk сказать нечего то про Erlang я могу сказать что на нем написаны
две единицы софта такие как RabbitMq (очень надежная и неубиваемая система MQ).
Может не супер-производительная. И CouchDb которая выделяется своей
устойчивостью ко всяким сетевым сбоям. Реклама говорит что Кауч работает
практически при мигающей сети, при обрывах и т.п. лучше чем аналогичый TCP-IP совт.

Мысль вторая. Что Кей говорил про ООП.

У меня есть цитатник. Я туда собираю некоторые слова на лытни. И иногда слова Кнута, Дейкстры
и прочих it-академиков. Вот из цитатника Кея:

I made up the term "object-oriented," and I can tell you
I did not have C++ in mind.

Что в этой прямой речи можно понять. Что господин Кей открещивается от современного ООП.
А фактически все современное ООП зеркалит то что есть в С++. Здесь вы можете со мной спорить
о первенстве (я не буду спорить я не знаю). Но абсолютно очевиден факт что мир пошел по пути
жесткой синхронщины в 80х. И пока все еще идет. Будут ли примитивные типы int/double обьектами
не суть важно. Тут важно что Кей постулирует среду в которой двигаются сообщения. Как сеть в миниатюре.
А классическое ООП С++ - лишает нас этой среды и заменяет ее вызовом метода. Никакого сообщения
в С++ нет и быть не может потому что сообщение НЕ существует в отрыве от основного потока который
инициировал вычисления. Умрет поток - развалится весь стек и параметры и все. В противоположность
в языке Erlang поток (процесс) приёмник может дохнуть много раз но стек сохраняет свою живучесть
просто повторяя вычисления заново. И здесь мне кажется и идет развилка путей.

И здесь как-раз мы может говорить о недостатках. Очевидно что у нас появляется лаг приемки-передачи
сообщения. У нас появляются мягкие гарантии времени обработки. И многое другое.

Интересно почему в 80х Алан Кей проигрывал. Я думаю что победил прагматизм. В те далекие 80-е
комьютеры были еще слабыми. Частота мерялась сотнями килогерц и мегагерцами. И в расчетах
каждый такт был важен. И красивые и академические языки такие как Lisp, Prolog, Smalltalk
просто проигрывали языку С в силу оверинжинеринга. А поскольку С++ был вначале действительно
ООП-надстройкой над С - то он предлагал и ООП-подход и скорость портабельного ассемблера.
И хотя я лично не люблю С++ (я считаю его перегруженным техническими долгами прошлого)
я признаю что бизнес выбирая С++ выбирал просто скорость вычислений. Академизм и красивые
доказательства правоты программ были тогда не нужны. Нужно чтоб банковское приложение
быстро считало кредиты и выдавало зарплаты и пенсии.

Сегодня, когда мы нежемся в сладкой неге мощных процессоров и даже (!) облаков - мы можем
себе позволить любого уровня парадигмы и абстракции. Цена 1 абстракции стала настолько дешево
стоить что нам дешевле в банках запускать Java/Net приложения и на ходу фиксить ошибки
чем долго разрабатывать на С++ и иметь неопредленнное поведение и тяжелый анализ
в случае падения. Даже такой уродец как Python взлетел как язык интеграции а не разработки.

Мысль третья. Нестандартные и асинхронные архитектуры реализованные в железе.

Недавно смотрел анонс нового процессора от Чака Мура (это тот самый Мур который создал закон имени себя).
Мне кажется это пример той самой асинхронной клетки о которой мечтал Алан Кей.

Мысль четвертая. На кого похож Алан Кей?

Не знаю как вам. :) А мне он уж очень напоминает Боливара Траска из Люди Икс Дни Минувшего будущего.

Мысль 5. Что делает Алан Кей на фото?

Бренчит на музыкальных инструментах. Наверное блюз. Блюз потерянных архитектур :)

Опишу простыми словами для упрощения понимания.

модульное тестирование

Тестирование конкретного модуля. Обычно - это самый нижний уровень, отдельные простые классы, т.е. ниже по логике уже будут отдельные функции. Например, в JS есть класс Math - тестирование всех его методов и есть модульный тест. Конечно, границы между логическими уровнями могут быть размыты и в данную категорию вполне можно вписать класс уровнем выше. Так же, модулем может быть и что-то более сложное - опять же, много зависит от масштабов и особенностей архитектуры.

интеграционное тестирование

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

функциональное тестирование

Очевидно, что тестируются конкретные функции, которые есть в техническом задании. Например: когда пользователь нажимает кнопку "купить" в карточке товара - товар добавляется в корзину.

какими инструментами оно делается?

Инструментами автоматизации GUI - для сайтов это Selenium и браузеры. Для десктопных/мобильных приложений аналогичные решения.

приемочное тестирование

в че отличие от интеграционных.. еще видел фразу что тут и фронт и бек тестируются, но яснее не стало, какими инструментами оно делается?

"Бизнес" заказал в "Конторе" разработку сайта, выдал ТЗ, контора сделала сайт, бизнес заплатить денег обещал. Как бизнес проверит что контора сделала именно то, что он хотел? Через приемочное тестировние - бизнес получает доступ к сайту и проверяет, что сайт именно такой, какой он заказывал в ТЗ, а не тот, который сделали индусы за доширак. Если в ТЗ указан конкретный список тестов/фич - используется этот список или так, как прописано в ТЗ само тестирование. Само тестирование проводит соответствующий специалист (инженер отдела качества) - тыкает все кнопочки, нажимает менюшечки и говорит начальству "все окей, подписывай и платим им деньги" или "вот тут и тут не окей, не подписывай, денег не давай". Реальный пример: была заказана и собрана станция спутниковой связи, на приемке были представители заказчика и исполнителя, была толстая пачка бумаги на несколько сотен страниц, по которой первые проверяли что все работает именно так, как там написано в течении нескольких недель (плюс-минус), а вторые исправляли косяки показывали что все окей, потом все поставили свои галочки и крестики и разъехались по домам.

E2E - тут тестируется чрез браузер, с помощью Mocha и тп, те тестируются "требования бизнеса к приложению", тестируются пользовательские сценарии.. а в чем отличие от функциональных тестов тогда?

Сквозное тестирование. Это полная проверка от начала и до конца. Отличие от функционального в том, что это более комплексный тест. Если функциональное тестирование - это проверка конкретной функции, тот сквозное - работа всего приложения, т.е. более комплексное. Например, E2E тест приложения для загрузки файла на сервер: тест включает в себя запуск приложения, авторизация пользователя, выбор файла, указание мета информации, загрузку файла на сервер, выход из приложения. Вот тут неплохая статья на хабре: https://habr.com/ru/company/otus/blog/681066/

Совсем запутался, с unit только понятно, а как уложить и разделить остальные?

Картинка отсюда: https://www.rainforestqa.com/blog/the-layers-of-te...

queue = [...newData, ...queue].slice( 0, queLength )

парень. Всё равно ты будешь использовать ту терминологию, которую используют на работе. Если там под замыканием подразумевается замыкание с инкапсуляцией, то после того как тебе сказали что "твой код - говно", было два варианта: 1)поговорить о терминах либо со ссылкой на официальную документацию, либо вместо с собеседником вывести определение исходя из смысла понятия, не прибегая к авторитетам вообще. 2) Сказать о том, что прочитал такое определение у %авторитет%, и сказать, что готов использовать то, которым пользуетесь вы на работе.

По поводу выведения определения: есть смысл замыкания. Его нужно чётко озвучить согласиться с ним. Например, ты хочешь сказать, что смысл замыкания это ничто иное как "повесить ссылку на переменную с которой окончена работа до объявления функции, для сейва от мусорщика". Спросить - согласен ли с этим собеседник, или есть дополнения/возражения. Если согласен - значит "функция, являющаяся замыканием - любая функция, которая ссылается на переменную вне своего тела, в случае если переменную иначе удалил бы сборщик." Далее нужно договориться, что "иначе удалил бы" можно опускать как лишнюю сущность, которая усложняет определение такой функции, и упростить до - "функция, ссылающаяся на переменную вне своего тела."

Есть второй вариант: собеседник тебе говорит: "Ахтунг! Замыкание используется не просто для того, чтобы спасти переменную от удаления! Это ещё и способ сокрытия данных: замыканием можно использовать локальную глобальную переменную, вместо того чтобы использовать просто глобальную переменную, или же городить отдельный класс."
В этом случае всё твое определение идёт в пешее эротическое, и ты соглашаешься, что для этого придётся обернуть функцию в функцию, чтобы у тебя была функция с локальными переменными, которые будут глобальными для этой функции в функции.

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

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

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

1. Поиск хэша по "радужным таблицам" (rainbow tables): огромным базам данных, где собираются заранее посчитанные хэши для любых возможных строк.
   
2. Метод грубой силы (bruteforce): перебирать все комбинации символов и применять к ним хэширующую функцию до тех пор, пока она не вернёт искомый хэш.
   
3. Поиск по словарю. Похож на брутфорс, но перебор не всех возможных значений, а всего нескольких тысяч самых популярных паролей, типа "123", "password" и пр.
   

phpfaq.ru/tech/hashing

И только одного элемента недостаточно, а нужны все в комплексе:
- Хэширующая функция должна иметь большую вычислительную сложность, чтобы усложнить подбор перебором. по этой причине md5() не подходит
- Хэш должен быть посолен уникальной солью, чтобы нельзя было, затратив 1 раз кучу вычислительных усилий, заранее построить хэши для любых комбинаций символов. По этой причине фарш без соли - деньги на ветер.
- Пароль не должен быть слишком простым, иначе даже медленный перебор его раскроет. Этот момент тоже надо учитывать

1 вариант: Все логи отправляются в один микросервис.

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

А вот как это делать - уже разные варианты есть.

Ваше приложение может писать в stdout, и если вы пользуетесь чем-то вроде kubernetes/openshift, то это удобно ловить централизировано сразу на кластере, тегировать по имени приложения/пода и отправлять дальше.

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

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

Ваше приложение может писать логи прямо в базу данных. Даже в sql базу, или прямо в elastic.

Ваше приложение может писать просто в лог файлы, а потом эти лог файлы собираются, парсятся, отправляются в лог аггрегатор.

В общем на любой вкус и цвет. Определитесь с объемом логов, с пиковыми моментами, с тем что вы хотите делать и сделайте общий стандарт для всех ваших компонентов.

2 вариант: Каждый микросервис пишет собственные логи в своем хранилище.

Ну можно и так.

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

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

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

Вот даже здесь, поскольку fopen работает поверх абстракции, нельзя говорить о едином подходе.
Если у нас самый простой случай - локальный файл - то РНР оборачивает функции для работы с файлами языка С в свою собственную абстракцию. Но ниже - на уровне этих самых функций языка С - никаких потоков нет. Есть обращение к функциям операционной системы, которые просто позволяют прочитать выбранный кусок файла.
Тут никаких вопросов нет, всё честно - если мы прочитали из файла 5 килобайт - значит потратили ровно 5 килобайт памяти.
Но работаем мы с файлом не считывая его весь в память не потому что поток, а потому что так устроена файловая система. А поток этой возможностью только пользуется.

Если же мы открываем не файл, а URL, то РНР начинает извращаться, пытаясь предоставить те же самые инструменты, какие мы используем для работы с файлами, для доступа к ресурсам совершенно другого типа.
И здесь возможны нюансы. Я не знаю, как реализован HTTP wrapper, но в теории HTTP позволяет чтение произвольного объема данных через заголовок Range:. То есть РНР вполне может читать и из НТТР кусками, а не целиком.

В общем поток - это абстракция. Подход. Интерфейс. Способ работы с массивом информации не забирая её всю в память.
При этом реализация конкретного инструмента, использующего этот подход, может быть совершенно самостоятельной, никак с другими не связанной. Мне кажется, что именно этот момент является для вас камнем преткновения: на техническом уровне это совсем не обязательно одни и те же потоки. Но вполне могут быть.
При этом важно не смешивать сам поток и его получатель (получатель вполне может накапливать всю информацию из потока).

А упомянутый в вопросе PSR-7 вообще никакого отношения к потокам в РНР не имеет. Это совершенно отдельная реализация принципа потоков, которая не имеет отношения к потокам в РНР.

Есть встроенная библиотека crypt

from crypt import crypt

print(crypt("hello world", "ab"))

В python есть такая же функция в модуле crypt.

$hash = crypt ($password, $salt);

from crypt import crypt
hash = crypt (password, salt)

Они установливают PAC-скрипт с помощью chrome.proxy.settings.set.

В этом JS файле описана логика для браузера, как (через что) устанавливать соединения.