Начнём, пожалуй

Начнём, пожалуй

Спасибо всем, кто отвечал. Многие не поняли описанного пути. Так же большинство хочет критики. Поэтому будет про путь, и почему текущие подходы/решения нам(жаждущим скилла) не подходят.

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

у нас нет языка

динамическая типизация - не язык

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

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

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

у нас нет статической типизации - сектанты всех обманули

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

Если какая-либо часть семантики языка не определяется типами, а определяется какой-либо реализованной в рантайме логикой - это описательная типизация. Очень хорошо это заметно на примере TS. Вся семантика там - это js, и типизация динамическая. Сверху поверх этого навешаны типы, но это не более чем аннотации для статического анализатора. Никак на логику исполнения программы - они не влияют, и ничего не определяют.

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

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

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

Простой критерий для определения описательной типизации - наличие подтипов. Схема там следующая. Сектант при проектировании системы типов сталкивается с полиморфизмом. И, как он решается в скриптухе? За счёт any. Т.е. некоего типа, который объединяет в себе все возможные типы, позволяя самому себе являться любым из них.

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

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

А теперь подумаем об описательной типизации. Если у нас есть динамическая типизация, которая хранит в рантайме необходимый тип, т.е. определяет его, а сверху к этому прикручен сумтип - это работает. Именно поэтому оно и работает. A|B - не может работать в статической типизации. Это работает только в тандеме с хранением тега в рантайме.

Таким образом мы выходим к базовому свойству скриптухи. Скриптуха ВСЕГДА теряет типы. Потому как и в A|B и в C(где с подтип(базовый тип) для A и B). Ведь статическая типизация предполагает возможность определения типа, но эта возможность переносится в рантайм. И без подобного механизма - подобная типизация не может работать.

Почему же это сделано так? Всё очень просто. Нужно запомнить базовая правило. Запарта - тупа, а всё что она делает(за редкими исключения, но то скорее вопреки запарте) - всегда примитивное говно. Всегда выбираются самые убогие подходы и решения.

Вернёмся к полиморфизму. Вот у запартыша в скриптухе всё было круто f = a => b; f("");f(10); - типы сами разрулятся в рантайме. Но, ему же нужно родить типизацию. И вот у него возникает гениальный план, а давайка мы возьмём скриптуху, скажем, что (a: num|string) => b и никто не заметит. И так как запарта определяет методичку - она в ней запишет, что это и есть истинная реализация полиморфизма(СТАТИЧЕСКОГО).

Это всё что нужно знать о запарте. Она десятки лет учит сектантов тому, чего просто не существует. И называет что-то тем, чем оно не является.

На самом деле всё ещё хуже. Вы никогда не задавали себе вопрос - почему во всей бездарной скриптухи есть ГЦ? Почему так происходит какой-то вскукарек на тему value-типов. Хотя скриптуха типизирована и все дела. И это ещё одно чудо. На самом деле гц в скриптухе нужен не столько для управления памятью - сколько для реализации полиморфизма. Потому как необходимо создать одну полиморфную функцию, статически создать какую достаточно сложно. Да и мало кто заморачивается с этим даже для примитивных случаев.

Поэтому, все тормоза ГЦ в большей мере миф. Тормозит там совершенно другое. К тому же, зачем далеко ходить - достаточно посмотреть на С++. Жертвы пропаганды/невежества - везде и всюду используют динамические аллокации(почему читаем выше). Это базовое свойство любой си с классами дристни. Поэтому си с классами так же является скриптухой.

И, теперь, самое важное. Всякая там скриптуха бездарная с ворованными llvm пытается кукарекать, что она статическая и там какого-либо динамического диспатча. На самом деле - он там есть. А даже если его там нет - это не важно. Фокус заключается в следующим. Условно где-то под языком существует какой-либо оптимизатор/трансформатор, который каким-то образом убирает(в каких-то случаях) динамический диспатч. Но.

УБИРАНИЕ ДИНАМИЧЕСКОГО ДИСПАТЧА ГДЕ-ЛИБО -- НИКОИМ ОБРАЗОМ НЕ УБИРАЕТ ЕГО НА УРОВНЕ ЯЗЫКА. Это фундаментальное правило, которое игнорируют бездарные запартные сектанты. Ведь, если вы внимательно слушали, проблема заключается не в том, что есть какой-то там диспатч в ратайме -нет. Проблема заключается в том, что типы затираются. Т.е. если на уровне языка мы имеем A|B - и каким-то чудом мы это свели до B - на уровне языка ничего не поменялась. В рамках системы типов тип как был не определён - таким и остался. Система типов так же остаётся описательной.

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

последствия

Хорошо, но почему это разделение настолько фундаментально? Всё очень просто. Опять вернёмся к самому наглядному типу скриптухи - TS. Недавно опять увидел у пацана проблему, максимально показательную.

class rpc {
  foo(a: number, b: string) {}
  bar(a: string, b: number) {}
}

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

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

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

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

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

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

Здесь сразу становится понятно - почему С++ развивается в сторону языка-кодогенератора. Статический язык - это язык высшего порядка - это мета-язык. Человек не должен писать код. В какой-то степени это понимают запартыши и какие-то потуги в этом направлении у них ведутся, но всё это бесполезно. Это примитивная, бездарная херня, которая никому не нужна. Как-нибудь я подробней об этом(о запарте и почему она обречена) расскажу.

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

И здесь так же можно понять - почему я всегда хейтил и хейчу C++. Си с классами - это чистая скриптуха. Уже полиморфная. А вот C++ как мета-язык не состоятелен. Что мы хотим от мета-языка? Мы хотим, чтобы он производил то, что мы можем произвести руками(с теми же, либо лучшими свойствами). Но он не производил. И вот только с gnu++2a - язык стал в какой-то мере полноценным и позволяет заменить си.

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

ФОРМА - желательно посетить и ответить