Ода Джулии



Очень трудно передать весь восторг, который сопутствовал запуску первых программ и исправлению первых ошибок с использованием этого языка. Прост и красив как Python, немножко похож на Fortran, удобная работа с массивами и графиками, а также возможность осуществлять лютую оптимизацию и распараллеливание даже для таких чайников, как я мои одногруппники. Можно работать на разных уровнях абстракции: от высокоуровневого программирования с динамической типизацией можно спуститься до ассемблерных команд, то есть, тут вам и питонская общедоступность и скорость выполнения фортрановских считалок. Не могу отделаться от ощущения, что Mathcad, Scilab и даже, прости Господи, C++ начинают в моем сердце уходить на второй план.


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


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


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


Установка


Под спойлером

На официальном сайте можно найти новости, видеоуроки и загрузить дистрибутив. После установки можно приступать к работе, но всё будет происходить в режиме интерпритатора.
На сайте https://juliacomputing.com доступны продукты, основой для которых послужил этот язык:


  • JuliaDB — для работы с аналитикой баз данных и аналитикой временных рядов, основанными на богатой экосистеме Джулии, а также располагающими встроенным параллелизмом и масштабируемостью.
  • JuliaBOX — Запустите Julia без установки из вашего браузера в ноутбуках Jupyter. Популярна в университетах и среди начинающих пользователей. Для полноценной работы нужно оформлять платную подписку. В бесплатном же режиме некоторые опции будут ограничены, и для доступа к вычислительным ядрам нужно ждать в очереди
  • JuliaRun — Запускайте приложения Julia в публичном или частном облаке. Масштабируемое развертывание в производстве для анализа в реальном времени и для крупномасштабных параллельных симуляций.
  • JuliaFin — Для работы в сфере финансов. Включает в себя все инструменты, необходимые для бэктестинга и торговли: Excel, Bloomberg, моделирование контрактов и JuliaDB.
  • JuliaPro — Бесплатная версия для ученых и исследователей данных. Установите в Windows, Mac или Linux. Доступна расширенная коммерческая лицензия.

Выбираем последний вариант. На момент написания руководства доступна версия 0.6.4.1. После регистрации будет доступно бесплатное скачивание. Пользователи Windows 7/Windows Server 2012 также должны установить:



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


Ну вот, всё наконец-таки установилось, теперь в нашем распоряжении:


  • JuliaPRO Command Prompt — все Юлины умения прямо из интерпретатора.
  • Juno — красивая IDE с окошком для графиков и рабочим пространством, где можно смотреть содержимое всех объектов
  • Jupyter — запускает вычислительное ядро в консоли, а выполнять код можно прямо в браузере. (Помимо Джулии присутствует еще и Питон)

Посмотрим, что умеет этот калькулятор… Поддержка Юникода — можно использовать кириллицу, иероглифы и назвать pi греческой буквой. А еще можно явно не указывать умножение между числом и переменной (именно в таком порядке и без пробела):


x = 5+8
2x - 3x + 2x^2
Out: 325

Все нужные знаки тоже на месте: +=, *=, >>= и т.д. (Знак ">>" (битовый сдвиг вправо). Знаки сравнения: >, >=, <, <=, ==, !=. Неравенства можно объединять в цепочки:


y = 5
y += 2
4 <= y < 8
Out: true

Комплексные числа в наличии:


(2-1im)*(4+3im)
Out: 11 + 2im

И функции для работы с ними:


  • real(z) — действительная часть,
  • imag(z) — мнимая часть,
  • conj(z) — комплексно сопряжённое число,
  • abs(z) — модуль,
  • abs2(z) — квадрат модуля,
  • angle(z) — аргумент комплексного числа.

Можно пользоваться рациональными числами используя "//" и соответствующими функциями:


  • num(x) — числитель,
  • den(x) — знаменатель,
  • float(x) — преобразует к десятичной дроби

x = 4//6+5//7
Out: 29//21
float(x)
Out: 1.380952380952381

В Julia есть возможность управлять внутренним представлением данных:


  • typeof(obj) — тип объекта
  • typemax(obj) — максимальное число этого типа
  • typemin(obj) — мимимальное
  • eps() — машинный ноль
  • BigInt — большое целое
  • BigFloat — большое с плавающей точкой

q = 3
typemax(q)
Out: 9223372036854775807
typeof(q)
Out: Int64
BigFloat(2.3^45/6)
Out: 3.159376405019356000000000000000000000000000000000000000000000000000000000000e+15

Функции


Комплект особоупотребительных функций


  • abs(x) — модуль числа,
  • abs2(x) — квадрат модуля,
  • sqrt(x) — квадратный корень,
  • cbrt(x) — кубический корень,
  • exp(x) — экспонента числа,
  • log(x) — натуральный логарифм,
  • log10(x) — десятичный логарифм,
  • log(b,x) — логарифм x по основанию b.
    А также тригонометрические, гиперболические, Эйри, Бессель и еще много всяких других.

Пользовательские функции:


function имя(аргументы)
    #тело функции
end

Функция возвращает результат последнего выражения (Икнул пользователь Mathcad).


function cube(x)
    x^3
end
cube(4)
Out: 64

Ну, или укажем явно:


function myabs(x)
    if x>=0
        return x
    else
        return -x
    end
end
myabs(-12)
Out: 12

Возвращаемые значения можно собрать в кортеж:


function cubeandsquare(x)
    x^3,x^2
end
a,b = cubeandsquare(3)
print("a = $a, b = $b")
Out: a = 27, b = 9

Функции могут принимать кортежи, значения по-умолчанию, ключевые слова. Если после имени функции отсутствуют скобки, оно рассматривается как переменная и может быть присвоено другой переменной или передано в функцию как параметр. Еще Julia поддерживает и функциональный стиль написания программ (привет Lisp`у)


function mysin(t;A=1,?=1,?=0) # поддержка Юникода - можно использовать греческие символы
    A*sin(?*t + ?)
end
x1 = mysin(pi) # синус Пи = 0
x2 = mysin(pi*0.5,A = 2) # увеличиваем амплитуду в два раза
x3 = mysin(pi*0.5,? = 0.5) # уменьшаем в два раза частоту
print("x1 = $x1, x2 = $x2, x3 = $x3")
Out: x1 = 1.2246467991473532e-16, x2 = 2.0, x3 = 0.7071067811865475

Массивы


Я как пользователь Scilab даже не заметил подмены: можно задать массив с помощью функции:


  • Array{T}(undef, dims...) — Массив типа Т и размерности dims
  • zeros(T, dims...) — Массив нулей
  • ones(T, dims...)- или единиц
    Индексация начинается с единицы, вместо $end, а также определены все необходимые операции для матриц (для того чтоб осуществить, скажем, поэлементное сложение или умножение, перед оператором нужно ставить точку).


(Теперь понятно как картинки вставлять, но ладно уж...)


Базовые функции:


  • det(A) — вычислить определитель
  • A' — транспонировать матрицу
  • inv(A) — инвертировать матрицу
  • length(A) — число элементов
  • ndims(A) — число размерностей
  • size(A) — кортеж размерностей
  • size(A, n) — размерность в заданном направлении
  • copy(A) — создание копии массива
  • linspace(начало, конец, шаг) или
    linspace(начало: шаг: конец) — создание одномерного массива

A = [1 2 3; 6 5 4; 7 8 9]
Out: 3?3 Array{Int64,2}:
 1  2  3
 6  5  4
 7  8  9
A[2,1]
Out: 6
A[end]
Out: 9
size(A) 
Out: (3, 3)

Можно выделять части массива, задавая диапазон индексов вдоль размерности знаком ": ".


m1 = rand(3,2)
m2 = reshape(1:2:11, 3,2)
Out: 3?2 Base.ReshapedArray{Int64,2,StepRange{Int64,Int64},Tuple{}}:
 1   7
 3   9
 5  11
m3 = [m1 m2] # объединение строк (вдоль первой размерности)
Out: 3?4 Array{Float64,2}:
 0.325649  0.701038  1.0   7.0
 0.513579  0.620215  3.0   9.0
 0.815242  0.805307  5.0  11.0
m5 = [m1; m2] # объединение столбцов (вдоль второй размерности)
Out: 6?2 Array{Float64,2}:
 0.325649   0.701038
 0.513579   0.620215
 0.815242   0.805307
 1.0        7.0     
 3.0        9.0     
 5.0       11.0
m3[:, 2:4]
Out: 3?3 Array{Float64,2}:
 0.701038  1.0   7.0
 0.620215  3.0   9.0
 0.805307  5.0  11.0

Здесь использовались rand(), возвращающая массив случайных чисел заданной размерности, и reshape(), изменяющая размерность массива на указанную.


for a in A
    # действия над a из массива A
end  

или


for i in eachindex(A)
   # действия с учётом индекса i 
end 

или


for i = 1 : size(A,n)
# n - вдоль какой размерности бежит индекс (хм.. можно упростить трехмерное ВУ)
   # действия с учётом индекса i 
end 

Графики


Для использования графики нужно докачивать с репозитория пакет на выбор:


  • Pkg.add("Plots")
  • Pkg.add("PyPlot")
  • Pkg.add("Gadfly")
  • Pkg.add("Winston")

Из них наиболее популярен питоновский PyPlot. Модули подключаются командой using, например:


using PyPlot

Однако, давайте попробуем Gaston использующий Gnuplot (качается отдельно).
Загружается Gaston.jl командой


   Pkg.add("Gaston")

И сразу к делу:


using Gaston
t = 0:0.01:1
plot(t, sin.(2?*5*t))


plot(t,sin.(2?*5*t),title="A sine wave",xlabel="Time (s)",ylabel="Amplitude",grid="on",linewidth=3,color="blue",
    yrange="[-1.1:1.1]",marker="ecircle",plotstyle="linespoints",linestyle="-.-")


plot!(t,cos.(2?*5*t),color="red",linewidth=2) # добавляем во фрейм еще один график


x = y = -15:0.33:15
surf(x,y,(x,y)->sin.(sqrt.(x.*x+y.*y))./sqrt.(x.*x+y.*y),title="Sombrero",plotstyle="pm3d")


x = y = -15:0.33:15
surf(x,y,(x,y)->sin.(sqrt(x.*x+y.*y))./sqrt.(x.*x+y.*y),
    title="Edge view of a sombrero",plotstyle="pm3d",gpcom="set view 80,20")


R = [ x+y for x=0:5:120, y=0:5:120]
G = [ x+y for x=0:5:120, y=120:-5:0]
B = [ x+y for x=120:-5:0, y=0:5:120]
Z = zeros(25,25,3)
Z[:,:,1] = R
Z[:,:,2] = G
Z[:,:,3] = B
imagesc(Z,title="RGB Image",clim=[10 200])


histogram(rand(1000),bins=15,norm=1,title="Histogram",yrange="[0:1.6]")


y = 1:40
err = Gaston.ErrorCoords(rand(40))
plot(y,err=err,title="Example of error bars",plotstyle="errorbars")


Можно создавать несколько графических окон (не работает в Jupyter) используя команду h = figure() (Просто вставить между plot'ами). Чтобы сохранить график в виде файла изображения, используйте команды
set_filename("имя.png") # если не указать, выведется на экран
printfigure("png") # сохранить в файл, доступно PNG, PDF, SVG и GIF
Больше информации по пакету Gaston


Заключение


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


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

Комментарии (93)


  1. mkshma
    19.09.2018 19:27
    -3

    язык программирования с динамической типизацией

    Хоть что-то не из прошлого века с такими исходными взлетело вообще? Это же похороны языка прямо с самого старта.


    1. salas
      19.09.2018 21:40
      +2

      А что вас минусуют, хороший же вопрос ставите. Только его ещё чуть сократить надо: что вообще взлетело не из прошлого века?


      Понятно, есть довольно много вещей, явно позиционирующихся как "Better Java(Script)". CoffeeScript, TypeScript, Kotlin. Scala сюда же: она как всё одновременно позиционируется, но в том числе — и, полагаю, наиболее важно для взлёта — таки как drop-in замена джаве. Groovy — самый интересный в контексте вашего вопроса случай: "улучшенная Java", причём "улучшенная" с помощью динамической типизации.


      Взлетел ли Swift? Там своя атмосфера, термины свободного полёта я бы предпочёл к движениям в ней не применять.


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


      1. Aldarund
        19.09.2018 23:00
        +2

        Тайпскрипт вполне себе взлетел\взлетает с нормальной скоростью


        1. salas
          20.09.2018 00:50

          Да, я его указал в списке успешных несамостоятельных языков. С другой стороны, по исходному вопросу любопытно, что он не только веселей всех взлетает, но и ближе всего к Julia в части системы типов, включая "динамичность", т.е. возможность объявить все переменные как implicit any.


          1. 0xd34df00d
            20.09.2018 16:18

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


      1. Fedcomp
        19.09.2018 23:36

        Rust


        1. salas
          20.09.2018 00:29

          Ну да. И Go.


          1. QtRoS
            20.09.2018 12:11

            Скорее 'Ну нет. И Go.'


      1. lair
        20.09.2018 01:38

        что вообще взлетело не из прошлого века?

        .net.


        1. salas
          20.09.2018 01:49

          Ага, переоценил возраст. Думал, оно чуть-чуть, но из прошлого века. На грани, но по 1.0 проходит. Третьим будет.


    1. potan
      20.09.2018 09:48

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


    1. YuraLia
      20.09.2018 17:29

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


  1. masai
    19.09.2018 21:27

    Я в последний раз смотрел на Julia давным-давно, когда он только появился, так что, возможно, скажу глупость. Мне не очень понятна его целевая аудитория. Как язык общего назначения его вряд ли будут использовать, но так язык так себя и не позиционируют. Как замена матлаба? Ну, не знаю. Julia многословнее, сложнее отчасти, да и до матлабовского разнообразия инструметов далековато. Для тех же, кому матлаба мало, уже есть Python.


    Если кто-то использует Julia на регулярной основе, напишите, пожалуйста, какие преумущества склонили вас к использованию этого языка (кроме любопытства :)).


    1. geisha
      19.09.2018 22:35

      Постоянно слышу о простой параллелизации из коробки (я сам язык не пробовал).


      1. geisha
        20.09.2018 00:03

        Только что попробовал. До параллелизации не дошел. С базой знаний — какой-то ад: еле нашел замену функции eye, которую благополучно убрали в одном из прошлых релизов. В linspace не хватает аргументов. Вообще, создалось впечатление, что собрались снобы и решили сделать идеальный язык методом выковыривания самых нужных функций потому что им они не нужны и вообще то же самое можно написать используя выражение с двойными скобками, оператором из стороннего модуля и какой-то там матери. einsum тоже не наблюдается (только сторонний модуль). Вся надежда на параллельное исполнение, но, боюсь, окажется, что там примерно те же проблемы что и в питоне. Но исполняется, конечно, очень быстро.


        1. DelphiCowboy
          20.09.2018 06:44

          еле нашел замену функции eye, которую благополучно убрали в одном из прошлых релизов

          Стрёмно очень! :(
          Такой язык годится только для WRITE ONLY! кода. :(
          Потому что при постоянной утере совместимости с предыдущими версиями поддерживание проекта станет постоянным мазохизмом. :(


          1. mkshma
            20.09.2018 16:30

            Они только месяц как зарелизились. Странно было надеяться на то, что версия 1.0 будет полностью совместима с предыдущими как минимум потому, что это была одна большая бета.


    1. yarric
      19.09.2018 23:01
      +1

      кому матлаба мало, уже есть Python.

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


      1. masai
        19.09.2018 23:14

        Ну, смотря какие задачи. Скажем, в статьях по deep learning матлаб и не встретишь уже. А вообще, да. Тулбоксы в матлабе на любой вкус.


        1. yarric
          19.09.2018 23:22

          в статьях по deep learning матлаб и не встретишь уж

          Нуу прям:


          https://scholar.google.ru/scholar?hl=es&as_sdt=0%2C5&as_ylo=2017&as_vis=1&q=deep+learning+%2Bmatlab&btnG=


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


          1. masai
            20.09.2018 12:14

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


            Collobert, R., Kavukcuoglu, K., Farabet, C., 2011. Torch7: A matlab-
            like environment for machine learning. In: Advances in Neural
            Information Processing Systems.

            Не очень-то в пользу Matlab.


            К тому же язык реализации обычно не упоминается в самой статье. Просто ссылка на Github где-то в сноске.


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


            Возьмите топовые статьи, которые продвинули deep learning, или доклады с топовых конференций. Там тоже матлаб — редкий гость. Не возьмусь утверждать, что его там совсем не будет, у той же NIPS 2018 один из спонсоров — MathWorks.


            Но Matlab явно не самый популярный язык в этой области. Сами посудите. Deep learning сейчас продвигают крупные компании Facebook, Apple, Microsoft, Amazon и т. д., у них интерес практический. Да исследования с помощью Matlab проводить удобно, если ты привык к этому инструменту, хорошо его знаешь. Но приходит пора выкатывать твой код в продакшн. И тут начинаются проблемы. Не так-то просто запихнуть Matlab в Docker (к слову, даже на этапе исследований, не так-то просто и дёшево развернуть с десяток инстансов GPU на AWS с Matlab). Да, конечно, с недавних пор можно экспортировать модель в ONNX, но зачем удлинять цикл разработки и делать его дороже?


            А вот в классическом Computer Vision, Matlab встречается чаще. По крайне мере мне. :)


    1. potan
      20.09.2018 11:38

      Мне синтаксис нравится существенно больше, чем у python или matlab. И стандартная библиотека логичнее устроена.
      Мультиметоды очень приятны.
      На регулярной основе не использую, изредка возникали задачи, в которых применял R, жду следующего случая, что бы попробовать Julia.


    1. homocomputeris
      20.09.2018 15:26

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


    1. topspin
      20.09.2018 17:33

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


  1. alec_kalinin
    19.09.2018 22:14
    +4

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

    А если серьезно, Julia это такой MatLab на стероидах. Писать большие программы на MatLab это ад, да и стоит MatLab просто бешеных денег. Поэтому в сообществе разработчиков научного софта возникла идея написать аналог MatLab'а, но с более качественным внутренним языком и open source.

    Для того времени идея была верной. Научные расчеты на Python были в самом зачаточном виде, особых альтернатив не было. Авторы Julia признавались, что если бы к тому времени был бы NumPy, они бы не стали писать Julia.

    И их идея частично удалась. В основе Julia одно из лучших ядер линейной алгебры и очень хорошие средства параллелизации. Если бы не выстрелил Python, сейчас Julia была бы ведущим языком для научных расчетов.

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

    Сейчас уже в Python перетянули все самые полезные вещи, в том числе и из Julia: cupy — работа на GPU с интерфейсом NumPy, numba — JIT компиляция для научных расчетов, parallel accelerator стянутая из Julia автоматическая параллелизация, всем известный Tensorflow, и т.п.

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


    1. yarric
      19.09.2018 23:15

      Не сказал бы, что Python удобнее MATLAB: например там, где в MATLAB можно написать что-то вроде sin(1:5) в Python придётся писать зубодробительные list comprehensions типа [sin(x) for x in range(1,5)]. Аналога матлабовским тулбоксам в Python нет, а свободный от гарантий зоопарк библиотек не добавляет удобства использования.


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


      1. biseptol
        19.09.2018 23:59

        Python придётся писать зубодробительные list comprehensions

        numpy часто облегчает такие вещи

        np.sin(range(1,5))


      1. alec_kalinin
        20.09.2018 00:00
        +1

        Не сказал бы, что Python удобнее MATLAB: например там, где в MATLAB можно написать что-то вроде sin(1:5) в Python придётся писать зубодробительные list comprehensions

        Это не совсем верно, как раз NumPy и предоставляет удобную векторную нотацию, вот пример с sin

        from numpy import sin, aranage
        
        sin(arange(5))
        


        А вот как раз пример матрично-векторных операций

        import numpy as np
        import numpy.linalg as la
        
        n = 100
        A = np.random.rand(n, n)
        B = np.random.rand(n, n)
        y = np.random.rand(n, 1)
        
        
        # поэлементное умножение
        C1 = A * B
        
        # матричное произведение
        C2 = A @ B
        
        # решение СЛАУ с регуляризацией
        E = np.eye(n)
        x = la.inv(A.T @ A + E) @ A.T @ y
        


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

        Ну как сказать, если вбить в google 'aerospace python jobs' то количество вакансий от крупных компаний будет достаточно большим.


        1. yarric
          20.09.2018 08:26

          NumPy и предоставляет удобную векторную нотацию

          С таким же успехом можно и на C++ это написать.


          вбить в google 'aerospace python jobs

          В aerospace тоже нужны фронтендеры и машин лернеры, я не такой aerospace имел ввиду.


          1. synedra
            20.09.2018 11:20

            Всё можно написать хоть на C++, хоть на брейнфаке. Тезис был про то, что благодаря нумпаю (и утиной типизации итерируемых объектов) можно в ряде случаев избежать громоздких comprehensions с четырьмя уровнями вложенности.


            Ну и лично мне эстетически ближе цепочка функций, чем какой-то хитрый синтаксис на знаках препинания. np.sin(range(5)) — это две штуки, np.sin и range. Я могу понять, что в каком порядке вызывается, благо в питоне функции просто передают результаты друг в друга. Я могу для каждой посмотреть документацию, передать (в общем случае) сколь угодно большое число дополнительных параметров и вообще написать свой аналог, если вдруг захочется. Даже на незнакомом языке можно просто погуглить что-то типа "python3 range arguments" и разобраться. А синтаксический сахар вроде sin(1:5)может иметь тонну неочевидных подводных камней. Какого типа будут выходные числа? С каким шагом? Как себя поведёт sin(x:y) при x=2; y=4.5?


            1. yarric
              20.09.2018 13:03

              Какого типа будут выходные числа? С каким шагом? Как себя поведёт sin(x:y) при x=2; y=4.5

              А range как себя поведёт? А какой-нибудь rng из библиотеки VelosipedPy? А где искать документацию к каждой библиотеке и всегда ли она есть? Прыжки по граблям.


              1. masai
                20.09.2018 14:46

                Ну вот не надо сравнивать VeliosipedPy с официальными тулбоксами. Точно так же можно сравнивать самопальный тулбокс с тем же Numpy.


                А где искать документацию к каждой библиотеке и всегда ли она есть?

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


                Прыжки по граблям.

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


                1. yarric
                  20.09.2018 22:27

                  не надо сравнивать VeliosipedPy с официальными тулбоксами

                  Проблема в том, что у Python официальных тулбоксов нет.


                  Но не стоит абсолютизировать этот тезис

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


                  1. masai
                    20.09.2018 22:59

                    Приведите пример хотя бы одной библиотеки для Python, которая задокументированных также хорошо, как тулбоксы MATLAB.

                    Да хотя бы тот же Numpy. Чем плоха его документация?


              1. synedra
                21.09.2018 08:02

                range себя поведёт согласно своему докстрингу, который я получу с помощью команды help(range).


                1. yarric
                  21.09.2018 09:35

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


                  По-сути чтобы понять, что делает функция, нужно как минимум 1. Идентифицировать функцию; 2. Идентифицировать библиотеку, к которой она относится. С операторами проще.


            1. x67
              20.09.2018 20:33
              +1

              Вектор * скаляр = вектор. Если это подводный камень, то к научному софту лучше не прикасаться. Если же вы имели ввиду тип возвращаемого значения для единственной переменной, то питон в очевидности таких вещей ничем не лучше матлаба, потому что это вопрос а. Стандарта языка; б. Реализации функции.
              Матлаб и матлабоподобные языки действительно удобнее и понятнее питона. Не говоря уже у numpy, которая действительно прекрасная библиотека (правда с необходимостью писать в тысячи раз больше букв и скобок, чем того требует задача), но так ею и останется, что ей никогда не простят те, кто писал на матлабе.
              К тому же в питоне тоже немало способов выстрелить себе в ногу и непонятных и неочевидных вещей. Например отсутствие человеческих массивов и попытка скрыть это списками и numpy. Я сотни раз создавал n мерные массивы в фортране, матлабе и никогда это не вызывало у меня такой горечи, как попытка построить логику программы на срезах из двумерного списка, list(). Его даже опытные питонисты (не изучавшие других языков) ошибочно могут назвать array или matrix в двумерном варианте, хотя это очень далеко от истины.
              И кстати, этот хитрый синтаксис с знаками препинания в ограниченном виде используется и в питоне, и это одна из самых приятных частей питона.
              Матлаб тоже не без недостатков и в конечном счете его недостатки не позволили ему войти в IT. И не смотря на его активное развитие как продукта несколько лет назад (сейчас не слежу), он уже не займет нишу питона даже в области науки о


              1. synedra
                21.09.2018 08:07

                Покажите мне в моём примере умножение вектора на скаляр, сомнения по поводу того, что (с математической точки зрения) при этом получится, или возвращаемое значение для единственной переменной. Я говорил исключительно про сравнение range(x,y) и x:y с точки зрения читаемости.


                1. x67
                  22.09.2018 03:58

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


                  1. masai
                    22.09.2018 11:49

                    Сечение массивов появилось только в Fortran 90 (как и многие другие полезные элементы языка), а Matlab был разработан в 80-х. Скорее всего это Fortran позаимствовал синтаксис у Matlab.


      1. Dark_Daiver
        20.09.2018 07:46

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

        Очень спорное утверждение, можете раскрыть мысль?


        1. potan
          20.09.2018 14:00

          Для авионики действительно использовать его глупо. Там требуется высокая надежность и высокая производительность, Python не обеспечивает ни того, ни другого.
          Но для авионики надежность Julia тоже не будет достаточной, динамическая типизация, сборки мусора и труднопредсказуемый JIT будут мешать.


          1. masai
            20.09.2018 14:32

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

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


            Дело не в надёжности и производительности самого языка. Если мы говорим об авионике как об электронном обрудовании самолётов, то там, уж извините, и Matlab никак не прикрутишь. Бортовая ЭВМ не потянет.


            Если же мы говорим об авиастроительной отрасли и исследованиях, то там Python не прижился просто потому, что до него ниша уже была занята и не было нужды в чём-то ещё. Работает — не трогай.


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


    1. masai
      19.09.2018 23:18

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


      1. alec_kalinin
        20.09.2018 00:07

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

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

        Вот к примеру расчет гравитационных волн от слияния черных дыр.


        1. masai
          20.09.2018 12:22

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


          А так я сам давно уже на Python перешёл по указанным вами причинам.


  1. MechanicZelenyy
    19.09.2018 23:38

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


    Поумерю ваш пыл и добавлю ложку дёгтя:
    1) Возможность использовать греческие символы и прочую ересь — это только красивая игрушка, бесполезная в прикладной разработке, поскольку она ломает одну из главных функций любого редактора кода/IDE — автодополнение кода, кроме того осложнит работу с кодом в непривычный среде — например в этой статье греческие символы неотображаются.
    2) Управление пакетами даже хуже чем в python, особенно если сравнивать с maven и gradle.
    3) Если сравнить скорость роста интереса сообщества к Джули с Растом и Котлином, то создается ощущение что это мертворожденый проект.
    4) Качество существующих библиотек ужасное, научный код в его худших проявлениях, достойный наследник ROOT
    5) Параллелизация из коробки на деле оказывается не такой уж фичей — в целом классе задача она бесполезна (например Монте-Карло методы, сбор данных) и нужна нормальная многопоточность/ асинхроность, а параллелизацию тензорных вычислений можно и в python получить. Koltin в этом плане удачнее.
    6) Стремный синтаксис с точками восклицательными знаками, хорошо что в python нет этой matlabщины


    1. 0xd34df00d
      20.09.2018 02:01

      Вот с юникодом да, я в Agda об него руки сломал.


      1. khim
        20.09.2018 05:51

        Ну Юникод — это просто стандарт сегодня. Даже в C++ он есть.


        1. 0xd34df00d
          20.09.2018 06:33

          Я понимаю, но вот это — это перебор.


        1. MechanicZelenyy
          20.09.2018 09:56

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

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


        1. masai
          20.09.2018 12:24

          Какая из этих букв русская, а какая латинская: А и A? А ведь это разные имена переменных.


    1. Yermack Автор
      20.09.2018 09:38

      Ну Юникод я действительно не считаю прям таки каким-то преимуществом, но, например, выполнить курсовую в юпитере или сделать методичку на нем же вышло гораздо нагляднее с греческими символами, вот я и порадовался. На счет Питона особо не берусь сравнивать: за несколько дней прошел питон-тьютор, и он как-то наскучил своими придирками к пробелам ии табуляциям. Возможно Юлия цепляет некой романтикой — сразу чувствуется работа мечтателей. Но на красоту, простоту и мощь не стоит закрывать глаза. Поковырявшись пару вечеров в блогах и мануалах, я набросал на юпитере зачатки этого пособия, и всего вышеперечисленного материала вполне хватило, чтоб запилить решалку трехмерного волнового уравнения и прогу для моделирования фононных спектров. Не знаю на счет других универов, но у нас профессора понимаю только фортран, доценты учат сям и плюсам, а студенты перебиваются считалками типа маткада-матлаба, результаты которых предоставить нельзя так как у нас с нелицензиями строго. А питон задерживает внимание ненадолго — как правило у нас требовательные расчеты, хотя да, на NumPy Есть надежда. И тут у меня вопрос к хабровчанам — какой у нумпай порог вхождения для незнакомого с питоном человека? Скажем, для пользователя фартрана и с++?


      1. masai
        20.09.2018 12:28

        После Fortran за день можно научиться писать какие-то вычислительные алгоритмы, где обычно ничего сложнее циклов нет, а если векторизовать вычисления, то и циклов не будет. Если есть опыт Matlab — так и вовсе за час пересесть можно, даже названия функций учить не придётся. :)


        Хотя я когда-то занимался численными методами, и должен сказать, что Fortran 2008 очень даже неплох.


      1. salas
        20.09.2018 20:09
        +1

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


    1. potan
      20.09.2018 09:53

      Основное использование Julia — через Jupyter. Там греческие буквы можно вводить как в TeX — написать \lambda и нажать табуляцию. При конвертации нотебука в pdf это выглядит красиво.


  1. potan
    20.09.2018 09:49

    В функции myabs писать return не надо. Без него читабельнее.


    1. rraderio
      20.09.2018 10:52

      Нет


  1. worldmind
    20.09.2018 11:13

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


    1. potan
      20.09.2018 11:42

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


      1. worldmind
        20.09.2018 11:57

        А можно ссылки или подробности? Мультиметоды в питоне можно реализовать, конечно может не максимально красивым способом.
        Замыкания куда уже проще?
        Производительность специальных либ типа numpy разве хуже?


  1. potan
    20.09.2018 11:46

    Julia мне нравится, но ложку дектя вылью.
    Нумерация в массивах с единицы в 21 веке выглядит странно — вроде уже все привыкли, что ноль, это нормальное число.
    Нет TCO. Хотя они не отказываются от ее полезности, но реализацию считают низкоприоритетной. Между тем рекурсивные программы часто нагляднее, что полезно при использовании языка в преподавании.


    1. yarric
      20.09.2018 13:10

      А что плохого в нумерации с единицы? Проще написать i=1:N чем i=1:N-1


      1. potan
        20.09.2018 14:09

        Аксиоматика натуральных чисел логичнее, если в них включать ноль. То, что он выпадает из допустимых индексов несколько странно. Можно было бы пересмотреть семантику ':', что бы он не включал веркхниб границу, тожда было бы 0:N.


      1. worldmind
        20.09.2018 14:15

        Даже если не обсуждать причины почему надо нумеровать с нуля (которые конечно же есть), понятно что это общепринято в отрасли и нужно иметь веские аргументы для того чтобы это менять.


        1. yarric
          20.09.2018 15:00

          В отрасли вообще-то общепринят фортран и матлаб.


          1. worldmind
            20.09.2018 15:19

            Говоря отрасль я имел ввиду ту отрасль человеческой деятельности, которая опирается на Computer Science, а не группу пользователей конкретного математического пакета.


      1. masai
        20.09.2018 14:22

        А что плохого в нумерации с единицы? Проще написать i=1:N чем i=1:N-1

        Вы, наверное, имели в виду 0:N-1.


        Вообще, об этом даже Дейкстра ещё писал в заметке «Why numbering should start at zero».


        Если кратко, для диапазонов удобнее использовать полуотрезки a ? i < b, чем отрезки a ? i ? b, так как:


        • полуотрезки легче объединять — точка разделения будет только в одном из них, и не придётся писать лишний раз +1;
        • длину полуотрезка можно найти как b - a.

        А если у нас N элементов, то весь диапазон индексов задаётся как раз полуотрезком 0 ? i < N.


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


        Второе преимущество (больше программистское, чем математическое) — семантика индекса как смещения относительно превого элемента.


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


        1. masai
          20.09.2018 14:34
          +1

          Забыл добавить, что 0:N-1 выглядит некрасиво именно в Matlab, который включает оба конца в диапазон. В том же Python, где используются полууотрезки, этот же диапазон выглядит как 0:N.


        1. yarric
          20.09.2018 15:06
          -3

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


          Объединение массивов в нормальном языке вроде MATLAB делается вообще без индексов. Нотация 1:N (не включая N) хуже тем, что невключение уже не очевидно.


          1. worldmind
            20.09.2018 15:13
            +1

            Дейкстра даже не программист был

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


            1. yarric
              20.09.2018 15:23
              -1

              Это не личности, просто факт: чувак писал свои рекомендации программистам ручкой на бумаге. Если я вам скажу, что я не написал ни одной строчки кода — будете ли вы серьёзно относится к моим советам по программированию?


              1. worldmind
                20.09.2018 15:53

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


                1. yarric
                  20.09.2018 16:30

                  masai даже потрудился пересказать они о стройности архитектуры,

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


                  1. rraderio
                    20.09.2018 16:38
                    +1

                    А можете привести пример на каком-то реальном языке программирования где полезно на практике i=1:N?


                    1. yarric
                      20.09.2018 17:23

                      В матлабе полезно: функции нахождения длины вектора возвращают количество элементов N, соответственно естественно писать 1:N для обозначения индексов всех элементов вектора.


              1. rraderio
                20.09.2018 15:55
                +2

                en.wikipedia.org/wiki/Edsger_W._Dijkstra
                he worked as a programmer at the Mathematisch Centrum (Amsterdam) from 1952 to 1962

                чувак писал свои рекомендации программистам ручкой на бумаге
                А должен был писати рекомендации на Фортране?


              1. khim
                20.09.2018 16:08

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

                Если я вам скажу, что я не написал ни одной строчки кода — будете ли вы серьёзно относится к моим советам по программированию?
                Как раз если выяснится, что вы знакомы только с современной технологией если достаточно долго месить чан с перловой кашей, в синтаксическом мусоре можно рано или поздно узреть лик Ларри Уолла и на листе бумаги не можете изобразить ничего — я буду относиться к вашим советом с куда большим подозрением, чем к советам человека, программы которого переносили на перфокарты «специально обученные люди» и который просто вынужден был думать о том как созданный им компилятор будет работать…


          1. masai
            20.09.2018 18:39
            +1

            Дейкстра даже не программист был

            Он, например, один из разработчиков компилятора ALGOL 60 и операционной системы THE. Думаю, он заслужил, чтобы к его аргументам хотя бы прислушаться.


  1. TitovVN1974
    20.09.2018 12:23

    Пакеты постоянно изменяются. Простая задача может занимать много памяти. Fortran + MKL считает быстрее.


  1. dim2r
    20.09.2018 15:08

    простой вопрос — что будет при переполнении числа?


    1. masai
      20.09.2018 18:52

      Проверил.


      julia> UInt8(255) + UInt8(1)
      0x00

      Но есть BigInt для длинной арифметики.


      1. dim2r
        20.09.2018 23:07

        любое число в расчетах можно переполнить, но будешь ли ты об этом знать?


  1. homocomputeris
    20.09.2018 15:24

    Как я понял, «скорость как у Си» можно получить, только если использовать мультиметоды, но вот тут начинаются пляски, когда Джулия вываливает три страницы трейса, потому что ты вызвал

    f(0, 1) 
    вместо
    f(0.0, 1.0).

    Ну и постоянные перепиливания API — это жуть. Спёрли бы просто все названия у Матлаба, который и хотят заменить, и было бы всё ок.
    Надеюсь, ко 2-й версии устаканится всё, хотя и сейчас уже большие вещи пишут.


  1. kirtsar
    20.09.2018 15:44
    +1

    Главные features языка Julia — это богатая система типов и multiple dispatch.
    Благодаря ним можно писать единообразный лаконичный код:

    rand()                 # случайное число на [0, 1]
    rand(n)                     # случайный вектор с координатами, р.р. на [0,1]
    rand(m, n)                # случайная матрица размера m x n
    rand(k, m, n)             # случайный трехмерный массив и т.д.
    using Distributions  # подключаем пакет с распределениями, аналог import
    d= Normal()             # и используем, например, станд. норм. распр.
    rand(d)                     # случайное число, взятое из распределения d
    rand(d, n)                # случайный вектор... и так далее
    


    Одна функция = множество методов, каждый заточен на свой тип и компилируется в довольно шустрый llvm-код. Ещё пример:
    using DataFrames
    using RDatasets         # пакет со всякими известными датасетами
    df = dataset("datasets", "iris")
    
    df[1, :]              # первая строка датафрейма df
    df[:, 1]              # первый столбец датафрейма df
    df[:Species]     # столбец с именем Species
    

    Аналогично pandas-ам можно индексироваться и по булевским векторам, и по range. Но без всяких loc-iloc.
    Другой пример предоставляет пакет Plots с его универсальной функцией plot на все случаи жизни.

    Второе, чем хороша — легкая обратная связь посредством REPL.
    Макросы @benchmark (аналог %timeit в ipython) и @code_llvm — для просмотра сгенерированного низкоуровневого кода. Если видно, что в @code_llvm какая-то беда, то, манипулируя высокоуровневыми абстракциями и используя этот макрос, можно добиться хорошего качества низкоуровневого кода (при этом не написав ни одной строки на ассемблере).
    Для получения справки по функции достаточно набрать ?<имя>, для выхода в bash и навигации по файловой системе к примеру — начать команду с; (и т.д., так что REPL в Julia очень умная, аналог ipython).

    Почему вдруг черт дёрнул писать на Julia и чем недостаточно было Python+numpy?
    Это вопрос на статью, если вдруг кому-то нереально интересно, то могу написать. Короткий ответ такой: python + numpy абсолютно ОК до тех пор, пока вы не выходите за пределы векторизованных операций (единообразные преобразования датафреймов, всякая лин.алгебра и т.д.). Если вы начинаете писать что-то своё с большим кол-вом циклов (см., например, NIST-овские тесты на псевдослучайность последовательности, к примеру алгоритм Берлекэмпа-Месси и т.д.) — начнутся проблемы со скоростью. Дальше будет либо cython (с линтером, с уродливыми типами, да и вообще, почему бы тогда сразу не писать на Си?), либо numba (не всегда дает большой прирост в скорости). Более развернуто могу в отдельной статье, но если кому-то интересно, потому что писать статьи долго :)


    1. Yermack Автор
      20.09.2018 15:50

      «Это вопрос на статью, если вдруг кому-то нереально интересно, то могу написать.» —
      было бы неплохо. А то все как-то набросились и я теперь в сомнениях: с одной стороны питонские инструменты, уже популярные и проверенные, а с другой стороны Юлия, про которую много обещаний, но со стороны публики холодный прием — как бы не свернули лавочку, и переучиваться потом с мертвого языка…


      1. topspin
        20.09.2018 17:57

        Все зависит от Ваших целей. Если хотите писать крупный проект с большим количеством сложно векторизуемых циклов, то на пайтоне придется повозиться (Numpy+Numba) и то вероятно в скорости проиграете. Вообще, у Julia очень низкий порог вхождения, так что попробовать можно, а там уже и к Python'у не захотите возвращаться)


      1. masai
        20.09.2018 18:45

        А то все как-то набросились

        А вы нас не слушайте. У нас свои задачи, у вас свои. :)


    1. homocomputeris
      20.09.2018 16:41

      Было бы отлично, особенно сравнение.


    1. alec_kalinin
      21.09.2018 00:51

      Почему вдруг черт дёрнул писать на Julia и чем недостаточно было Python+numpy? Это вопрос на статью, если вдруг кому-то нереально интересно, то могу написать.

      Поддерживаю, очень интересно!

      Я сам долго мучался с проблемой выбора инструмента и все-таки остановился на Python. Да cython (местами уродливый), да numba (далеко не гарантия) и да, местами С. Но для моей задачи удалось очень хорошо локализовать эти критические места и аккуратно их спрятать за простой интерфейс. Зато на высоком уровне получилась сказка — просто, понятно и быстро за счет оптимизированного низкого уровня. Так получилось, что 70%-80% процентов активной разработки в моем проекте как раз было на верхнем уровне. В результате Python зашел просто идеально.

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


  1. NIN
    20.09.2018 17:51

    Хм, неужели я единственный, кто ассоциировал произношение/происхождение названия Julia с Множеством Жюлиа??


    1. topspin
      20.09.2018 17:58

      Как говорят авторы языка, слово Julia не несет никакого смысла, просто красивое имя.


      1. yarric
        20.09.2018 22:21
        -1

        А уж прочтённое на испанский манер совсем хорошо звучит.