Как сделать раст на русском

Добавил пользователь Алексей Ф.
Обновлено: 10.09.2024


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

В 2020 году по итогам опроса разработчиков Stack Overflow самым любимым языком программирования уже пятый год подряд был признан Rust. Многие разработчики уверены в том, что Rust скоро обгонит C и C++ благодаря своему средству проверки заимствований и решению давних проблем, таких как управление памятью, а также неявная и явная типизация.

Сегодня мы поможем вам начать р а боту с Rust независимо от вашего уровня опыта. Мы расскажем, что отличает Rust от других языков, изучим его основные компоненты и поможем написать вашу первую программу на Rust!

Вот что мы рассмотрим в статье.

Rust — это мультипарадигмальный статически типизированный язык программирования с открытым исходным кодом, используемый для создания операционных систем, компиляторов и других программно-аппаратных средств. Он был разработан Грейдоном Хором в Mozilla Research в 2010 году.

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

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

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

Зачем изучать Rust?

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

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

Лучший способ освоить Rust — реальная практика. Для начала напишем первую программу hello-world .

Разберем все части этого кода.

fn

main

Функция main — это то место, где начинается программа.

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

Фигурные скобки. Ими обозначается начало и конец тела кода. Тело сообщает, что делает функция main .

println!

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

("Hello, world!")

"Hello, world!"

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

А это точка с запятой. Она обозначает конец одной инструкции, как точка в предложении. Инструкции — это указания компьютеру выполнить конкретное действие. Чаще всего инструкция состоит из всего одной строки кода. В нашем случае она вызывает макрос. Есть и другие виды инструкций, которые мы скоро увидим.

Теперь рассмотрим основные части программы на Rust и способы их реализации.

Переменные и их изменяемость

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

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

Здесь создана переменная my_name со значением "Ryan" .

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

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

Например, вот этот код выдаст ошибку во время компиляции:

Ошибка в строке 4, где мы попытались установить значение x = 6 . Но значение x уже задано в строке 2 и изменить его нельзя.

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

Представьте, что у вас есть две функции: functionA , которая использует переменную, имеющую значение 10 , и функция functionB , которая изменяет эту же переменную. Выполнение функции functionA будет прервано!

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

Чтобы переопределить это значение по умолчанию и создать изменяемую переменную, объявим ее вот так:

Изменяемые переменные чаще всего используются как переменные-итераторы или как переменные в структурах цикла while .

Типы данных

Пока что мы видели, что значения переменных задаются либо с помощью фраз (называемых строками), либо целых чисел. Эти переменные представляют собой различные типы данных, которые обозначают, какой вид имеют содержащиеся в них значения и какие операции они выполняют.

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

Указав между именем переменной и ее значением : &[type] , мы явно определим тип для этой переменной.

В этом случае наш пример с объявлением my_name будет переписан следующим образом:

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

Допустим, имеется переменная answer , которая записывает ответ пользователя в форму.

Rust неявно определит строковый тип для этой переменной, так как она приводится в кавычках. Тогда как переменная наверняка булева, что подразумевает выбор между двумя вариантами: true и false .

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

Основные типы на Rust:

  • Integer: целочисленный (целые числа).
  • Float: числа с плавающей запятой (с десятичными знаками).
  • Boolean: логический (булев) с выбором между двумя вариантами ( true или false ).
  • String: строковый (набор символов, заключенных в кавычки).
  • Char: скалярное значение Юникод, представляющее конкретный символ.
  • Never: тип без значения (обозначается как ! ).

Функции

Функции — это наборы связанного кода на Rust, объединенные под кратким условным обозначением и вызываемые из других частей программы.

Пока что мы использовали только базовую функцию main() . Rust также позволяет создавать дополнительные, собственные функции, и это очень важная для большинства программ возможность. Функции часто представляют собой одну повторяющуюся задачу, например addUser (добавление пользователя) или changeUsername (изменение имени пользователя). Эти функции затем повторно используются всякий раз, когда требуется выполнить то же самое поведение.

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

Вот формат для объявления функции:

fn

[functionName]

Здесь находится идентификатор функции, который будет использоваться при ее вызове.

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

[parameterIdentifier]

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

[parameterType]

После параметра необходимо явно указать тип. Во избежание путаницы неявная типизация параметров в Rust запрещена.

Фигурные скобки обозначают начало и конец блока кода. Код внутри скобок выполняется при каждом вызове идентификатора функции.

[functionBody]

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

Добавим немного кода. Переделаем hello-world в функцию say_hello() :

Совет? Увидели () — значит, вы имеете дело с вызовом функции. Если параметров нет, получаем внутри скобок пустое поле параметров. Сами скобки все равно остаются, указывая на то, что это функция.

Функция создана, теперь вызовем ее из других частей программы. Программа начинается в main() , поэтому вызовем say_hello() оттуда.

Вот как будет выглядеть полная программа:

Комментарии

В Rust есть два способа писать комментарии. Первый — использовать двойную косую черту // . В этом случае все, вплоть до конца строки, игнорируется компилятором. Например:

Второй способ — предварять комментарий косой чертой со звездочкой /* и завершать его звездочкой с косой чертой */ . Преимущества такого способа оформления комментариев: 1) есть возможность помещать комментарии в середину строки кода и 2) так легче писать многострочные комментарии. Недостаток в том, что во многих случаях приходится задействовать больше символов, чем просто // .

Условные инструкции

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

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

Это пример условного оператора if . Фактически происходит вот что: если hasAccount соответствует false , учетная запись будет создана. И пользователь будет в ней авторизован независимо от того, уже имелась у него учетная запись или нет.

Вот как выглядит формат оператора if :

Есть три основных условных оператора: if , if else и while .

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

Владение

Владение — это центральная особенность Rust и одна из причин такой его популярности.

Во всех языках программирования должна предусматриваться система освобождения неиспользуемой памяти. В некоторых языках, таких как Java, JavaScript или Python, есть сборщики мусора, которые автоматически удаляют неиспользуемые ссылки. В низкоуровневых языках типа C или C++ от разработчиков требуется всякий раз, когда это необходимо, выделять и освобождать память вручную.

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

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

Вот эти правила владения.

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

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

Главный вывод касается разного использования s и x . Сначала x владеет значением 5 , но после выхода ее из области видимости функции main() переменная x должна передать владение параметру number . Ее использование в качестве параметра позволяет продолжить область видимости выделения памяти под значение 5 за пределы исходной функции.

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

Структуры

Еще одним важным понятием в Rust являются структуры, называемые struct . Это пользовательские типы данных, создаваемые для представления типов объектов. При создании определяется набор полей, для которых все структуры этого типа должны иметь какие-то значения.

Аналогом этих структур в таких языках, как Java и Python, являются классы.

Вот синтаксис объявления структуры:

  • struct сообщает Rust, что следующее объявление определит тип данных struct.
  • [identifier] — это имя типа данных, используемого при передаче параметров, таких как string или i32 , в строковые и целочисленные типы соответственно.
  • <> эти фигурные скобки обозначают начало и конец переменных, необходимых для структуры.
  • [fieldName] — это место, где вы называете первую переменную, которую должны иметь все экземпляры этой структуры. Переменные внутри структуры называются полями.
  • [fieldType] — это место, где во избежание путаницы явно определяется тип данных переменной.

Например, создадим структуру struct Car , которая включает в себя переменную строкового типа brand и переменную целочисленного типа year .

Каждый создаваемый экземпляр типа Car должен иметь значения для этих полей. Поэтому создадим экземпляр Car для конкретного автомобиля со значениями для brand (модели) и year (года выпуска).

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

Вот как выглядит вся структура целиком:

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

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

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

Если скачать Rust с официального сайта, Cargo автоматически устанавливается вместе с компилятором ( rustc ) и генератором документации ( rustdoc ) как часть набора инструментальных средств Rust. Убедиться, что Cargo установлен, помогает ввод в командной строке следующей команды:

Для создания проекта с Cargo запустите в интерфейсе командной строки операционной системы следующее:

Первой командой создается новый каталог hello_cargo . А второй командой этот новый каталог выбирается.

Генерируется манифест под названием Cargo.toml , который содержит все метаданные, необходимые Cargo для компиляции пакета, а также файл main.rs , отвечающий за компиляцию проекта.

Чтобы все это увидеть, наберите:

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

Все зависимости приведены в категории dependencies .

После завершения проекта введите команду $ cargo run : проект будет скомпилирован и запущен.

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


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

“Contains violence and caveman themed nudity. In-game nudity, blood, player-made signs, voice chat and text chat can be disabled from the in-game options menu.”

Эта информация предназначена исключительно для проверки и не будет сохранена.

© 2022 Valve Corporation. Все права защищены. Все торговые марки являются собственностью соответствующих владельцев в США и других странах.

Привет всем, друзья! ? Сегодня рассмотрим 10 Мощных онлайн-курсов для обучения программирования на языке R, которые можно пройти абсолютно бесплатно.

ТОП-3 Курсов Программирования Rust для Новичков

?Rust Developer

Углублённый курс по языку программирования Rust, в котором мы разберем:

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

Разработчикам на системных языках (С, C++, …), которые хотят:

  • изучить Rust, его сильные и слабые стороны;
  • научиться избегать ошибки по работе с памятью и многопоточностью;
  • изучить проектирование высокопроизводительного ПО
  • изучить язык, позволяющий делать критические по производительности секции вашего ПО максимально быстрыми;
  • особенности работы с низкоуровневым ПО;
  • подходы к разработке безопасного и отказоустойчивого ПО.
  1. использовать язык Rust для разработки ПО;
  2. разворачивать Rust и среду разработки;
  3. создавать надёжное, отказоустойчивое и высокопроизводительное ПО;
  4. тестировать код;
  5. использовать сторонние библиотеки;
  6. писать асинхронный код.

Один из Курсов программирования Rust

Без выдачи сертификата

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

  • Срок обучения: видео с обучающим контентом.
  • Форма контента: лекции + задания в видео.
  • Связь с преподавателем: нет.
  • Срок регистрации на поток: без ограничений.
  • Необходимый уровень знаний: для новичков.
  • Проверка домашки: без проверки.
  • Цена: бесплатно.
  1. Привет, Rust!
  2. Арифметические вычисления
  3. Переменные
  4. Логический тип данных
  5. Выражение if
  6. Хранилища однотипных данных
  7. Использование простых типов данных в Rust
  8. Перечисления
  9. Кортежи и структуры
  10. Функция
  11. Обобщенные структуры и функции
  12. Использование различных мест хранения переменных
  13. Реализация типов данных в Rust
  14. Анонимные функции
  15. Строка
  16. Диапазон
  17. Срез
  18. Итератор
  19. Типаж.

6 Бесплатных Курсов Программирования Rust с Нуля

Обучение Rust

Без выдачи сертификата

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

  • Срок обучения: видео с обучающим контентом.
  • Форма контента: лекции + задания в видео.
  • Связь с преподавателем: нет.
  • Срок регистрации на поток: без ограничений.
  • Необходимый уровень знаний: для новичков.
  • Проверка домашки: без проверки.
  • Цена: бесплатно.
  1. Зачем нужны языки программирования без сборщика мусора?
  2. Дисциплина владения, линейные типы, RAII.
  3. Ссылки и времена жизни.
  4. Механика языка: встроенные типы, выражения, алгебраические типы данных, macro by example.
  5. Модули, библиотеки и модель компиляции.
  6. Стратегии обработки ошибок.
  7. Параметрический полиморфизм, трейты, статичекое и динамическое связывание.
  8. FFI и unsafe.
  9. Реализация коллекций и итераторов.
  10. Надёжное многопоточное программирование.
  11. Стратегии управления памятью.
  12. Процедурные макросы.

Learning Rust

Без выдачи сертификата

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

  • Срок обучения: видео с обучающим контентом.
  • Форма контента: лекции + задания в видео.
  • Связь с преподавателем: нет.
  • Срок регистрации на поток: без ограничений.
  • Необходимый уровень знаний: для новичков.
  • Проверка домашки: без проверки.
  • Цена: бесплатно.
  1. Basics
  2. Installation, Hello World, Cargo, Crates, Variable bindings, Functions, Primitive Data Types, Operators & Control Flows.
  3. Beyond the Basics
  4. Vectors, Structs, Enums, Generics, Impls & Traits.
  5. The Tough Part
  6. Ownership, Borrowing, Lifetimes & Lifetime Elision.
  7. Let’s Get It Started
  8. Modules, Crates, Workspaces, std modules and Preludes.
  9. Error Handling
  10. Smart compiler, Panicking, Option & Result, Unwrap & Expect, Error & None propagation, Combinators and Custom Error Types.
  11. Stay tuned!
  12. More things are coming in 2021. Stay in touch.

Руководство по языку программирования Rust

Без выдачи сертификата

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

  • Срок обучения: видео с обучающим контентом.
  • Форма контента: лекции + задания в видео.
  • Связь с преподавателем: нет.
  • Срок регистрации на поток: без ограничений.
  • Необходимый уровень знаний: для новичков.
  • Проверка домашки: без проверки.
  • Цена: бесплатно.
  • Глава 1. Введение в язык Rust
  • Глава 2. Основы Rust
  • Глава 3. Составные типы данных
  • Глава 4. Ссылки и Ownership
  • Глава 5. Объектно-ориентированное программирование
  • Глава 6. Время жизни ссылки
  • Глава 8. Модули
  • Глава 9. Обработка ошибок
  • Глава 10. Cargo
  • Глава 11. Ввод и вывод
  • Глава 12. Unsafe-контекст

Без выдачи сертификата

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

  • Срок обучения: видео с обучающим контентом.
  • Форма контента: лекции + задания в видео.
  • Связь с преподавателем: нет.
  • Срок регистрации на поток: без ограничений.
  • Необходимый уровень знаний: для новичков.
  • Проверка домашки: без проверки.
  • Цена: бесплатно.
  1. Введение – установка, первая программа
  2. Переменные
  3. Типы данных
  4. Функции
  5. Условные выражения и циклы
  6. Чтение логов в реальном времени на RUST и запись данных в influxDB.

Без выдачи сертификата

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

  • Срок обучения: видео с обучающим контентом.
  • Форма контента: лекции + задания в видео.
  • Связь с преподавателем: нет.
  • Срок регистрации на поток: без ограничений.
  • Необходимый уровень знаний: для новичков.
  • Проверка домашки: без проверки.
  • Цена: бесплатно.

Один из Лучших Курсов Программирования Rust для Всех – официальная документация

Изучить Rust

Без выдачи сертификата

Обучающая программа: в данной документации, вы найдёте все необходимые шпаргалки по языку программирования Rust: руководства по разработке, инструкции по API и др.

  • Срок обучения: видео с обучающим контентом.
  • Форма контента: лекции + задания в видео.
  • Связь с преподавателем: нет.
  • Срок регистрации на поток: без ограничений.
  • Необходимый уровень знаний: для новичков.
  • Проверка домашки: без проверки.
  • Цена: бесплатно.
  1. СТАНДАРТНАЯ БИБЛИОТЕКА
    Полное руководство по API стандартной библиотеки.
  2. РУКОВОДСТВО ПО РЕДАКЦИЯМ ЯЗЫКА
    Руководство по редакциям Rust.
  3. КНИГА ПО CARGO
    Книга о пакетном менеджере и системе сборки Rust.
  4. КНИГА ПО RUSTDOC
    Узнайте, как создать удивительную документацию для вашего проекта.
  5. КНИГА ПО RUSTC
    Познакомьтесь с опциями, доступными в компиляторе Rust.
  6. РУКОВОДСТВО ПО ОШИБКАМ КОМПИЛЯТОРА
    Подробные объяснения ошибок, которые вы можете получить от компилятора.

?Hola amigos! Здесь я выкладываю подборки с курсами для обучения разным профессиям с нуля. Проект существует с 2021 года и постоянно развивается.

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

Краткая история ценностей в программировании

Чтобы материал хорошо залег в голову и сердце, неплохо кратко вспомнить, что люди хотели сделать в программировании за последние 50 лет и что в итоге у них получилось. Без обид, только личное субъективное мнение и холивар, подкрепленный 20-летним опытом разработки.

Низкоуровневые языки: C, C++


Понятно, что можно писать программу сразу в виде цифр на машинных кодах и многие этим занимались на ZX Spectrum, БК0010-01 и на PC — код получается очень быстрым :-) Но мы люди, в голову много информации не помещается, мы отвлекаемся и поэтому даже изобретение ассемблера не особо помогло — код на таком низком уровне пишется очень редко и очень метко и, скорее всего, если вы не занимаетесь разработкой драйверов, микроконтроллеров или хитрых встраиваемых систем, это в жизни не пригодится.

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

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

Scala, несомненно, большой шаг вперед, т.к. язык, конечно, получился научно-заумный и навороченный, взявший немало полезных и бесполезных вещей из мира функционального программирования. Но вот с популярностью что-то как-то не очень понятно. Однако Apache Spark действительно хорош и популярен, нечего сказать.

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

Скриптинг

  • быстро делаем решение на PHP/python/JavaScript/Node.js, запускаем в бой и начинаем решать задачи клиентов
  • обкатываем фичи, возможности, улучшаем сервисы
  • в редких случаях, по опыту, обычно не ранее, чем через несколько лет, часть таких, уже стабильных по функционалу, сервисов, переписывается на C/C++/Java/Golang/Rust

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

  • мутабельные переменные
  • циклы с условиями
  • функции, создающие побочные эффекты

Системное программирование, еще в начале нулевых, реализовывало себя в основном через C/C++ (возможно, нельзя не упомянуть в этом контексте и знаменитый Forth). А мнение Линуса Торвальдса про C++ как тогда, так и сейчас не утратило своей актуальности, несмотря на попытки великого и ужасного Андрея Александреску изменить ситуацию в D (со сборщиком мусора — ну как же так, опять наступили на эти грабли).

Выход есть — Rust!

Теперь кратко обо всем по порядку.

Как же удалось отказаться от сборщика мусора?

Как добились zero-cost абстракций?

Безопасное программирование и функциональщина

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

В целом понятно, что все сложные и противоречивые концепции системного и многопоточного программирования (освобождение памяти, гонки данных) переложили на систему уникальных аффинных типов со строгими гарантиями компилятора и оно… работает. Строгая система типов и суровая алгебра логики в сочетании с умным компилятором дают вам гарантии получения безопасного/многопоточного кода, работающего со скоростью C/C++ и потребляющего так же мало ресурсов. Причем изначально никто в это не верил.

Многопоточное программирование

За счет описанных выше уникальных для языка и встроенных в компилятор возможностей владения и заимствования, не возникает проблем с порядком установки-снятия блокировок, а многопоточное программирование делается как-то легко и без сюрпризов. Если что-то не так, код просто не компилируется. Я не буду описывать детали трейтов Sync/Send, это нужно увидеть вживую, но ничего сложного и мистического не происходит: реализуете логику, если компилятор ругается, исправляете, вот и всё.

Если хочется реализовать многопоточный сетевой сервис с неблокирующими соединениями, обрабатывающий десятки тысяч сокетов одновременно почти незаметно для процессора, можно взять готовую библиотеку и за 1-2 часа реализовать самые смелые мысли по работе с futures в функционально строгом стиле. Получаем тоже самое, что внутри Node.js и python с async/await, но с гарантией строгих алгебраических типов, работающее гораздо быстрее и с на порядки меньшим потреблением ресурсов. А если результат одинаковый, зачем же платить больше?

Встроенные unit и интеграционные тесты

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

Удобный пакетный менеджер — cargo

Heap и стек

Что может быть очень непонятно

Общие принципы разработки на Rust

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

Детали реализации проекта

Общее ощущение — очень положительные. Еще бы, вместо нескольких железных серверов (8 ядер, 16 ГБ ОЗУ), задача стала решаться одним процессом (с десятками потоков), кушающим не более 5 ГБ ОЗУ и создающим не очень заметную нагрузку на ядра, при трафике в районе 0.5-1 гигабит.

Заключение

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

Читайте также: