Мнение

Почему Julia - отличный язык для итеративной разработки

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

Введение

Язык программирования Julia - это довольно новый язык, который покоряет сообщества разработчиков программного обеспечения и научных вычислений. Это происходит по разным причинам, поскольку язык программирования Julia является одним из самых быстрых из доступных и, безусловно, самым быстрым языком, доступным на таком высоком уровне. Коды языков похожи на язык сценариев с синтаксисом, очень похожим на Python или MATLAB, но при этом остаются невероятно быстрыми. Именно здесь зародился старый девиз: «Идет как Питон, бежит как Си». Однако, хотя язык Julia довольно быстро компилируется, это, безусловно, не единственная привлекательность языка.

Язык использует множественную отправку как парадигму. Это может дать довольно замечательные результаты в программировании, которые вы просто не найдете больше нигде. Множественная отправка часто рассматривается как основа языка и демонстрирует свою прекрасную сущность во многих аспектах языка. Один из способов, которым множественная диспетчеризация сильно повлияла на язык программирования Julia, - это возможность расширять модули по всей экосистеме Julian. Это круто, потому что он создает пакеты, которые вы можете добавлять и уже знаете некоторые методы, даже не заглядывая в документацию.

Множественная рассылка - обзор

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



Почему мне больше всего нравится использовать множественную рассылку
Обзор преимуществ множественной рассылки и почему она мне так нравится. todatascience.com



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

  • Конструкторы
  • Функции

То, как эти двое работают вместе, обычно определяется парадигмой языка, на котором мы работаем. В Джулии обе эти вещи работают с одной и той же концепцией программирования - множественной диспетчеризацией. Это делает Julia невероятно уникальным языком, потому что у нас есть диспетчеризация для создания типов и диспетчеризация для создания методов. Рассмотрим следующий пример:

mutable struct CoolKid
    cool_status::Int64
    function CoolKid(height::Int64, weight::Int64, n_friends::Int64)
        cool_status = height - weight * -n_friends
        new(cool_status)
    end
end

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

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

Строительные блоки

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

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

import Base: +
+(d::Dict, p::Pair) = push!(d, pair)

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



Расширение операторов Джулии с потрясающими результатами
Как загрузить и расширить методы в Джулии, с действительно захватывающим примером. todatascience.com



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

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

d = Dict(:A => [5, 10, 15], :B => [10, 15, 20])
d + :C => [25, 30, 35]

Вывод

Язык программирования Julia на удивление хорошо подходит для множества действительно невероятных вещей. Многие из этих концепций могут быть более научно обоснованными, но я думаю, что большинство может согласиться с тем, что парадигма множественной диспетчеризации является огромным преимуществом для разработки программного обеспечения. Один из способов его применения - итеративная разработка. Это связано с тем, что в Julia можно построить почти все, один метод, например Base.push или Base.filter, виден на всем языке и используется для отправки нескольких типов из нескольких модулей, что, на мой взгляд, довольно гладко! Большое спасибо за то, что прочитали мою статью, и я надеюсь, что она была, по крайней мере, в какой-то мере полезной для демонстрации того, что такого хорошего в написании своего кода и работе с другим кодом в Julia.