Основы Rust. Глава 1 — Знакомство с Rust



    Rust — это язык программирования, разработанный Mozilla и поддерживаемый большим опенсорс-сообществом. Начал его разрабатывать Graydon Hoare в 2006 году. Mozilla начала спонсировать проект в 2009 и впервые он был официально представлен в 2010 году. Над проектом было проведено много работы и первая стабильная версия, под номером 1.0.0, вышла в свет 15 мая 2015 года. Rust основан на ясных и твердых принципах. Он является системным языком программирования, и по возможностям не уступает C и C++. Rust такой же быстрый, как и C++, при этом делает вашу работу более безопасной, так как в нем запрещено использовать код, способный вызвать сбой программы из-за проблем с памятью. Кроме того, в Rust встроены функции, позволяющие работать с многоядерными машинами, при этом параллельное программирование безопасно для памяти и не используется сборщик мусора. Это первый язык, в котором подобное реализовано. Rust также предотвращает повреждения данных при совместном их использование, именуемом также, как гонка данных (data races).

    В этой главе мы расскажем о преимуществах Rust’а и установим его на нашу машину.

    Преимущества Rust


    Компания Mozilla известна своим вкладом в развитие веб инструментов, в первую очередь, таким детищем, как браузер Firefox. На сегодняшний момент все браузеры, включая Firefox, написаны на C++. Firefox имеет примерно 12,900,992 строк кода, а Chrome 4,490,488. Это позволяет им быть быстрыми, но в тоже время небезопасными, так как в C/C++ разрешены манипуляции с памятью, но отсутствует проверка валидности. Если разработчик не уделит должного внимания к своему проекту, то велика вероятность, что программа будет падать, происходить утечка памяти, переполняться буфер и возникать нулевые указатели. Некоторые из ошибок могут привести к серьезным проблемам в безопасности, которые хорошо известны в современных браузерах. Rust разрабатывался для того, чтобы избежать подобных проблем.

    С другой стороны, мы имеем Haskell, который, как известно, является очень безопасным и надежным языком, но с очень скудным контролем распределения памяти и прочих системных ресурсов. Давайте представим себе график «контроль-безопасность» и наложим на него разные языки программирования. Будет казаться, что чем язык склонен больше в сторону безопасности, тем он больше теряет на низкоуровневом контроле. Противоположность также прослеживается: если язык предоставляет больше контроля надо ресурсами, то он является менее безопасным.


    В Rust для решения этой дилеммы сделали следующее:
    • Мощная система типизации обеспечивает высокую безопасность
    • Используется глубокое, но в тоже время безопасное, низкоуровневое управление ресурсами (примерно, как в C/C++)

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

    Rust достигает обе цели без сборщика мусора, который присутствует в большинстве современных языках, таких как Java, C#, Python, Ruby, Go. На самом деле, в Rust этого сборщика мусора просто нет (но планируется быть). Rust является компилируемым языком: компилятор придерживается строгих правил безопасности, благодаря которым отсутствуют дополнительные затраты на выполнение кода. В результате чего, Rust’у требуется минимум времени на выполнение, а иногда и вовсе оно не требуется. Таким образом, Rust можно использовать в режиме реального времени или как встраиваемый проект.

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

    Троица Rust — безопасность, скорость и многозадачность


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

    Разработчики создавали Rust с целью сделать его универсальным и мультипарадигмальным языком. Как и C++, Rust императивен, структурирован и объектно-ориентирован. Помимо всего прочего, он перенял многое из функциональных языков и имеет дополнительные функции для многозадачного программирования.

    В Rust типизация переменных статична (поскольку Rust компилируемый) и сильна. Однако, в отличие от Java или C++, разработчику не нужно указывать типы для всех элементов, так как компилятор Rust во многих случаях способен самостоятельно определять типы данных.

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

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

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

    Rust разрабатывался с целью быть таким же портируемым, как и C++, и работать на разном оборудование и программных платформах. В настоящее время он работает на Linux, Mac OS X, Windows, FreeBSD, Android, и iOS. Он может запускать код на Си так же просто и легко, как если бы Си запускал собственный код, и наоборот- Си может запускать код, написанный на Rust.

    Сравнение с другими языками


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

    Объектная ориентация в Rust не является настолько явной и продвинутой, как в объектно-ориентированных языках, таких как Java, C#, и Python, поскольку в нем нет классов. По сравнению с Go, Rust дает вам больше контроля над памятью и ресурсами, это позволяет писать код на более низком уровне. Go также работает со сборщиком мусора, и он не имеет универсальных шаблонов или механизмов для борьбы с гонками данных между его goroutines, который используется для многозадачности. Julia фокусируется на числовой вычислительной производительности. Она работает с компилятором JIT и не дает вам такого низкоуровневого контроля, который предоставляется в Rust.

    Использование Rust


    Из предыдущего раздела напрашивается вывод, что Rust можно использовать в проектах, где обычно используют C и C++. Действительно, многие видят в Rust преемника или замену C и C ++. Хоть Rust и разрабатывался в качестве системного языка, его можно использовать для разных задач, благодаря своему богатому функционалу, что делает его идеальным кандидатом для приложений, входящих в одну из перечисленных групп:
    • Клиентские приложения, такие как браузер
    • Низкая задержка, высокая производительность, в таких вещах, как драйвера устройств, игры и обработчик сигнала
    • Распределенные и параллельные системы, такие как серверные приложения
    • Системы в режиме реального времени, такие как ядро операционной системы
    • Встроенные системы (это требует минимального времени выполнения) или среда с ограниченными ресурсами, такие как Raspberry Pi, Arduino или робототехника
    • Инструменты или сервисы, которые не терпят долгих задержек, например JIT-компиляция
    • Web-фреймворки
    • Крупномасштабные, высокопроизводительные, ресурсоемкие и сложные программные системы

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

    До выхода стабильной версии Rust, две кампании уже выпустили в продакшн свои проекты:
    • OpenDNS — это промежуточный инструмент для блокировки вредоносных программ и доменов
    • Skylight — это инструмент для мониторинга запущенных Rails приложений

    Установка Rust


    Скачать Rust можно на официальном сайте. Платформа поддерживает три основные операционные системы (Linux 2.6.18 и старше, OS X 10.7 и старше, Windows 7- 8 и Windows Server 2008 R2), в 32 и 64-битном форматах. Для работы лучше использовать стабильную версию. Если вы захотите воспользоваться самой свежей версией, можете установить ночную сборку.

    Для установки Rust на Windows запустите инсталлятор. Для Linux и Mac OS X самым простым способом будет ввести следующую команду в консоли:
    curl -sSL https://static.rust-lang.org/rustup.sh | sh
    

    Проверить корректность установки можно с помощью просмотра текущей версии Rust в системе, для этого используйте rustc -V или rustc –version, вы увидите что-то наподобие этого:
    # rustc -V
    rustc 1.0.0-beta.5 (7b4ef47b7 2015-05-11) (built 2015-05-11)
    

    Rust можно удалить через стандартную программу удаления в Windwos, и с помощью /usr/local/lib/rustlib/uninstall.sh в Linux.

    Rust также был портирован на Android OS, iOS и ARM процессоры.

    Для того, чтобы запустить Rust во встроенной среде, был разработан стек под названием zinc. Однако, пока что Rust работает только на архитектуре ARM.

    Исходный код Rust’а лежит на GitHub, о том, как собрать его из исходников можете почитать здесь.

    Rust компилятор — rustc


    В корневом каталоге Rust располагается rustc, вы можете найти его в следующих директориях:
    • Для Windows – C:\Program Files\Rust stable 1.0\bin, если вы не меняли папку по умолчанию
    • Для Linux или Mac OS X – /usr/local/bin

    Если домашняя директория Rust была прописана в переменной PATH, то rustc можно вызывать из любого места терминала. Библиотеки Rust вы можете найти в папке rustlib каталога bin на Windows, или в /usr/local/lib/rustlib в Linux. HTML документация лежит в папке C:\Program Files\Rust stable 1.0\share\doc\rust\html на Windows, и /usr/local/share/doc/html в Linux.

    Команды rustc имеют следующий формат: rustc [options] input.

    В опциях указывается одна буква с одним тире, например -g или -W, а в слове- с двумя: –test, –no-analysis. Для вызова справки по командам используйте rustc -h.

    Наша первая программа


    Давайте начнем с сообщения приветствия нашим игрокам:

    1 — Создайте новый файл с помощью текстового редактора и введите туда следующий код:
    fn main() {
    	println!("Добро пожаловать в игру!");
    }
    

    2 — Сохраните файл с именем welcome.rs
    .rs – это стандартное расширение для файлов Rust. Имя файла не должно содержать пробелов, если вам необходимо разделить слова, то воспользуйтесь нижним подчеркиванием, например start_game.rs.

    3 — Дальше нам нужно скомпилировать код, для этого введи в консоли следующее:
    rustc welcome.rs
    
    Эта команда создаст файл welcome.exe в Windows и welcome в Linux.

    4 — Запустите программу, вы увидите следующее:
    Добро пожаловать в игру!
    

    Исполняемый файл получает такое же имя, какое имеет файл исходника. Если вы хотите задать исполняемому файлу другое имя, скажем start, скомпилируйте код с параметром -o имя_файла:
    rustc welcome.rs -o start
    

    Параметр rustc -O производит оптимизацию для ускорения работы программы (это эквивалентно команде rustc -C opt-level=2, наиболее оптимизируем код генерируется с помощью opt-level=3).

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

    Поясним приведенный код выше. Если вы уже работали с такими языками, как C/Java/C#, этот код покажется вам знакомым. Как и в большинстве языков, выполнение кода начинается в функции main(), которая является обязательной в программах.

    В больших проектах, где используется много файлов, функция main() хранится в файле с именем main.rs.

    main() объявлена как функция, поскольку до имени установлено ключевое слово fn, короткое и элегантное, как и большинство ключевых слов в Rust. В скобках указывается список параметров, в нашем примере он пуст. Код функции помещен в блок, который окружен фигурными скобками {}.

    В нашем блоке всего одна строчка. Для удобства чтения мы сделали отступ в четыре пробела, Rust не чувствителен к пробелам. Программа печатаем нам текст «Добро пожаловать в игру!». Эта строка была передана в качестве параметра макросу println!, восклицательный знак указывает на объявление макроса, а не функции. Строка заканчивается точкой с запятой, как и большинство строк в Rust.

    Работаем с Cargo


    Cargo – это менеджер пакетов и зависимостей в Rust, он похож на Bundler, npm, pub, pip в других языках. Не смотря на то, что вы можете писать программы на Rust без него, Cargo незаменим для любого крупного проекта. Он устанавливается вместе с Rust и доступен из коробки.

    Cargo умеет делать следующее:
    • С помощью команды cargo new создается структура папок и несколько шаблонов для вашего проекта
    • С помощь cargo build компилируется (собирается) код
    • С помощью cargo run запускается проект
    • С помощью cargo test запускаются юнит-тесты, если они присутствуют
    • С помощью cargo update загружаются зависимые пакеты, которые были указаны в специальном файле

    Давайте переделаем наш проект, используя Cargo:

    1 — Создайте новый проект welcomec:
    cargo new welcomec --bin
    

    Опция –bin сообщает Cargo, что мы хотим создать исполняемую (бинарную) программу. После выполнения этой команды у нас будет следующая структура:
    # cd welcomec/
    welcomec # tree
    .
    ├── Cargo.toml
    └── src
        └── main.rs
     
    1 directory, 2 files
    

    Создается папка с названием проекта, в корне этой папки вы можете разместить все виды общей информации: файл лицензии, README файл и тд. В подпапке src лежит шаблон исходного кода с именем main.rs (в нем содержится такой же код, что мы писали ранее, только строка имеет надпись «Hello world!»).

    Файл Cargo.toml (с заглавной буквой C) – это конфигурационный файл или манифест вашего проекта. В нем содержатся все метаданные, которые нужны Cargo для сборки вашего проекта. Он придерживается формата TOML, и содержит следующий текст с информацией о проекте:
    [package]
    name = "welcomec"
    version = "0.0.1"
    authors = ["Your name <you@example.com>"]"
    

    Этот файл можно редактировать и добавлять другие разделы. Например, мы можем добавить раздел, в котором будем говорить Cargo, что хотим иметь название скомпилированного файла welcome:
    [[bin]]
    name = "welcome"
    


    2 — Мы можем собрать проект при помощи следующей команды:
    cargo build
    

    По завершению сборки будет выдано следующее сообщение (на Linux):
    Compiling welcomec v0.1.0 (file:///home/ska1n/Source/rust/welcomec)
    

    Теперь, в нашем проекте вот такая структура каталогов:
    welcomec # tree
    .
    ├── Cargo.lock
    ├── Cargo.toml
    ├── src
    │   └── main.rs
    └── target
        └── debug
            ├── build
            ├── deps
            ├── examples
            ├── native
            └── welcomec
     
    7 directories, 4 files
    

    В каталоге target лежит наш исполняемый файл welcomec.

    3 — Для запуска программы используйте следующую команду:
    cargo run
    

    Будет выдан следующий результат:
    Running `target/debug/welcomec`
    Hello, world!
    

    На втором шаге также создается файл с именем Cargo.lock. Его использует Cargo для отслеживания зависимостей в вашем проекте. На данный момент в нем содержится только информация о приложение:
    [root]
    name = "welcomec"
    version = "0.0.1"
    

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

    Инструменты разработки


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

    Создано множество плагинов для текстовых редакторов, таких как Atom, Brackets, BBEdit, Emacs, Geany, GEdit, Kate, TextMate, Textadept, Vim, NEdit, Notepad++, и SublimeText. Большинство разработчиков работают с Vim или Emacs. Для них создан проект под названием racer. Он включает в себя подсветку синтаксиса и автозавершение кода.

    Другие инструменты


    RustDT – это новая и многообещающая Rust IDE, основанная на Ecplise. Помимо всех возможностей, которые есть в Eclipse, в нем используется Cargo, имеется автозавершение кода и система отладки (используется GDB).

    Существуют также плагины для других IDE, с разным состоянием завершенности:

    Также существует сервис Rust Play Pen, в котором можно запускать код на Rust из браузера.

    rusti – это простая интерактивная среда программирования (REPL), которая разрабатывается для Rust. Проект впечатляет, поскольку подобные среды используются для динамических языков, но никак не для статических.

    Оригинал статьи — Ivo Balbaert — Rust Essentials
    Поделиться публикацией
    AdBlock похитил этот баннер, но баннеры не зубы — отрастут

    Подробнее
    Реклама
    Комментарии 22
    • +3
      Явно перевод, но нет ссылки на оригинал.
      • +1
        Судя по всему, перевод книги Rust Essentials.
      • +3
        Да еще к тому же такой, который проще читать в оригинале через автопереводчик, чем делать тоже самое здесь, но не видя оригинала. Я не понимаю, в чем прелесть выкладывания минимально обработанных переводов — просто ради того, чтобы потешить ЧСВ «первым нах»?
        • +3
          Согласен. Я было попытался машинально составить список правок, но на первом же абзаце понял, что проще заново перевести.
          • 0
            Укажите хоть часть, буду признателен. Старался не халтурить с переводом.
            • 0
              — большим опенсорс сообществом
              ++ большим опенсорс-сообществом

              — Mozilla начало спонсировать
              ++ Mozilla начала (или начал, если речь о фонде) спонсировать

              — Работа над ним прошла <...>, выпустив первую стабильную версию 1.0.0.
              ++ Работа над ним прошла <...> выпуском первой стабильной версии 1.0.0.

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

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

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

                  Как хотите.
                • +1
                  «памятебезопасным»?? По-моему, вариант в оригинале лучше (хотя, конечно, фраза целиком составлена никудышно). Править так править:
                  «Кроме того, Rust умеет работать с параллельными потоками на многоядерных машинах. Это безопасно для памяти даже без сборки мусора. Пока что на такое не способен ни один другой язык»,
                • +1
                  Выкладывайте на вики или, даже лучше, на сервис коллективных переводов, сообщество поможет.
                  • +1
                    RustDT – это новый и многообещающий Rust IDE, основанный на Ecplise.
                    IDE — это среда, поэтому новая, многообещающая, основанная.
                    C:\Rust\unins001.exe
                    C:\Program Files\Rust 1.0\bin
                    Так где же всё-таки установлен Rust?
                    Rust разрабатывался, чтобы быть таким же портативным, как и C++
                    C++ не портативный, а портируемый.

                    Там и сям лишние запятые.

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

                    Поддерживаю идею про сервис коллективных переводов. Или Github c pull requests.
                    Перевод, близкий к тексту, который не звучит инородно — это тяжёлый труд.
                    • 0
                      Во, тут уже по делу, благодарю) а по поводу разных путей- как в книге было, так оставил, надо заменить, да)
            • +3
              curl -sSL static.rust-lang.org/rustup.sh | sh


              Г. Остер, «Вредные советы для пользователей комьютера».
              • 0
                Хипстерско-докерское вебдванольное. Я всё жду, когда так начнут деплоить самолёты и реакторы.
                • 0
                  Так там целых 1430 строк баш-файла, просто так не поставить c:
                  • 0
                    Ребят, а можно подробнее? Что не так с этим скриптом?
                    • 0
                      Со скриптом, возможно, всё так. Но запуская его подобным образом мы про это никогда не узнаем. И уж тем более не узнаем, если там что-то не так, пока файлы загадочным образом не исчезнут с диска. Самый правильный способ это поставить Rust при помощи пакетного менеджера своего любимого дистрибутива.
                      • +1
                        Прошу прощения за некропост, но даже в 2017 году в репозиториях многих дистрибутивов лежат не самые свежие версии. Да ещё и без Cargo. А в 2015 и вовсе не было.
                • –1
                  Все-таки Java/C# более безопасны, чем Python/Ruby. Статическая типизация многие ошибки позволяет отлавливать во время компиляции.
                  • +1
                    Это позволяет им быть быстрыми, но в тоже время небезопасными, так как в C/C++ разрешены манипуляции с памятью, но отсутствует проверка валидности

                    В стандартах C++11 и C++14 есть умные указатели, так что все нормально.
                    • 0
                      rusti – это простая интерактивная среда программирования (REPL), которая разрабатывается для Rust. Проект впечатляет, поскольку подобные среды используются для динамических языков, но никак не для статических.


                      У Haskell есть интерактивная среда. Он тоже компилируемый.

                      Я только начал изучать Rust, но мне показалось, что у них вообще много общего.

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