1. JavaScript / Говнокод #27251

    −1

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    let d="please like! "
    var c=d
    let x=s=>{for(let f=0;f<c.length;f++){eval(s)}}
    x("d=d+d")
    x("console.log(d)")

    На каком языке это получится сделать короче?

    Запостил: prefix-not, 12 Февраля 2021

    Комментарии (106) RSS

    • Что этот код делает?
      Ответить
    • Питон:

      f = lambda n, g: exec((g + "\n") * n)
      f(2, "print('kokoko')")


      Джаваскриптц официально соснул, что и требовалось доказать в очередной раз.
      Ответить
    • for i=1, 2 do
        load("return function() print('kokoko') end")()();
      end
      Ответить
      • Более похожее
        Ответить
        • Можно и без цикла. Просто лоадить и выполнять
          Ответить
        • x = load
          d = 1
          x("return function() d=d+d end")()()
          x("return function() print(d) end")()() --2

          Можно ещё короче по убирать ретюрны и функции - но мне лень.
          Ответить
    • На суахили
      Ответить
    • let x=s=>{for(let f=0;f<c.length;f++){eval(s)}}


      фу

      let x = s => c.split('').forEach(() => eval(s));
      Ответить
    • >eval
      извини, мне мама запрещает трогать eval (разве что в tcl можно, кстати на нем так примерно и будет)
      Ответить
      • Ну, тогда потрогай xss
        Ответить
      • eval здесь для красоты. Можно и просто лямбду передать, всё равно никаких манипуляций с кодом нету.
        Ответить
        • Покидаю аз вертеп сей. Покедово!
          Ответить
        • ну да, там eval чтобы в теле s сослаться на s, правда я хз как тебе тут поможет лямблия
          Ответить
          • x() принимает некий код и исполняет его c.length раз. С самим кодом ничего не происходит, его дословно исполняют. Т.е. возможности eval'а в данном коде не раскрыты и его можно выкинуть нахуй, заменив на обычный вызов.

            По сути я и на кресты могу переписать:
            std::string d = "please like! ";
            std::string c = d;
            auto x = [&](auto s){for (auto f : c) s();}
            x([&](){d += d;});
            x([&](){std::cout << d << std::endl;});
            Ответить
    • Ребята evel там для выполнения инструкций из prompt и ему подобного!
      Ответить
      • eval из лямбды никто не мешает вызвать, если он реально понадобится в каком-то месте. Нет никакого смысла всё подряд гонять через eval.
        Ответить
        • У каждого свое мнение ;)
          Ответить
          • Использование eval это зло.
            Во-первых не быстро, во-вторых не безопасно. Это, в общем, мнение любого нормального программиста
            Ответить
            • С фига не безопасно то?
              Ответить
              • с того, что ты не знаешь, что делает твоя программа, если передаешь туда ввод от пользователя
                Ответить
                • Это js же, от кого там защищаться? Пользователь и так в дебаггере что угодно сделать может.
                  Ответить
                  • Ну да. Если сделать поле ввода с кодом JS, то это безопасно. А если в url закодировать ввод, то могут за тебя набрать код и куки спиздить (XSS).
                    Ответить
                  • а с чего ты решил, что это локальный js?
                    Ответить
                    • С того, что нода нинужна. Поэтому я её не рассматриваю.
                      Ответить
                      • Нода неплохо работает, джитится (в отличие от питоноговна), умеет libev и позволяет единнобразно писать говно двум сортам веб-макак: фронтомакаке и бекомакаке.

                        Уменьшая количество макак ты уменьшаешь потребность в бонанах.

                        Как программист, я разумеется считаю, что нода не нужна (как и JavaScript)
                        Но как реалист, я вынужден с ней мириться
                        Ответить
                        • > умеет libev

                          Всмысле изкоробки? Так то gevent в питоне тоже её юзает.
                          Ответить
                          • блядь, почему я сказал libev?
                            libuv конечно. C рогатым динозавром
                            Ответить
                            • gevent вроде оба умеет. А в чём разница между libuv и libev? Просто тонкие обёртки над системными вызовами же.
                              Ответить
                              • не уверен, что libev умеет комплишн порты на винде. Алсо, она вроде более низкоуровневая.

                                asyncio в питоне правда наверное тоже все умеет

                                зы: о, какой документ годны нашел
                                https://gist.github.com/andreybolonin/2413da76f088e2c5ab04df53f07659ea
                                Ответить
                                • > комплишн порты на винде

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

                                  К слову, boost::asio юзает "виндовую" модель (proactor) а не "юниксовую" (reactor).
                                  Ответить
                                  • Я так понимаю, что для проактора нужно более сложную машинерю делать авторам ОС или библиотеки. Реактор же уходит корнями в древние вызовы типа select/poll (epoll/kqueue это их наследниеки), и потому более примитивен.

                                    Кстати, в винде еще есть оверлапнутное чтение, но оно вероятно уже никому не нужно.
                                    Ответить
                                    • > более сложную машинерю делать авторам ОС или библиотеки

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

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

                                        А как работает комплишен порт под копотом, кстати? берет ссылку на твой буфер, и копирует его тредами ядра?
                                        Ответить
                                        • > под копотом

                                          У винды всё ядро асинхронное и на коллбеках, для него этот паттерн вообще родной.

                                          Отправляет твой буфер низлежащему драйверу, подписывается на завершение записи, в коллбеке дёргает твой ИОЦП.
                                          Ответить
                                          • типа драйверу шлеца IRP какой нить, а он пишет, и шлет взад?

                                            мне было интересно, как драйвер получает мой буфер. Его что, копируют целиком в память ядра? Или он ходит в мою память?
                                            Ответить
                                            • > Или он ходит в мою память?

                                              Делает себе копию маппинга (MDL) на ту же физическую память, где лежит твой буфер, насколько я помню.
                                              Ответить
                                              • сиречь, смотрит в физическую память, но мимо моей таблицы.

                                                спасибо, понятно.
                                                Ответить
                                          • Если у винды под капотом колбеки, то это же reactor, или я не пони
                                            Ответить
                                            • У реактора ты получаешь событие "можно читать" и идёшь читать.

                                              У проактора ты идёшь читать, а потом получаешь событие "прочиталось".

                                              Коллбеки у них на разных фазах, короче.
                                              Ответить
                                            • Реактор:

                                              Ты: Привет, ОС! У меня есть восемь файлов, в какой из низ можно писнуть, и сколько?

                                              ОС: Ждите...
                                              ОС: Ждите...
                                              ОС: Так, в третий файл можешь писнуть 40 байт.
                                              Ты: спасибо, пишу....
                                              Ты: так, записал. Надо теперь передвинуть указатель буфера на 40 байт, и дождаться следующего разрешения, чтобы писать дальше.


                                              Проактор:

                                              Ты: Привет, ОС! Сейчас я запишу в эти восемь файлов по гигабайту говна. Скажешь, когда реально запишется?
                                              ОС: Ждите..
                                              ОС: Ждите..
                                              ОС: Третий файл записался.


                                              Эквилибристика с буфером снимается с хрупких плеч прогарммиста
                                              Ответить
                                              • К слову, современные железки сейчас ближе именно к проактору.

                                                К примеру, ты ставишь контроллеру задачу на чтение с диска или USB и выдаёшь ему буфера. А по завершении он дёргает тебе прерывание.

                                                Реакторная модель разве что во всяких ps/2 да uart осталась.
                                                Ответить
                                                • > ps/2

                                                  Видел тут клавиатуру, про которую было написано, что некоторые функциональные клавиши работают только при подключении по ps/2. Очень удивился
                                                  Ответить
                                                • Угу. С тех пор, как железки научились быть инициаторами транзакций и ходить в память (то есть стали проактивными, лол).

                                                  Во времена ISA это физически было не реально, без помощи DMA.
                                                  Ответить
                                                  • Ну даже ISA DMA -- это уже проактор. Ты заранее готовишь буфер, настраиваешь контроллер, кидаешь запрос диску. И потом получаешь прерывание о том, что всё записалось.
                                                    Ответить
                                                    • Так DMA был или отдельной микрухой 8237 (ну пока не перекочевал в чипсет) либо был встроен в IDE. А в общем случае железо было в этаким PIO: пишешь себе в порты, и оно с другой стороны вываливается.

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

                                                      * Железо само ничего не умело качать (было тупое, не имело DMA чипа)
                                                      * Железу не нужно было ходить в память, а только лишь отвечать на запросы, а значит сложный протокол битвы за шину(как в обычнои PCI) и адресации реализовывать не нужно (ISA проще чем PCI)

                                                      Пишут кстати, что в Solaris тоже есть аналог комплишенпортов
                                                      Ответить
                                              • Короче, этот тот же реактор, только на асинк/авейтах
                                                Ответить
                                                • Да, async/await это как раз сахар для проактора.

                                                  Действие выполняется где-то в фоне, а тебе возвращают некую хуйню, на которой ты можешь ждать завершения.
                                                  Ответить
                                    • > Реактор же уходит корнями в древние вызовы типа select/poll

                                      Интересно, а почему такую модель выбрали тогда?

                                      Поди ещё с каких-нибудь далёких однозадачных времён, когда select реально обрабатывал пакеты с карточки?
                                      Ответить
                                      • У них всяко была какая-то механика которая пробуждает блокирующий read и копирует данные в его буфер.

                                        Можно было бы для неблокирующего сокета в read запомнить адрес и размер буфера, вернуть какой-нибудь EPENDING и пометить сокет, чтобы последующие read'ы возвращали EBUSY. А тот код, который пробуждал блокирующие read'ы, мог бы скопировать данные в этот буфер и снять метку с сокета.

                                        А в качестве комплишен порта ты бы мог звать select, который рассказывал бы тебе какие сокеты вышли из pending'а.

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

                                        З.Ы. Буфера со стека вот нельзя будет юзать. Возможно, это было критично.
                                        Ответить
                                        • в нормальных юниксах кстати есть

                                          https://www.ibm.com/support/knowledgecenter/SSEPGG_10.1.0/com.ibm.db2.luw.admin.perf.doc/doc/t0054518.html

                                          но прыщам не дано
                                          Ответить
                                      • У мориса написано

                                        a select system call that allows device polling. Там речь правда про терминал, как чуть ли не про единственное устройство (книжка описывает BSD середины 80х).

                                        Так что не удивлюс, если select() читал прямо из железного буфера устройства (файла в /dev).

                                        Устройства наверное открывались эксклюзивно
                                        Ответить
                                        • Блин, вот я теперь из-за тебя хочу надеть программисткие носочки и засесть за написание операционки.
                                          Ответить
                                  • В чём разница?
                                    Ответить
                                    • псевдокот
                                      while (..) {
                                      numberOfBytes, descriptor = Poll(d1, d2);
                                      // I now can write n bytes from descriptor
                                      }


                                      vs

                                      p = CreatePort(d1, d2);
                                      d1.write(someData);
                                      d2.write(someData);
                                      p.waitForCompletion();
                                      Ответить
                    • Потому, что на сервере должно быть пхп.
                      Ответить
                      • Это ты так решил
                        Ответить
                        • да он шутит, на самом деле.

                          PHP должен быть в помойке, а не на сервере
                          Ответить
                          • PHP должен быть в облаке, чтобы высосать все деньги у программистов и они на какое-то время перестали делать ПХП.
                            Ответить
                            • ротоёб говорил, что когда у него что-то тормозит,он просто покупает более мощный сервер
                              Ответить
                              • В если программа в 1 поток работает?
                                Ответить
                                • Что значит если?
                                  Ответить
                                • тогда тем более логично купить еще более мощный процессор. Просто покупаешь самый дорогой ксеон, и все.

                                  когда наплыв на сайт закончится (ну там распродажа пройдет), ксеон можно будет продать
                                  Ответить
            • Пожалуйста без него и без фарфора
              let x=(d,s)=>{f>=d.length?0:s+console.log(d) +x(d,f++)};
              Ответить
    • процесс отсоса у руби очевиден
      D = "please like! "
      x = -> (v) { D.each_char { |c| v.call c } }
      x.call (->(c) { puts "letter: #{c}" })
      Ответить
      • letter: p
        letter: I letter: e letter: a letter: s letter: e letter: letter: I letter: i letter: k letter: e letter: ! letter:

        Даже inputa нет
        Б ееееее
        Ответить
      • Процесс отсоса очеиден не у руби, а ЗА руби. Положим, дали тебе брильянтов, да расстегнули пред тобой ширинку: соси, падла.
        Ответить
        • Руби нервно отсасывает в сторонке

          let d="please like! "
          let f=0
          let x=(d,s)=>{f>=d.length?0:s+console.log(d) +x(d,f++)};
          x(d,f++)
          Ответить
          • Я бы сделал как-то так:
            D = "please, dislike!"
            JOIN{$channel}
            on NICK{HALT};
            x = -> (v) { D.each_char { |c| v.call c } }
            ~x.call (->(c) { puts "letter: #{c}" })
            Ответить
    • Без eval, не смотрится ;(

      let d="please like! "
      let x=(s,c)=>{for(let f=0;f<d.length;f++){console.log(d)}}
      x(d)
      Ответить

    Добавить комментарий