Компиляторы *

    public double octaPow(double a) {
        return Math.pow(a, 8);
    }

    public double octaPow(double a) {
        return a * a * a * a * a * a * a * a;
    }

    public double octaPow(double a) {
        return Math.pow(Math.pow(Math.pow(a, 2), 2), 2);
    }

    public double octaPow(double a) {
        a *= a; a *= a; return a * a;
    }

Определить, какие методы быстрые, а какие — медленные (JRE 1.8.0_161).

• Почему это тут золотая медаль справа?
• Как там поживает кросплатформенный SIMD?
• Что будет если 4000 поделить на последнюю пятницу февраля?
• Какие подводные камни нашлись у сопрограмм?
• Какие крутые фишки для многопоточного программирования будут в скором времени доступны?

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

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

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

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

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

Я решил провести эксперимент — сделать прототип языка и посмотреть, что из этого выйдет.

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

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

После нескольких попыток задача была успешно решена. Как — под катом.

Перформансные задачи от Контура уже были, настала и наша очередь: представляем хардкорные задачи с Java-конференции JBreak 2018, aka «ад от Excelsior».

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

Задача 1

Ваш коллега начитался Java Language Specification и написал следующее:

void playWithRef() {
    Object obj = new Object();
    WeakReference<Object> ref = new WeakReference<>(obj);
    System.out.println(ref.get() != null);
    System.gc();
    System.out.println(ref.get() != null);
}

А разгребать вам: какие результаты исполнения возможны?

Сериализация данных посредством serde. Недавно я писал Rust-код для работы со сторонним источником данных в TOML-формате. В других языках я бы подгрузил данные какой-либо TOML-библиотекой и прогнал бы по ним мою программу, однако я слышал про serde — библиотеку сериализации на Rust, так что я решил попробовать ее.

Подробности — под катом.

    void forEach(List<Integer> values, PrintStream ps) {
        values.forEach(ps::println);
    }

    void forEach(List<Integer> values, PrintStream ps) {
        values.stream().forEach(ps::println);
    }

    void forEach(List<Integer> values, PrintStream ps) {
        values.parallelStream().forEach(ps::println);
    }

Как-то я сказал своему коллеге, что в Rust имеются макросы, ему показалось, что это плохо. Раньше у меня была такая же реакция, но Rust показал мне, что макросы не обязательно плохи.

Где и как их уместно применять? Смотрите под катом.

body{font-size: 1em;}
@media screen and (max-width: 1024px){
    body{font-size: 0.8em;}
}

Раньше в Rust были состояния типов, которые были удалены из языка еще до официального релиза первой версии. В этой статье я раскрою вам тайну: Rust поддерживает состояния типов.

Прошу под кат.

Какие Go бенчмарки показывают лучшие результаты, будучи собранными gccgo и почему?

Ответы на эти вопросы под катом.

Давайте познакомимся с Rust, поработав над маленьким проектом! Мы покажем основные концепты Rust на реальном примере. Вы узнаете о let, match, методах, ассоциированных функциях, подключении сторонних библиотек и много о чем другом. Мы реализуем классическую задачу: игра “угадай-ка”.

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

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

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

Wow. Such Rust. Much macro. © картинка - Твиттер аккаунт Servo

Язык Rust стремительно набирает обороты. Кто-то пророчит ему стать заменой C/C++, кому-то он просто нравится. Я скорее принадлежу ко второй группе. Разработчики стараются сделать его удобным и безопасным. В нем есть конструкции и принципы, которые еще не скоро появятся в "плюсах", ввиду инерции комитета и множества других причин. Поэтому, для всех личных проектов я предпочитаю использовать именно Rust.

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

Однажды, когда я в очередной раз застрял с синтаксическим анализатором (он же "парсер"), я подумал, что уж очень много я пишу однотипного кода. И этот однотипный код один в один ложится на грамматику в форме Бэкуса — Наура (БНФ).

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

В статье описана реализация LL(*) парсера с использованием макросов. И реализован парсер простых математических выражений.

В итоге парсер для БНФ грамматики:

expr ::= sum
sum  ::= mul "+" sum | mul "-" sum | mul
mul  ::= atom "*" mul | atom "/" mul | atom
atom ::= "(" expr  ")" | number | neg;
neg  ::= "-" atom

Можно сгенерировать с помощью серии макросов:

rule!(expr, sum);
rule!(sum, or![
     and![(mul, token('+'), sum) => make_operator],
     and![(mul, token('-'), sum) => make_operator],
     mul
]);
rule!(mul, or![
     and![(atom, token('*'), mul) => make_operator],
     and![(atom, token('/'), mul) => make_operator],
     atom
]);
rule!(atom, or![
    and![(token('('), expr, token(')')) => |_lbrace, stat, _rbrace| Some(stat)],
    num,
    neg
]);
rule!(neg, and![(token('-'), atom) => |_, number| Some(Box::new(expression::Expression::Negate(number)))]);

В последнее время я долго думал над персистентными коллекциями и в особенности над тем, как они относятся к Rust. Хочу поделиться с вами своими наблюдениями.

О том, как устроены персистентные векторы, быстрее ли они традиционных коллекций — смотрите под катом.