Динамическая типизация — это не инструмент для разработки. Это чепуха (паршивая)



    В программировании очень много вещей, в которых я разбираюсь очень плохо. Настолько много, что меня иногда спрашивают — а в чем ты вообще разбираешься?

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

    Большую часть жизни я просто махал на них рукой и проходил мимо. Эти глупцы не понимают очевидных вещей, и я не нанимался разъяснять каждому js-нику, почему его код — это не разработка, а игрушечное прототипирование. Но время идёт, а количество идиотов вокруг и не думает уменьшаться, вместо того, чтобы всей своей фронтенд индустрией переехать наконец на статический тайпскрипт, эти ослы начинают использовать всякие кложуры, писать тонны тестов, и идти на все мыслимые ухищрения — лишь бы не разбираться в типах.

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

    Но сегодня я пришёл сюда, чтобы сказать:

    Динамическая типизация — адское говнище, а инженеры которые верят в такой подход — серьезно ошибаются.


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

    Противники статической типизации говорят, что все эти вещи не нужны. Они говорят мне, что

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


    Серьезно? Серьезно? Нам лень писать символы? Братан. Ты думаешь пять часов, а печатаешь десять минут. Ты инженер, так что попробуй посчитать, о каком эфорте ты говоришь. И не забудь, что со статической типизацией, или без нее, ты не раз в своей кодовой базе опишешь структуры объектов, с которыми будешь работать. Но если будешь пользоватся статикой, компилятор и IDE смогут делать эту работу за тебя. И проверять твой код на ошибки описания этих объектов. Если тебе лень писать аннотации типов к функциям — используй ЯП с выводом типов, или генерируй их с помощью расширений к IDE.

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

    Противники статической типизации говорят, что ранний отлов ошибок не так уж и важен.


    Ало. Ваша доска с задачами набита багами, которые допустили разработчики. Чинить баги — большая часть всей работы в индустрии. Мы тратим миллиарды человекочасов, чтобы пофиксить до нелепости смешные ошибки. Вы пишите код без багов? или у вас только умные баги? Да хрен там плавал. Если бы компилятор не проверял за вас, что вы закрыли фигурную скобку, поверьте мне, у нас были бы сотни багов с незакрытой скобкой.

    Когда думаешь о том, где баг потенциально может возникнуть, а где нет, появляется опасная иллюзия, что ты держишь ситуацию под контролем, и предусмотрел все кейсы. Я работаю семь лет, ещё ни разу не было такого, чтобы я предусмотрел все кейсы. Потому что это частный случай задачи коммивояжера — ты НИКОГДА не можешь предусмотреть все кейсы. Ты даже самые распространенные и вероятные рассмотреть не можешь. Когда, кто и в какой ситуации напишет код с критичным багом, в каком модуле и как он это сделает — ты, блин, понятия не имеешь. Все, что ты можешь сделать, это уменьшить шансы на появление бага. Вот и уменьшай, тебе за это платят бешеные деньги.

    Противники статической типизации противопоставляют типы тестам.


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

    Болваны из динамического мира говорят, что статическая типизация лишает код гибкости.


    Я не понимаю, о какой гибкости они говорят. Даже в нищем C# система типов позволяет мне не иметь контроль над типами данных, чей тип не имеет для меня значения. Я всегда могу доказать языку, что вот, мол, слушай сюда, я не могу описать, что это за штука, но я точно знаю, что у нее есть вот такое поле, вот такого типа или вот такого типа. И я буду работать только с ним. Любой статически типизированный язык это позволяет. А гибкость и свобода писать код, который точно не сможет работать — такая гибкость мне не нужна.

    JS-подростки говорят, что статическая типизация смещает акцент с задачи на описание типов.


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

    Если система типов конкретного ЯПа не позволяет тебе описать свой домен правильно и защищено — это проблема конкретного языка, а не статической типизации в целом. Это нормально, и конкретно на этом языке ты местами используешь всякие object и dynamic, но везде где можешь получить гарантии — ты их получаешь.

    Я писал код и с динамической типизацией, и со статической. Со строгой и нестрогой, со структурной и номинативной.

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


    Динамическая типизация — это игрушка, штука, которая подойдет, когда ты решил закодить что-то в одного, и забыть об этом. Когда ты собрался вести разработку, когда с твоим кодом будут работать другие люди, когда код вылезет на прод и начнет решать проблемы пользователей, обновляясь раз в неделю — динамическая типизация абсолютно нахрен неприемлема. Просто запомни это и иди менять расширения своих файлов с .js на .ts.



    И посмотри мой подкаст — там новый выпуск

    Похожие публикации

    AdBlock похитил этот баннер, но баннеры не зубы — отрастут

    Подробнее
    Реклама

    Комментарии 1977

      –45

      Задвиньте эту статью в черновики, автор явно провоцирует холивар.

        +79

        А вы посмотрите на остальные статьи этого эпатажного автора. Вы думаете, он опомнится на 27-ой разжигающей статье?)

          0
          Мне особенно нравится трезвая оценка с опозданием —
          Пару лет назад я уже писал о типизации, но тогда я был молодой, глупый и трусливый

          Остается немного подождать для оценки уже этой статьи.
          –10

          Отлично, ради прикола обнулили мне карму.

          +56

          Афигенно! Автор, жги! * обновляет страницу, дабы насладится холиваром *

            –13
            Холивар, вроде не пятница.
            Динамическую типизацию зачем то придумал и мало того она жива до сих пор, обычно то что никому не нужно умирает на задворках истории.
            Но удивительное дело в динамических появляются типы, а в типизированных val.
            Такие дела.
            Истина где-то рядом, наверно по середине.
            И наверно не всех надо по одну гребенку.

            Удивительный у автора талант писать статьи, которые вызывают эмоции от полного принятия до лютой неприязни.
              +66

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

                +13
                Думаю просто смешиваются в голове все варианты: статическая/динамическая, сильная/слабая, явная/неявная.
                +7
                Динамическую типизацию зачем то придумал и мало того она жива до сих пор, обычно то что никому не нужно умирает на задворках истории.

                Как говорил один мой знакомый:


                Так ведь значит же. Динамика это просто атавизм из 90-х, когда языки с нормальными системами типов делать не умели, а писать на вербозном говне не хотелось.

                А ЯП с нормальными системами типов начали появляться относительно недавно.

                  0
                  А можете привести примеры ЯП с нормальными системами типов?

                  Ни в коем случае не троллинг, действительно интересно.
                    +10

                    Haskell (хотя 0xd34df00d щас опять будет ворчать, что выразительности не хватает), Idris, вроде бы Scala (хотя точно сказать не могу), с некоторой натяжкой — Rust.

                      0
                      Странно (про Haskell), там ведь и Хиндли-Милнер, и алгебраические типы…
                        +5

                        Зависимых типов нет, линейных типов нет, row polymoprhism нет. Ещё говорят, что модульная система так себе, но я же не окамлист, чтобы так считать.

                          0

                          Первые два скоро подвезут. Только-только появилось понимание как это сделать чтобы потом компилятор не треснул.
                          Третье доступно в виде библиотек.

                            +2

                            Первое (особенно с консистентностью) подвезут очень нескоро. Про второе (пропозал от tweag, по крайней мере) я слышал ещё три года назад — как там с ним прогресс?


                            Заменять row polymorphism библиотеками (уж не classy lenses ли и им подобное?) — это костыли, хоть и не такие, как делать вид, что у нас есть зависимые типы через синглтоны.

                              0

                              Мне ещё регулярно (в чужом коде) встречается Vinyl. Но конечно это всё полимеры...

                        +5
                        1. Динамика это просто атавизм из 90-х, когда языки с нормальными системами типов делать не умели
                        2. Haskell, 1990 год.
                        3. Python, 1991 год.

                        Как эти три вещи могут одновременно укладываться в голове? Видимо ваш знакомый не знает одной из них.


                        Не получится убедить, что Haskell — это подходящий язык для разработки, а Python — не подходящий.


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

                          +5

                          Все таки Haskell это полигон для экспериментов, который тем не менее дорос до прода, а активно вывод типов начал проникать в индустрию только в 10ых годах.

                            +5

                            Ну так хаскель 90-го года и хаскель совеременный — это очень разные языки.

                              0
                              Не получится убедить, что Haskell — это подходящий язык для разработки

                              Почему?


                              а Python — не подходящий.

                              Зависит от проекта. Как тонкий слой клея между уже готовыми библиотеками он прекрасен, да.

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

                                Если бы она ещё работала… Потому что когда тебе нужно, а в апстриме не нужно — вылезай, приехали.

                                  +1
                                  Но ведь в статике бойлерплэйта, как правило, меньше. Можно одновременно получить и безопасность, и читаемость.
                                    0

                                    Как правило больше, на мой взгляд. По крайней мере если брать языки типа C++, C#, Java, TypeScript

                                      0
                                      Ну вот и не надо их брать.
                                        +2

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

                                          +1

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

                                0

                                Swift

                                  –3

                                  Не очень из-за дурацкого деления типов на структуры и классы.

                                    0

                                    Структуры и классы никак не делят типы и не мешают. Это лишь определяет reference type/value type и системе типов до этого нет никакого дела.

                                      +2

                                      Есть дело мне при написании программ, потому что мне надо думать, где будет глубокое копирование, а где — поверхностное, где меняется аргумент, а где — его копия. И в дженериках подобное разделение обычно аукается.

                                        +1
                                        В C# тоже самое. По факту, структуры придуманы не от хорошей жизни, а ради перфоманса. И мутабельные структуры — это дорога в ад (во всяком случае в C#). А если структура не мутирует, то думать про копирование особо не надо.
                                          0

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

                                            0

                                            За мутабельные структуры компилятор всегда подскажет. Если один раз понять как работают reference type/value type в свифте и использовать их где нужно и как нужно, то никаких проблем не будет возникать, а компилятор в случае чего все-равно заботливо предостережет. Все четко и явно в этом плане. И не придется переживать за глубокое/поверхностное копирование.
                                            А что не так с дженериками?
                                            В самом простом варианте все по-умолчанию imutable, потому что компилятор не будет знать что именно туда придет, а для мутабельности можно и inout или var в нужном месте указать.
                                            В случаях посложнее (generic constraints) у вас в протоколе все ограничения описываются, вплоть до указания что этот протокол только для классов.
                                            Не знаю с какими проблемами вы сталкивались, но по этому поводу у меня голова ни разу не болела.

                                        +1

                                        К сожалению он существует только в яблочной экосистеме.

                                          –2

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

                                            +4
                                            Только пользователей пк на винде большинство.
                                              –2
                                              habr.com/ru/post/243183
                                              6 лет назад было 50/50, как сейчас — не знаю, но думаю не в пользу винды.
                                                0
                                                en.wikipedia.org/wiki/Usage_share_of_operating_systems
                                                87% windows на 2019 год.
                                                Многие помнят, что
                                                Интернет спрос показал, что 100% пользуются интернетом.
                                                  –5

                                                  87% это в целом по миру или в сфере разработки? Я видел винду только у тех разработчиков, которым по каким-то причинам было лень ставить линукс. Возможно страх перед неизведанным.

                                                    +3

                                                    Страх перед паршивыми гуями тогда уж.

                                                      0

                                                      На самом деле почти у всех знакомых мне разработчиков в экосистеме .NET и 1С винда — основная ось для этой разработки. Линуксы — только для кроссплатформенных задач.

                                                        –4

                                                        На самом деле у 100% разрабочтиков в экосистеме Яббле стоят XCode и MacOS — основная ось для этой разработки. Винды — только для задач HR/серкретарш и бухгалтерии.

                                                  0

                                                  https://swift.org/blog/5-3-release-process/
                                                  Теперь и на винде будет.

                                                  +1

                                                  Можно, но на практике я его видел меньше, чем перла в новых проектах или чего ещё. Даже в резюме у людей не видел свифт, наверное, ни разу (зато видел даже пролог, не говоря о хаскелях с растами).

                                                    0

                                                    Так исторически сложилось, что на свифт перешли все кто писал на ObjC, а он существовал в рамках эппловских операционок, поэтому большинство пишущих на нем — маководы. А так как язык молодой, то пока еще не успел выбиться из нативной разработки под MacOS/iOS (в плане популярности), хоть эппл и делает многое, чтобы он мог быть универсальным. Бекенды эти ваши давно уже можно писать, с ардуинками играться, TensorFlow переходит на него как на основной язык. Дайте малышу время)

                                                      +1
                                                      Бекенды эти ваши давно уже можно писать

                                                      Можно, но зачем? Для высокой производительности у меня есть плюсы или раст, а когда производительность не составляет 99% от всех критериев, то можно и на хаскеле.

                                                        +1
                                                        хоть эппл и делает многое, чтобы он мог быть универсальным.
                                                        А что именно он делает? Мне просто интересно. Компилятор предоставил? Так Objective C всегда был под разные платформы (стараниями Столлмана, правда, вопреке желанию Джобса… но был).

                                                        Каких-либо попыток сделать разумную среду, которую можно использовать вне экосистемы Apple я не наблюдаю… да неясно какой в ней мог бы быть смысл: Apple же нужно сделать так, всё-таки, чтобы «хомячки» не разбежались с его платформы, а не чтобы кто-то вне её творил…

                                                        TensorFlow переходит на него как на основной язык
                                                        Кто сказал? Откуда уверенность, что из этого не получится очередная стелла на известном сайте?
                                                          0
                                                          Fullstack-разработка на swift вполне себе цель. В смысле — клиент под ios + серверсайд под линукс.
                                                            0

                                                            Про TensorFlow Google сказал, мол уходят с питона на свифт. Потому что быстрый, безопасный и: https://en.wikipedia.org/wiki/Differentiable_programming


                                                            Если появится очередная стелла, свифт от этого никак не пострадает. Но это не отменяет факта, что свифт уже не только язык для “хомячков” с платформ Apple.

                                                              +2
                                                              Про TensorFlow Google сказал, мол уходят с питона на свифт
                                                              Где, когда, а главное, кто? Те, кто его разработал? Там им свою разработку и внутри Гугла надо как-то продавать — ещё бы они не излучали оптимизм.

                                                              Если появится очередная стелла, свифт от этого никак не пострадает.
                                                              Пострадает, конечно. Причём уже похоже, что не «если», а «когда». Итересно только — релиз успеют сделать или прямо из беты в небытиё?

                                                              Но это не отменяет факта, что свифт уже не только язык для “хомячков” с платформ Apple.
                                                              Та же самая история, что и с Objective C, на самом деле: когда Objective C только появился — народ разработал GNUstep и были даже попытки куда-то это всё приспособить. Однако со временем всё заглохло и, насколько я знаю, Cocoa уже никто никуда портировать особо не пытался — так, кой-какие обрезки для игрушек.

                                                              То же самое и здесь: каждая неудача применить Swift куда-нибудь, кроме iOS и macOS будет подчёркивать «неразрывную связь»: Swift == Apple, Apple == Swift.

                                                              0

                                                              Слабо себе понимаю причину захоронения S4TF. Ребята из Google просто искали наиболее подходящий язык и выбрали Swift. Cделали форк языка и на его основе допиливают под нужды. В Colab уже добавили. FastAI, курсы начали переводить. Единственная проблема, крайне сыроват еще, но светлое будущее :).

                                                                +1
                                                                По-моему вы сами всё прекрасно описали:
                                                                Ребята из Google просто искали наиболее подходящий язык и выбрали Swift.
                                                                Именно так: не «Google искал», а «ребята из Google искали».

                                                                В Colab уже добавили. FastAI, курсы начали переводить. Единственная проблема, крайне сыроват еще, но светлое будущее :).
                                                                Где-то я это уже слышал… Chrome Apps, NaCl… Да собственно половина проектов из Google Graveyard когда-то были «сыроватыми, но со светлым будущим».

                                                                Слабо себе понимаю причину захоронения S4TF.
                                                                То же самое, что и всегда: не оправдал надежд, не набрал критической массы… Посмотрим. Самый важный вопрос не в том, смогут ли они в Colab что-то добавить, а смогут ли они хотя бы один «большой» проект этим увлечь… и то может не помочь: NaCl использовался в App Engine, но ему это не очень помогло…
                                                          0

                                                          Вот это самое "кроме" такой немаленький минус. И подозреваю в обозримом будущем оно не войдет в Tier1 поддерживаемых ОС. Rust вполне неплохая альтернатива в данной ситуации.

                                                      +1
                                                      TypeScript ) (исключительно ради троллинга)
                                                        0

                                                        Тогда уж сразу AssemblyScript, это ts без js.

                                                        –1
                                                        Есть язык D. Благодаря удобно сделанным шаблонам, утиной типизации, возможности ограничивать типы в шаблонных параметрах (часто используются обобщения для структур данных, например, чтобы условный тип массива и условный тип списка могли приниматься функцией поиска). Ну и плюс обычные Си-подобные типы данных и С++-подобное ООП (но без лютого трэшака). Нормальные массивы, хранящие и указатель на себя, и свой размер. Там много хорошего, выводящего на другой уровень программирование на Си-подобных языках. Как раз тот язык, благодаря которому никак мне не удаётся полюбить динамическую типизацию, хоть я и много времени программирую на Python'е, JavaScript'е и bash'е по долгу службы.
                                                        Динамическая типизация переносит ряд возможных ошибок на время исполнения программы вместо времени компиляции.
                                                      +7
                                                      На самом деле очень прокачивает скиллы кардинальная смена стека. Я всю жизнь (лет 15 я думаю) писал на PHP, пару лет назад понадобилось прочно влезть в яву (более строго-типизированного языка я в жизни не видел), дак я вам скажу что именно после того, как я вернулся обратно на PHP я полностью оценил все преимущества статической типизации, ибо мне не нужно боятся что по какой-то причине я загоню аргументом строку, хотя должен был массив (например, изменил возвращаемое значение какой-то другой функции), представляете что произойдет при этом, особенно когда эта функция должна будет пройти этот массив и сделать несколько запросов в БД или сконвертить его в JSON и отправить его на сервер? Теперь начиная с 7 версии PHP тоже имеет строгую типизацию и заругается если аргумент имеет другой тип данных или функция возвращает другое значение, а не то, которое от нее ожидается.

                                                      Как по мне оптимальна гибридная типизация, ибо иногда просто хочется расслабиться и что-то наклепать на коленке, не задумываясь о типах, но в серьезных проектах на том же PHP строгая типизация просто необходима по причинам, которые я описал выше. Причем я понял что словами это не объяснить, с этим нужно сталкиваться чтобы оценить все преимущества.

                                                      P. S. Это еще ладно, я еще и после этого с MySQL на PostgreSQL перешел (который тоже строготипизирован), теперь он меня обругивает каждый раз если по какой-то причине в строку суется число (а это может быть следствием какой-то очень серьезной проблемы, ибо почему возвращается число там, где должна возвратиться строка, например, array_search не нашел какое-то значение в массиве, хотя должно, что означает что этот массив сформирован неверно). Очень сильно выручало уже, хотя я не так давно пользуюсь всеми ее преимуществами.
                                                        +1
                                                        писал на PHP, пару лет назад понадобилось прочно влезть в яву (более строго-типизированного языка я в жизни не видел)
                                                        Это не та ли система типов, которая считает null объектом любого типа?
                                                        В РНР эту «особенность» умудрились не повторить, кстати.
                                                          0

                                                          Наверное, просто потому что null в PHP появился чуть ли не раньше чем сама Java появилась (шутка, она старше на пару месяцев) и изначально был отдельным скалярным типом, когда объектов ещё даже в проекте не было

                                                            –2
                                                            это круто, конечно, что умудрились не повторить ошибку системы типов, которую проектировали четверть века назад. Дженерики тоже сразу сделали, а не как в джаве?
                                                              0
                                                              Ну да, всю систему типов на помойку, и сам язык туда же, у него же тип null есть!
                                                                0
                                                                Типа null у него как раз нет. В этом и проблема.
                                                                  +1

                                                                  Ну так-то вот эта концепция с null самим её изобретателем признана "ошибкой на миллиард долларов".

                                                                0
                                                                заругается если аргумент имеет другой тип данных

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

                                                                ЗЫ на самом деле Php начинает нервировать, ятоже много лет на нем пишу, и у меня все более отчетливое желание писать на jsp или на чистой Java
                                                                  0

                                                                  TypeError обычное исключение. Обычно его и особо перехватывать не нужно, так же как любое необработанное.

                                                                    +2
                                                                    Как правила это — ошибка в коде и ловить такие вещи в рантайме — странная идея.
                                                                      0

                                                                      Лучше поздно чем никогда.

                                                                    0
                                                                    На рантайме вообще ничего тестить нельзя, учитывая его специфику, все делается на локальном сервере, и просто через Гитхаб обновляются бранчи. Но PHP тем и хорош, что иногда хочется расслабиться и накидать что-то для себя на коленке, не заботясь о типах, как раз таки именно Java в этом плане начинает напрягать, когда ты только и занимаешься тем, что приводишь все к типам. Но в крупных и серьезных проектах это необходимость, да, и очень полезная необходимость.
                                                                +55

                                                                Хороший пример: когда тон чего-то сказанного в начале убивает желание вообще продолжать смотреть на дальнейшие какие-то рассуждения или аргументы, не важно правильные или неправильные.


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

                                                                  +9
                                                                  Пример того, когда автор может честно говорить, что думает. Да, грубовато. Но большинство статей про js намного токсичнее, хотя автор будет обращаться на «вы».
                                                                    +10
                                                                    Эта статья скорее развлекательная. Честность и эпатаж в стиле камеди клаб — немножко разные вещи. Честным было бы показать особенности подхода на примере своих работ с примерами кода и анализом выбранных решений.
                                                                  +5
                                                                  ** Прыгая в комменты с клавиатурой **
                                                                  -А холивар то где???
                                                                  P.S. После фразы «адское говнище» не читал.
                                                                    +41
                                                                    Наконец то кто то осмелился это сказать! Я уж думал со мной что то не так
                                                                      +8
                                                                      Не зря во многие ЯП добавляют статическую типизацию(PHP, Python, Javascript)
                                                                        0

                                                                        В PHP добавляют строгую. А про джс можно подробнее?

                                                                          +2
                                                                          Ну так TypeScript же.
                                                                            +14
                                                                            В PHP нет ни строгой, ни статической типизации. Нет и не будет.
                                                                            Тот, кому первому пришла в голову идея назвать рантаймовый контроль типов «типизацией» — будет вечно гореть в аду за обман джуниоров.
                                                                              0

                                                                              Типизация — не контроль типов?

                                                                                +3

                                                                                Контроль, конечно.


                                                                                Просто типы — это не рантайм-метки рядом с другими ячейками в памяти, а что-то, что проверяется компилятором статически. Например, Пирс в TAPL это именно так и определяет, и прямо говорит, что dynamic typing is arguably a misnomer.

                                                                                  +1

                                                                                  Не согласен. Типы — информация о том, как интерпретировать то или иное значение. А где она хранится и как и когда проверяется — детали реализации.

                                                                                    +9

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


                                                                                    Таки приведу цитату, аж в форме скриншота для важности:

                                                                                      0

                                                                                      Лучше поздно, чем никогда, нет?

                                                                                        +7

                                                                                        Но раньше ещё лучше.

                                                                                          –3

                                                                                          Как по мне, то если контроль типов есть, то это типизация.

                                                                                            +2

                                                                                            То есть, если я в ассемблере буду везде хранить в памяти рядом с объектами их метки и проверять в рантайме, ассемблер станет типизированным?

                                                                                              –1

                                                                                              Ваша программа станет типизированной.

                                                                                                +2
                                                                                                Если эта проверка встроена в язык и её нельзя обойти — то конечно язык типизированный. По крайней мере, такое понимание типов согласуется и с википедией, и с официальными документациями языков программирования, и с литературой по программированию. То, что это не идеально совпадает с теорией типов в математике — ну так в разных областях одно и то же слово может использоваться в разных значениях.
                                                                                                  +3
                                                                                                  и с литературой по программированию.

                                                                                                  Нет, не согласуется. На несколько комментов вверх прямая цитата.


                                                                                                  По крайней мере, такое понимание типов согласуется и с википедией

                                                                                                  На википедии и прочих википодобных источниках чего только не написано.

                                                                                                    +1
                                                                                                    Не знаю, из какой именно книги ваша цитата выше — но даже в ней написано, что такое использование термина является стандартным. То есть, именно так понимается «динамическая типизация» применительно к языкам программирования. Так зачем спорить о терминах?
                                                                                                      +2

                                                                                                      Из TAPL.


                                                                                                      «Является некорректным названием» (или как там misnomer правильно перевести) в первую очередь.

                                                                                                        0

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

                                                                                                          +2
                                                                                                          Понятие вроде «динамически типизированный» есть по логике вещей неверное наименование и должно быть вероятно заменено на «динамически проверяемый» (или «проверяемый во время выполнения» — прим. пер.), но использование этого понятия уже устоялось.
                                                                                                        0
                                                                                                        Очень странный подход к определению типов данных. Вот есть языки, которые позиционируются, как языки со стогой статической типизацией. При этом практика диктует наличие в таких языках механизмов позднего связывания (по факту элементов строгой динамической типизации). Получается все данные и структуры, для которых использованно позднее связывание не имеют типов вообще? Это как-то выбивает основу из-под строгой типизации, не находите?
                                                                                                          +1
                                                                                                          Читать про алгебраический тип данных. Много думать.

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

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

                                                                                                          Но нет, позднее связывание не делает язык нетипизированным. Даже если в каким-то месте про тип и нельзя ничего сказать (как в Java, когда вы получаете Object), но в других-то можно!
                                                                                                            +2

                                                                                                            Есть, кстати, более интересный способ размыть границу.


                                                                                                            Есть такая штука в теории типов, как сигма-тип — это пара из значения одного типа и значения другого типа, где второй тип зависит от первого значения. Например, (n : Nat ** Vect n Int) — натуральное число и вектор соответствующей длины.


                                                                                                            Так вот, никто не мешает вам написать тип (a : Type ** a) — это сигма-пара из типа (а типы — first-class citizen, как мы помним) и значения этого типа. То есть, у вас по факту есть метка типа и объект этого типа — всё как в питонах, JS и так далее. И вы даже можете написать [(_ ** "yay string"), (_ ** 42), (_ ** MkSomethingElse)] — почти динамически типизированный список, можно даже типы не писать, а оставить подчёркивания, чтобы компилятор их вывел!


                                                                                                            Однако, есть проблема: подавляющее большинство имеющихся языков вроде агды, кока или первого идриса очень не любят паттерн-матчинг по типам из-за parametricity, поэтому создать объект такого типа вы сможете, а вот использовать его — нет.


                                                                                                            К счастью, есть и решение: в Idris 2 завезли новую теорию, интегрирующию завтипы и некоторую форму линейных типов, и теперь вы вполне сможете написать что-то вроде


                                                                                                            type Dyna = (a : 1 Type ** a)
                                                                                                            
                                                                                                            stupidAdd : Dyna -> Dyna -> Maybe Dyna
                                                                                                            stupidAdd (String ** s1) (_ ** s2) = Just (s1 <> s2)
                                                                                                            stupidAdd (Nat ** n1) (_ ** n2) = Just (n1 + n2)
                                                                                                            stupidAdd _ _ = Nothing

                                                                                                            То есть, тайпчекер всё равно проверяет, что код имеет смысл, статически (и написать stupidAdd (String ** s1) (Nat ** n2) = s1 + n2 у вас не получится), но теперь вы можете делать что-то, что очень сильно пахнет тем же питоном.

                                                                                                            +1

                                                                                                            Вы про то позднее связывание, которое загрузка динамических библиотек (а не про ООП с виртуальными функциями, скажем)?


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

                                                                                                              0
                                                                                                              К сожалению dlsym даёт просто указатель на функцию, которую можно вызывать. А уж как её вызывать — не его дело.
                                                                                                                0

                                                                                                                Вот поэтому «условно».

                                                                                                        0
                                                                                                        Были архитектуры, где именно так и сделано — железо само следит за типами аргументов. Можно ли считать такой ассемблер типизированным?
                                                                                                          +1

                                                                                                          В том смысле, о котором я говорю — нет. Он же не проверяет типы при ассемблировании?

                                                                                                            0
                                                                                                            Вы определили «типы» как нечто, проверяемое при компиляции. Но это ведь не единственное определение.
                                                                                                              +1

                                                                                                              Определять, понятное дело, можно как угодно, главное об этом договориться. Но у типов давно (ещё до программирования) есть вполне конкретное определение, которое на программирование отображается как статические проверки. Зачем эти вещи путать?


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

                                                                                                                +2
                                                                                                                Применительно к программированию я, например, встречал определение типа как набора значений и операций над ними. Когда именно проверять, что объекты удовлетворяют такому типу, там не уточнялось.

                                                                                                                назвать типизацией наличие проверок на корректный доступ к элементу массива


                                                                                                                Тем не менее в Паскале длина массива именно что входила в определение типа.

                                                                                                                (ещё до программирования)


                                                                                                                Если вы имеете в виду математические типы в стиле введенных Расселом, то он ведь тоже не уточнял, в какое время их надо проверять.

                                                                                                                Поэтому ваше утверждение

                                                                                                                которое на программирование отображается как статические проверки


                                                                                                                достаточно спорно.

                                                                                                                Если уж на то пошло, то и статическая, и динамическая проверка типов вообще не относятся к типам, как таковым — типы просто существуют, а является скорее помощью человеку, который не может не делать ошибок и не путать данные разные типов в процессе программирования или выведения логических формул.
                                                                                                                  +1
                                                                                                                  Применительно к программированию я, например, встречал определение типа как набора значений и операций над ними. Когда именно проверять, что объекты удовлетворяют такому типу, там не уточнялось.

                                                                                                                  Дико неконструктивное определение.


                                                                                                                  Должна ли операция «удалить первые N символов» быть в определении строки? Если у вас питон с типа строгой динамической типизацией, то, получается, "abcde" и "" — разные типы?


                                                                                                                  Тем не менее в Паскале длина массива именно что входила в определение типа.

                                                                                                                  А там можно получить число по сети или считать из файла и выделить массив ровно такой длины, да чтобы его длина осталась в типе?


                                                                                                                  Если вы имеете в виду математические типы в стиле введенных Расселом, то он ведь тоже не уточнял, в какое время их надо проверять.

                                                                                                                  Тамошняя ramified theory of types как раз позволяет сказать, что некоторые выражения не имеют смысла, не «вычисляя» (то есть, не анализируя семантику) эти выражения.

                                                                                                                    0
                                                                                                                    > Дико неконструктивное определение.

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

                                                                                                                    Типы в ЯП до формализации примерно так и строились.
                                                                                                                      +2

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

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

                                                                                                                          Я окончательно запутался в предложенном определении. То есть, тип — это не про совокупность операций, а про такие несомненно объективные критерии, как удобство и реализуемость.


                                                                                                                          Научно и инженерно, ничего не скажешь.

                                                                                                                            –3
                                                                                                                            Вы путаете инженерию с математикой. Инженерия — это как раз о том, что удобно и реализуемо, а не то, что аксиоматично и строго формализуемо. Математика всего лишь шьет пиджаки для осьминогов.
                                                                                                                      0
                                                                                                                      Должна ли операция «удалить первые N символов» быть в определении строки?


                                                                                                                      Может быть, но не обязательно. Она не слишком аксиоматическая, что ли.

                                                                                                                      Если у вас питон с типа строгой динамической типизацией, то, получается, «abcde» и "" — разные типы?


                                                                                                                      Непонятно, почему вы пришли к такому выводу. Операция эта будет определена как функция отображения строки в строку, т.е. тип объекта не изменится.
                                                                                                                        0
                                                                                                                        Может быть, но не обязательно. Она не слишком аксиоматическая, что ли.

                                                                                                                        Ну окей, «удалить один первый символ».


                                                                                                                        Операция эта будет определена как функция отображения строки в строку, т.е. тип объекта не изменится.

                                                                                                                        Но операция «удалить первые 5 символов» неприменима к пустой строке.

                                                                                                                          0
                                                                                                                          Значит, это частично определенная функция. Ничего особенного.
                                                                                                                            0

                                                                                                                            Так почему операцию деления не сделать определённой вообще на всех объектах? Просто на некоторых (на числах, например) она тоже будет частично определённой.

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

                                                                                                                                Извините, я хотел написать «на строках».

                                                                                                                          +2
                                                                                                                          Может быть, но не обязательно. Она не слишком аксиоматическая, что ли.

                                                                                                                          То есть вместо строгого определения имеем: "Вроде как нет, но если надо, почему бы и не да".

                                                                                                                            0
                                                                                                                            Отнюдь. Просто задачу выделения элементарных операций над типом (и определить тем самым тип) можно решить разными способами. Как только мы зафиксировали один из них, дальше все строго.
                                                                                                                              0

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

                                                                                                                                –1
                                                                                                                                Боюсь, что это не столько теория, сколько практика. И не моя, а универсальная.
                                                                                                                                  0

                                                                                                                                  Та же практика показывает, что чем более математизированы основания под языком, тем проще и адекватнее с ним работать.

                                                                                                                                    0

                                                                                                                                    И это положительно сказывается на популярности?

                                                                                                                                      0

                                                                                                                                      ХЗ. После некоторой границы популярность языка меня не особо волнует, так как все эти миллионы программистов на нём вряд ли будут писать код вместо меня.

                                                                                                                                      –2
                                                                                                                                      Несомненно. Порядок и логика всегда лучше хаоса и конструкций из палок. Но практика еще и показывает, что математизации поддаются только самые простые части мира, и программирования в частности.
                                                                                                                                        0

                                                                                                                                        У меня лично ощущение, что "полная" математизация основ языка (теория типов, теория категорий) негативно сказываются на его популярности.

                                                                                                                                          +2

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

                                                                                                                            0
                                                                                                                            некоторые выражения не имеют смысла, не «вычисляя»


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

                                                                                                                              Но я не вычисляю ответ. Когда я проверяю, что A : Set, мне совершенно неважно, какие элементы будут в A, пока оно удовлетворяет некоторым синтаксическим (и разрешимым!) правилам.

                                                                                                                                –1
                                                                                                                                В частных случаях. Это просто shortcut — как и вся математика, собственно.
                                                                                                                                  0

                                                                                                                                  Нет, это не шорткат. Это ответ на другой вопрос.


                                                                                                                                  Мне не нужно знать, что такое на самом деле A или P, чтобы понять, что { x ∊ A | P(x) } — корректное выражение. Достаточно A : Set и P : A → Bool. Мне не нужно ничего знать вообще ни о чём, кроме типа sin, чтобы понять, что { x ∊ sin x } некорректно. И вычислять его не надо.

                                                                                                                              0
                                                                                                                              выделить массив ровно такой длины


                                                                                                                              Насколько я помню исходный виртовский Паскаль — нет. Массивы там были вообще не динамические, а в их тип входили тип элементов, тип индексов и диапазон индексов.

                                                                                                                              А для передачи массива в процедуру приходилось определять формальный аргумент, прибегая к чему-то вроде any: ARRAY OF INTEGER, например, вместо полного типа ARRAY[1..10] OF INTEGER.
                                                                                                                    +1
                                                                                                                    Конечно ассемблер типизированная вещь. Типов, правда, не так много: «нечто размера 32 биты», «нечто размера 128 бит»… ну и всё.

                                                                                                                    Хотя бывают разные ассемблеры. Почитайте документацию на TASM. У них там объекты были.
                                                                                                                      +2
                                                                                                                      Не нечто, а вполне определённые форматы, для которых нужны свои инструкции.
                                                                                                                      Целочисленный add, применённый к float значению, выдаст хурму на выходе.
                                                                                                                        +1
                                                                                                                        елочисленный add, применённый к float значению, выдаст хурму на выходе.
                                                                                                                        Недоумённо смотрит на свой код из релизнутого продукта. А вы точно в этом уверены?

                                                                                                                        А вот эту статью вы когда-нибудь видели?
                                                                                                                          +1
                                                                                                                          На ассемблере add вполне себе выполнится, вот только результат будет весьма прикольный.
                                                                                                                            0
                                                                                                                            Почему прикольный? Всё будет зависеть о того, что вы складываете с чем и зачем.

                                                                                                                            В моём случае речь шла об округлении мантиссы — это делается как раз использованием целочисленных операций с float.
                                                                                                                              +1
                                                                                                                              В этом случае да, но не следует забывать того, что какраз у самого процессора(x86, сопроцессор и прочее не учитываем!) понятия типов вообще нет, и ему глубоко пофигу что с чем складывать. Поэтому 1.1f + 43 вполне себе может вылиться в любой треш.
                                                                                                                            0
                                                                                                                            Тут код специально рассчитан на такое поведение и работает со специально подобранными константами.
                                                                                                                            Разумеется, какие-то целочисленные операции можно применять к float зная формат и ожидаемый результат.

                                                                                                                            Я же говорил, что сложив 1+1 вы получите не 2, а 1.7014118346e+38

                                                                                                                            Точно так же, перепутав знаковое и беззнаковое деление результат может быть неверным.
                                                                                                                              +1
                                                                                                                              Я же говорил что сложив 1+1 вы получите не 2
                                                                                                                              А почему вы, собственно, должны получить 2? Вы и без всяких floatов можете получить чушь, если в одной переменной у вас 1 и в другой 1, только в одной — это метр, а в другой дюйм.

                                                                                                                              Проверено экспериментально.
                                                                                                                                +1
                                                                                                                                Хоспаде. Я написал банальную мысль о том, что при программировании на ассемблере нужно следить за типами инструкций и операндов. Типы отличаются не только размером, но и форматом данных.
                                                                                                                                Процессор не сделает преобразование типов за вас. К чему вот было это ваше «а можно плавать и со штангой»?

                                                                                                                                >> А почему вы, собственно, должны получить 2?
                                                                                                                                Потому что я хочу получить 2, наверное?
                                                                                                                                  –1
                                                                                                                                  Потому что я хочу получить 2, наверное?

                                                                                                                                  Интересный аргумент. А если я хочу получить 3, то должно получаться 3?
                                                                                                                                    0
                                                                                                                                    Нет, конечно. Лицензия на «хотение», очевидно принадлежит beeruser — и потому только он имеет право чего-то хотеть. Вы опоздали.
                                                                                                                                      +1
                                                                                                                                      А если я хочу получить 3, то должно получаться 3?
                                                                                                                                      1+1=3? Cтранное желание, но как хотите.
                                                                                                                            +1
                                                                                                                            Хотя бывают разные ассемблеры. Почитайте документацию на TASM. У них там объекты были.

                                                                                                                            Лучше на TAL-0 тогда уж.

                                                                                                                    0
                                                                                                                    Проверка выхода за границу массива это не проверка типа? Или защита от выполнения данных?
                                                                                                                    Ещё, слышал, бывали процессоры, у которых переменные содержали поле с типом.
                                                                                                                      +3
                                                                                                                      Проверка выхода за границу массива это не проверка типа?

                                                                                                                      В рантайме? Нет.


                                                                                                                      Или защита от выполнения данных?

                                                                                                                      Нет. У типа есть очень формально определённое значение, и даже если кто-то использует этот термин неправильно, это не значит, что этому надо способствовать (примерно как с «ться»/«тся»).

                                                                                                                        0
                                                                                                                        У типа есть очень формально определённое значение

                                                                                                                        Много определений типа в программировании. Некоторые ещё тянут в программировании определения типов из математики.

                                                                                                                          0

                                                                                                                          И правильно делают.

                                                                                                                            0

                                                                                                                            На любителя. По ощущениям на любителя ФП

                                                                                                                          0

                                                                                                                          "У типа есть очень формально определённое значение".


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

                                                                                                                            +1
                                                                                                                            Не считая определений из прикладных языков программирования, который возникли раньше тапла и из других предпосылок.

                                                                                                                            Понятие типа в контексте STLC возникло до любого из прикладных языков программирования. Да и уже automath какой-нибудь возник сильно до любого из ныне существующих языков программирования.


                                                                                                                            Какое же из них верное?

                                                                                                                            Откуда мне знать? Вы ж их не назвали.

                                                                                                                              0
                                                                                                                              Понятие типа в контексте STLC


                                                                                                                              1. Система типов из «лямбда-исчисления с типами» не единственная система типов, а только одна из.
                                                                                                                              2. Системы типов в современных мейнстримных языках (как со статической типизацией, так и с динамической) — это очень далеко не STLC и я подозреваю, что их авторы строили их на несколько других основаниях (и не только формальных).
                                                                                                                              3. Да, можно натянуть сову на глобус (что и делает тапл) и вывести одно из другого, но это вообще не означает, что определение типа из STCL единственно верное или валидное для языков программирования.
                                                                                                                              4. То что система типов красиво формализуема еще не означает, что она хорошо подходит для промышленной разработки людьми, которым важно получить результат здесь и сейчас, а не формально верифицировать корректность программы.
                                                                                                                                +1
                                                                                                                                Система типов из «лямбда-исчисления с типами» не единственная система типов, а только одна из.

                                                                                                                                Естественно. А в каких других теориях типов это не статическая классификация?


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


                                                                                                                                По остальным пунктам — а о чём мы спорим-то? Вы хотите сказать, что «динамическая типизация» — настолько же корректный термин, как «динамические проверки»?

                                                                                                                                  0
                                                                                                                                  А в каких других теориях типов это не статическая классификация?


                                                                                                                                  Ну есть, например, такая «Gradual Type Theory». Правда я с ней недостаточно знаком, чтобы внятно ее обсуждать.

                                                                                                                                  По остальным пунктам — а о чём мы спорим-то?


                                                                                                                                  Я спорю с утверждением, что «типы — это не рантайм-метки рядом с другими ячейками в памяти, а что-то, что проверяется компилятором статически», и утверждаю, что если «статическая типизация = типы проверяются компилятором статически», то так же правомерно говорить «типы проверяются рантаймом динамически = динамическая типизация».
                                                                                                                                    0

                                                                                                                                    Но проверяются не типы, потому что в рантайме у вас не тип.


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

                                                                                                                                      0

                                                                                                                                      А если система типов есть, но она плохая по этому критерию?

                                                                                                                                        0

                                                                                                                                        Я не знаю языков с Тьюринг-полной системой типов, при разработке которых при этом всерьёз думали бы о системе типов, и где эта полнота была бы желаемой (а не как в темплейтах C++, где Тьюринг-полнота была открыта, или в дженериках Java, где надо сильно изворачиваться, и на практике это не парит).


                                                                                                                                        Да, если вы возьмёте ту же теорию типов Мартина-Лёфа и добавите туда экстенсиональное равенство, то у вас получится неразрешимая система типов, но на практике именно поэтому так никто не делает.

                                                                                                                                0
                                                                                                                                automath какой-нибудь возник сильно до любого из ныне существующих языков программирования.


                                                                                                                                Я думал, что тут разговор о языках программирования, а не доказателях теорем.
                                                                                                                          –2
                                                                                                                          Разве пыха компилируется в принципе? Я сто лет не пышник и не в курсе новостей этого вашего пшп 7, хотя про типы и слышал. Просто обывательский подход — если ты не сидишь и не ждешь конца компиляции — оно не компилируется, а выполняется.
                                                                                                                            0

                                                                                                                            Оно компилируется в опкод, который выполняется VM.

                                                                                                                              0

                                                                                                                              В 8 обещают JIT компиляцию в нативный код, а пока только в опкоды

                                                                                                                          0

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


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

                                                                                                                            0
                                                                                                                            А как называются рантайм метки более коротко?

                                                                                                                            Ну так и называются, метки.


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


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

                                                                                                                            Ээ, не знаю, это какой-то слишком общий термин для меня.

                                                                                                                              0
                                                                                                                              Ну так и называются, метки.

                                                                                                                              А кем они так называются? Есть ли какая-то реализация которая называет их не типом?


                                                                                                                              Например, в вашей любимой IDE при отладке тип переменной и тип значения переменной называются по разному? Один тип, другой метка?


                                                                                                                              Ээ, не знаю, это какой-то слишком общий термин для меня.

                                                                                                                              Ну вы в обычной речи слово тип не употребляете?


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

                                                                                                                                0
                                                                                                                                Например, в вашей любимой IDE при отладке тип переменной и тип значения переменной называются по разному? Один тип, другой метка?

                                                                                                                                В моей IDE для хаскеля вообще нет рантайм-меток (да, я за всю практику пользовался Typeable в своём коде ровно один раз). Да и дебаггером я там не пользуюсь.


                                                                                                                                В моей IDE для плюсов их тоже не особо много для рантайм-поведения. Максимум — по vtbl можно определить, какой класс-наследник доступен по указателю на базовый класс, но какими бы то не было проверками типов там и не пахнет.


                                                                                                                                Ну вы в обычной речи слово тип не употребляете?

                                                                                                                                Зависит от контекста. Ещё употребляю «класс», «множество» и прочие подобные слова.


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

                                                                                                                                А зря. На мой взгляд, создаёт неправильные ожидания.


                                                                                                                                а статика тесно связана с динамикой.

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

                                                                                                                                  0
                                                                                                                                  С моей точки зрения в книжке терминология интересна но неудобна, все говорят «тип» для общего, никто не использует выражения «рантайм метка»

                                                                                                                                  А зря. На мой взгляд, создаёт неправильные ожидания.

                                                                                                                                  Зря или не зря — это уже больше философский вопрос. Факт в том, что «динамическая типизация» по отношению к языкам программирования используется именно в таком смысле, и причины, по которым так сложилось, здесь не важны.
                                                                                                                                    0

                                                                                                                                    Факт, однако, и в том, что куча людей пользуеться «ться»/«тся» некорректно, и даже несмотря на то, что язык — живой и подвижный предмет, который формируеться тем, чем предпочитают пользоватся люди, это почему-то не мешает старатся блюсти чистоту использования этих частей слов.


                                                                                                                                    И если мы обсуждаем преимущества разных видов типизации, то, ИМХО, лишний раз указать на принципиальное различие между типизацией и рантайм-проверками, которое по-хорошему должно быть определено даже в терминологии, вполне себе стоит.

                                                                                                                                      0
                                                                                                                                      В языке «ться» и «тся» не различаются, они различаются лишь на письме, которое представляет собой условность. Потому, собственно, их и путают на письме.

                                                                                                                                      лишний раз указать на принципиальное различие между типизацией и рантайм-проверками


                                                                                                                                      То, что вы называете типизацией, — всего лишь проверки до рантайма.
                                                                                                                                        +1
                                                                                                                                        То, что вы называете типизацией, — всего лишь проверки до рантайма.

                                                                                                                                        Где им, когда есть такая возможность, самое место.

                                                                                                                                          –1

                                                                                                                                          Это лишь ваше убеждение :)

                                                                                                                                            +2

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

                                                                                                                                              0

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

                                                                                                                                                +1

                                                                                                                                                И объективность важности этого ровно такая же, как объективность важности как можно более раннего отлова ошибок.

                                                                                                                                                  +5
                                                                                                                                                  Титанический труд проделал 0xd34df00d по вводу правильной терминологии, но увы так и не убедил любителей упасть во время выполнения(на миллионе юзерских девайсов) что лучше упасть во время компиляции(на единственном девайсе разработчика).
                                                                                                                                                  Вам экологии то не жалко ребята?
                                                                                                                                                  Триллионы триллионов раз, миллиарды юзеров будут гонять какие то там рантайм псевдропроверки, тратить ресурсы железа впустую, только потому что в вашем «типизированном»(в кавычках) языке нельзя их проверить во время компиляции.
                                                                                                                                                  • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                      +3

                                                                                                                                                      Извините, но вы соответствие Карри-Говарда проигнорировали. Избирательное зрение?

                                                                                                                                                      • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                          0

                                                                                                                                                          Надеюсь теперь всем ясно, что это — тролль?

                                                                                                                                                          • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                            0

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

                                                                                                                                                              0
                                                                                                                                                              Что вы собрались выяснять и в каком споре? Если человек не умеет в логику? В принципе?
                                                                                                                                                                0

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

                                                                                                                                                                  0
                                                                                                                                                                  А… ну это, успехов. Я умею сделать так, чтобы их уволили (что, обычно не так и сложно), а большего мне и не нужно обычно.
                                                                                                                                                                    0

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

                                                                                                                                                                      –1
                                                                                                                                                                      В политику и я не умею. Но с людьми, не умеющиеми в логику, обычно бесполезно спорить. Нужно просто пользоваться тем, что они не умеют просчитывать результаты своих шагов и «делать их крайними».

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

                                                                                                                                                                      Даже если вам за выполнение чего-то сказанного мимоходом и нигде не зафиксированного обещают кучу плюшек и всяких благ. Лучше прослыть «ничего не понимающим в бизнесе», чем оказаться крайним, когда очередной такой персонаж будет на вас пытаться повесить свои косяки.
                                                                                                                                                            0
                                                                                                                                                            Типы же первичны? Ошибся в типе, описал функцию как минус. Когда писал реализацию функции, IDE мне сказала, чувак тут надо "-" судя по типу, ну я и исправил на "-", хотя по тз там плюс.

                                                                                                                                                            но ведь ты тоже проигнорировал, как соответствие карри говарда поможет от неправильно поставленной/понятой/решенной задачи?
                                                                                                                                                            Почему ты допускаешь что в функции ошибиться можно, Но в тоже время уверен что в типах ошибиться нельзя, перенеся потом эту ошибку в реализацию?
                                                                                                                                                              +2

                                                                                                                                                              От неправильно поставленной или понятой задачи не поможет вообще ничего. Вообще. Если у вас попросили автопилот для машины, а вы сделали автопилот для самолёта (лучший среди всех автопилотов), то это не поймают ни тесты, ни типы, ничего.


                                                                                                                                                              Но это не логическая ошибка.

                                                                                                                                                                +1
                                                                                                                                                                или понятой задачи не поможет вообще ничего. Вообще

                                                                                                                                                                Я так и сказал.
                                                                                                                                                                Едиственно в чем мы расходимся это
                                                                                                                                                                Но это не логическая ошибка.

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


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

                                                                                                                                                                  Это когда вы спеку поняли правильно, но то, что вы написали, расходится со спекой.


                                                                                                                                                                  И получается, что спека у вас кодифицирована в типах, и компилятор просто проверяет, что реализации на самом деле ей удовлетворяет.


                                                                                                                                                                  А если мне сказали закодить биржевого бота, который будет торговать на какой-нибудь азиатской бирже только в рабочие дни, то, например, если я неправильно скопирую список праздников (или нагуглю список не для той страны), то типы едва ли это помогут отловить, конечно. Но как это отлавливать — вообще непонятно.

                                                                                                                                                                    +1
                                                                                                                                                                    А если мне сказали закодить биржевого бота, который будет торговать на какой-нибудь азиатской бирже только в рабочие дни, то, например, если я неправильно скопирую список праздников (или нагуглю список не для той страны), то типы едва ли это помогут отловить, конечно. Но как это отлавливать — вообще непонятно.

                                                                                                                                                                    Хуже. Список рабочих дней может как в России определяться в предыдущем году по решению Правительства. Или как с "нерабочими" днями. По ходу дела.
                                                                                                                                                                    Вообще удивительно, что только 0xd34df00d реально вернулся к истокам. Все это программирование — это не код ради кода, а код обработки данных. А все данные типизируются. А код — это просто функции превращения одного в другое.

                                                                                                                                                            0
                                                                                                                                                            у него большая проблема: многое из того что он говорит базируется не на научном подходе, а на религиозных предпочтениях/взглядах
                                                                                                                                                            Ну хоть с тем, что ЯП со статической типизацией убирают множество проблем с ошибками типов вы согласны?
                                                                                                                                                            • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                                +2
                                                                                                                                                                однако надо помнить (и это исследовал ещё Ларри Уолл), что большинство проблем с ошибками типов связаны с тем, что в языках некорректно сдизайнены операторы сравнения и математические операции.
                                                                                                                                                                А ещё нужно помнить, что когда эта «глыба», эта «гора», этот «гений» решил создаить что-то на основе своих идей… то получился высер такого микроскопического размера, что о нём даже как о мыши-то говорить смешно.

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

                                                                                                                                                                Знаете — весь этот ваш пафос был бы слегка более уместен