на каком движке игра раст
На каком движке игра раст
Thank you in advance.
You’re welcome in advance.
A description of its features, please? I don’t know about it.
EDIT: Strange that Garry didn’t use Source Engine, lol.
Unity is a cross-platform game engine with a built-in IDE developed by Unity Technologies. It is used to develop video games for web plugins, desktop platforms, consoles and mobile devices. It grew from an OS X supported game development tool in 2005 to a multi-platform game engine.
The latest update, Unity 4.3.1, was released December 2013. It currently supports development for iOS, Android, Windows, BlackBerry 10, OS X, Linux, web browsers, Flash, PlayStation 3, Xbox 360, Windows Phone 8, and Wii U. Two versions of the game engine are available for download, Unity and Unity Pro
Not sure if this game uses Unity 4.xx or previous revisions though
Учились у лучших
Сочетание зомби, создания предметов и выживания популярно далеко не первый год. У Rust, «тезки» одной из популярных сетевых карт для Call of Duty: Modern Warfare 2, есть сразу несколько источников вдохновения — помимо очевидной DayZ, это чуть менее явные Minecraft и S.T.A.L.K.E.R. Rust позаимствовала по несколько кусочков у каждой из трех культовых игр.
Из DayZ сюда пришли паранойя, буйные мертвецы и охота на животных, из Minecraft — строительство и создание предметов, необходимых для выживания в глуши, а также возможность отстраивать персональную крепость с колючими заборами. У серии STALKER, в свою очередь, позаимствованы радиация, вечная осень, романтика спальных мешков и встреч у костра. Только водки для постядерного антуража не хватает, но зато здесь можно отведать консервированных бобов, тунца из банки или куриной грудки, которую придется лично добыть с трупа забитой свиньи. Разработчики так нежно любят шутку про то, как в Rust из свинины получается курятина, что даже посвятили ей одну из коллекционных «стимовских» карточек игры.
Без риска умереть от укуса зомби
При всех заимствованиях Rust — самодостаточная игра со своим узнаваемым обликом. Симулятор выживания скрещен с классическим deathmatch. Ареной для драк служит большой остров, созданный разработчиками. Каждый игрок, впервые попавший на новый для себя сервер, начинает голым аборигеном. В руках — только крупный булыжник, которым можно добывать древесину, стуча по деревьям, и другие ценные материалы, дробя камни.
В особой цене здесь металлические детали, из которых собираются самые дорогие предметы: от амбарных замков и железных дверей до винтовки М4. По качеству предметы можно условно разделить на деревянные, каменные и железные. Материалы добываются просто: древесину можно собрать со специальных поленниц или рубя деревья, камни отламываются от больших валунов, а металл придется плавить в печи, расходуя низкокачественное, сваренное на коленке топливо.
 |  |
| ► Взгляд на обманчиво безлюдный ландшафт с холма. и с вершины горы. | |
Унизь ближнего
Основная задача игрока — выжить любой ценой, поддерживая на приемлемом уровне три ключевых параметра: здоровье, сытость и дозу полученной радиации. Здоровье соответствует «живучести» героя и теряется от выстрелов, укусов, ударов и падений даже с небольшой высоты. С сытостью чуть интереснее. Показатель неумолимо падает со временем, но в комфортных условиях (например, у разведенного костра) снижается медленно, а холодной ночью или во время активного бега от врагов — значительно быстрее. В игре встречаются радиационные зоны, в которых опасно задерживаться надолго. От радиации взгляд мутнеет, изображение расплывается на пиксели, а счетчик Гейгера шуршит, указывая на смертельную опасность и рост лучевой дозы в организме.
Но самую большую опасность представляют другие игроки. Эти негодяи обожают издеваться над новичками — просто потому, что способов полно. В Rust можно запереть игрока в его же жилище, заставить его раздеться и бегать голышом, сверкая причинным местом, или же посадить на специальную диету из сырого мяса. Апогей веселья показан в ролике, посвященном созданию братства Penis Brotherhood. И именно это привлекает множество игроков — море возможностей для глумления над остальными и так называемого «грифинга». В этом смысле Rust даст фору и DayZ, и Dota 2, и другим «неприветливым» играм.
 |  |
| ► Стоило подкормить мясом двух этих «бомжей», как они решили отобрать все мои продовольственные запасы! Не стоило помогать злодеям, но понимание этого пришло слишком поздно. | ► В горах легко переломать себе ноги, пытаясь прыгать с кручи на кручу. Но куда опаснее бродить вдоль дороги, где поджидают опытные игроки с пистолетами и дешевыми винтовками рычажного действия. |
На самых популярных серверах играет по 150—170 игроков, и зачастую там творится натуральный беспредел — ни дать ни взять, «смертельный матч» ветеранов с автоматическими дробовиками и MP5 против тех, кто только-только собрал каменный топор и надеялся достроить стены в шалаше. С поведением игроков сложились реальные проблемы, поэтому играть в удовольствие проблематично. Выживать приходится в условиях вечных издевок, насмешек и постоянного риска потерять за секунду все, что копил сутками.
Урок №1: не оставляйте героя без присмотра!
Урок №2: в случае опасности не стойте на месте!
Урок №3: не лезьте туда, откуда не сможете выбраться!
Урок №4: далеко не все сторонятся радиоактивных зон!
Урок №5: если хотите выразить свою позицию, поищите лучше чертеж дробовика.
Урок №6: даже если помочь кому-то выжить, нет гарантий, что он станет с вами дружить.
Выглядит Rust до изумления неказисто, потому что создается на движке Unity и в основном использует стандартные библиотечные модели и текстуры. Но, несмотря на это, Rust для Гарри Ньюмена — золотая жила. Игра пользуется огромным спросом в Steam и в своей нише уступает по популярности только DayZ. Широкие возможности по мастерению всего и вся позволяют создать массу интересных штук: от кирки и отмычки до фонарика, гранат F1 и противорадиационных таблеток. И охотиться за другими обладателями мощной экипировки, нажитой тяжким трудом, — особое удовольствие.
Куча людей посмотрели это видео уже давно, подключайся и смотри первым!
Ранний доступ. Как много самых разных эмоций вызывает это словосочетание. У одних оно ассоциируется с уникальным геймплеем, который невозможно встретить в играх высокого калибра, другие считают данный раздел в Steam воровством и попрошайничеством. Но невозможно отрицать факт – ранний доступ плотно въелся в игровую индустрию и дал многим разработчикам шанс реализовать себя.
Доброго времени суток, в этот час мы рады представить новую рубрику под названием «Как изменялись игры», в пилотом выпуске мы рассмотрим игру Rust.
Находясь уже почти два года на рынке в раннем доступе, игра привлекла к себе огромное число игроков, а если быть точнее, то около 3 миллионов. Вкратце напомню, что за игра перед нами. В Rust необходимо выживать на неблагоприятной территории, вас может погубить огромное число причин, среди них: кровожадные животные, не менее опасные игроки, голод, обморожение и другие.
Наверняка, многие не знают, что было раньше, года полтора назад. За всё время существования на рынке игра один раз кардинально изменилась, пересев на новые «рельсы». Были интегрированы некоторые функции сервиса Steam и ещё очень много разностей было добавлено.
Но давайте не будем торопиться и двинемся на несколько лет назад, в 2013 год.
Примерно в марте появилась система голода и радиации. В июне мы уже можем заметить значительные изменения в интерфейсе, которые остались с нами до «перерождения» игры.
В итоге за тот промежуток времени игра неплохо преобразилась и 11 декабря 2013 года игра вышла в сервисе Steam. В той версии уже присутствовал основной костяк особенностей, которые и остаются с нами и по сей день: строительство домов разных форм и размеров, охота на зверей и людей. К выходу был подготовлен достаточно весёлый трейлер.
Произошло значительное изменение, из игры полностью вырезали зомби, поэтому они сместили акцент с выживания в зомби-апокалипсисе на выживание в суровом, неблагоприятном мире, где тебя окружают волки, медведи и кабаны. Добавили кровать, револьвер, оптимизировали небо, которое любило «отъедать» ваши кадры в секунду.
В это время разработчики начали разрабатывать новую версию Rust на более современной версии Unity (потому что предшественник не мог воплотить многие аспекты в жизнь), создавая заново интерфейс, графику и остальное.
В первую очередь старались улучшить инвентарь и интерфейс, появились более удобные всплывающие окошки при выборе действия, чтобы, например, зажечь костёр. Дальше появилась нормальная модель человека. Вообще изначально вместо людей на сервере «бегали» прямоугольники.
Персонажи научились «спать», добавлена возможность переключится на третье лицо. Игра научилась генерировать карты с различным ландшафтом, естественно на очень примитивном уровне, но со временем получалась менее «картонная», но зато более насыщенная местность.
На самом деле за май было сделано гораздо больше, чем описано выше. Давайте просто вкратце перечислю многие функции, которые добавляли за то время: добавлены и улучшены новые анимации, переделан голосовой чат, появилась смена настроек графики без нужды выхода в главное меню.
В основном, в первую половину месяца работали над новой системой постройки зданий. Было несколько вариантов, как реализовать эту возможность, но остановились на том, что с помощью молотка можно устанавливать разные части строения. До конца доделали интерфейс, который оставался с нами до поры до времени, пытались интегрировать пещеры в мир игры, много графических улучшений, таких как: новая трава, звезды, анимации у волков, улучшенный биом «лес».
Создана очень важная функция, именуемая «метаболизм». Она совмещает в себе разные эффекты, в неё входят: сердцебиение, голод и жажда, кровотечение, запас кислорода и влажность.
Был добавлен лук, факел (странно, что его не было в самом начале), новый «снежный» биом, теперь вещи могут показывать различные показатели защиты от холода, радиации, пуль и подобного.
Улучшены модели персонажей в том плане, что они теперь лучше реагируют на источники освещения, появилось больше различных теней и оттенков. Изменена система глобального освещения мира, так как можно было обнаружить «мерцания» поверхности. К животным был «прикручен» мех, который, кстати, можно очень просто применять и на других моделях, как, например, на этом товарище.
Уже в который раз улучшили систему генерации мира, в этот раз добавили «монументы» – огромные постройки и статуи, которые служат в качестве неких ориентиров.
Но главным изменением стал переход на 5-ую версию Unity. Как объяснили разработчики, это дало значительный прирост эффективности, так как многие ограничения прошлых версий были сняты, да и многие действия были упрощены. Но это событие повлекло проблемы, к примеру, сломался голосовой чат, интерфейс попросту глючил.
Разработчики представили концепт зданий, состоящих не только из одних квадратов. Такие здания выглядят элегантнее, достаточно просто взглянуть на данный макет:
Большая часть времени была посвящена устранению багов и борьбой с Unity 5, так как программа всё ещё находилась в бета-тесте. Но и за это время появились и обдумывались новые интересные вещи. Самое банальное из всего списка – 3 инструмента и копьё. Ещё появился кодовый замок в качестве отдельного предмета, так как многих система с ключами бесила.
Из интересного: появлялись мысли на подобии «А что если мы…». Темой размышлений стала торговля чертежами. Разработчик хотел внедрить такую систему, которая позволяет «зарабатывать» чертежи во время игры (почти как шапки из TF2). А после, если есть нужда, продавать их либо обмениваться с вашими друзьями. Но до реализации (к счастью) руки не дошли.
Темой ноября может полноценно стать «Изменение системы строительства». Появилось много функций, сильно повлиявших на геймплей в целом:
Вернулся Radtown из оригинала. Суть его не изменилась: много лута + радиация. В первых версиях много экспериментировали, как и где должны стоять нужные строения. Ещё появились бочки, которые можно совершенно случайно обнаружить, например, в поле, и в них тоже лежит лут разной степени редкости.
Уже не помню, в который раз это пишу, но снова обновили генерацию местности, теперь появились реки, что дало больше разнообразия. Добавили таблички, на которых можно писать разные фразы. Теперь игроки получают «уникальную» внешность, но, разумеется, не самую разнообразную – есть только 2 формы лица и 2 текстуры кожи. Понятное дело, выбор не велик, но эту проблему достаточно быстро поправили.
Месяц добавления всего и вся. Самые разные вещи были введены: баррикады, гитара, лошадь, новые типы лестниц, ракетница, рисованные иконки для вещей. Теперь на табличках можно рисовать (да здравствуют половые органы и маты!). Сделали целую карту вручную, которая похожа на Legacy-версию. Убрали такую особенность, когда вещи выбрасываются в мешочках, теперь они имеют собственные модельки.
Этот месяц стал одним из самых насыщенных в истории. Добавили 5 экземпляров двуручного оружия, вдобавок ещё арбалет и мины. Ещё вы можете поверх своей одежды надевать подобие бронежилетов, например, из дорожных знаков.
Можно качать нефть с помощью наносной станции, принцип тот же, как и у сборщика руды. Чтобы не ставить очень много маленьких печей, была введена большая печь – переплавляет вещи быстрее, да и слотов стало больше.
Была полностью переработана система чертежей. Дело в том, что раньше нужно было надеяться на свою удачу, вам может выпасть нужный чертёж в первые минуты игры или не выпасть даже через несколько часов. Теперь падают фрагменты чертежей, отличающиеся по степени редкости. Собрав n-ое число, можно получить случайный рецепт.
Для разнообразия Radtown’ов разработали, но пока ещё не добавили, так называемые «подземелья». Первым на очереди стала водоочистная станция, она поделена на несколько уровней и содержит в себе достаточно ценный лут.
Разработчики чутка «сломали» игру одним патчем, поэтому много времени уделили на хотфиксы и оптимизацию игры в целом. Для начинающих игроков был добавлен тайник, который можно «закапывать» от других игроков. Защитники получили себе в арсенал турели – они очень редкие, так как основные ресурсы добываются только с вертолёта.
Привнесли 13 новых табличек и разных баннеров. Ещё ваш персонаж научился метать разные предметы: камни, топоры и подобное.
Пока я ковырялся с видео версией, практически полностью закончился ноябрь, но и его тоже возьмём в расчет.
Появились оконные ставни и металлические амбразуры. Теперь с вертолётов можно снимать М249. Также полностью вырезали нефтедобывающие станции. Причина проста – разработчики ввели их слишком рано.
Примерно такой путь прошел Rust за пару лет существования. От обычной «браузерки» до одной из самых популярных выживалок на рынке. Конечно, здесь расписаны только основные нововведения, в обход технической части.
Но это не главное. Цель новой рубрики – показать, что происходит с игрой в разделе «Ранний доступ». Rust является очень хорошим примером, потому что разницу между версией декабря 2013 года и нынешней видно невооруженным глазом.
Ну, а напоследок, вопросы. Понравилась ли вам эта рубрика, что изменить в ней и какую игру вы хотите увидеть в следующих частях? Ведь было затрачено много человеко-часов, поэтому с достоинством подойдите к оценке.
Разработка игр на Rust. Обзор экосистемы
Здравствуйте! Я занимаюсь разработкой игры на Rust и хочу рассказать об этом.
Моя первая статья будет полезна тем, кто хочет начать делать игру на Rust, но не уверен, какие из пакетов (крейтов) стоит использовать и что вообще происходит в экосистеме Rust для игрового разработчика.
Небольшое отступление — зачем всё это? Есть же готовый X?
Под впечатлением вот этого выступления, я начал писать свой игровой движок на Haskell. Далеко дело не зашло, но я написал рендер моделек, простое освещение, немного сети.
Haskell дал возможность вынести контракты из проверок в рантайме на уровень системы типов. Ну и остальные вещи, о которых рассказывает Кармак — быть уверенным, что функция делает именно то, о чём декларирует в своём типе. Быть чуть ближе к настоящей формальной верификации нашего игрового кода — то есть, в теории, иметь гарантию корректной работы вообще без тестов.
Но, с Haskell было несколько проблем — для вывода 3д в реальном времени он достаточно медлителен. Не было сообщества занимающегося на нём играми. Не хватало нужных для игр библиотек.
С Rust же всё пошло куда веселее.
На мой взгляд, Rust сочетает все свойства, нужные игровым разработчикам, в очень правильном соотношении:
мощная, но при этом простая система типов;
абстракции бесплатны по перфомансу — не надо платить за те абстракции, которые не используешь в явном виде;
И при этом на нём очень просто писать код, язык маленький и простой.
Вернусь к экосистеме:
Работа с окнами:
Glutin — раст-альтернатива GLFW, используется в Servo, активно развивается. Создаёт окна на win/osx/linux/android. На ios еще не работает, кто-то хотел сделать, но с 2015 об этом желающем не слышно.
И есть биндинги к не-растовым библиотекам: glfw-rs rust-sdl2 rust-sfml (сайт). Все три живы и поддерживаются.
Графические API:
Есть возможность использовать напрямую OpenGL/DirectX/Vulkan, к тому же уже созданы растоспецифичные графические библиотеки.
Glium — безопасная обёртка над OpenGL, по факту — в основном над OpenGL 3, хорошо поддерживаются OpenGL
Ржавеем дальше. Как появился Rust и можно ли на нём WEB?
Моя предыдущая статья про rust вызвала положительную реакцию и большое количество обсуждений о том что да как с rust. Мне исключительно приятно видеть что вам понравился этот материал.
В комментариях я встретил много вопросов типа «А можно ли использовать rust для WEB?» Лаконичный ответ таков: «Можно». Можно и brainfuck использовать, если хочется. Нужно ли? Скажем так, brainfuck для WEB использовать категорически не стоит. А вот rust – тут надо понимать что именно делает rust и каковы его цели. Для того чтобы это понять мы должны погрузиться в компилятор и разобраться в устройстве процессоров. Под катом вы найдёте глубокий заныр в историю того как появился rust и поймёте что это такое и когда его нужно использовать а когда можно и на «ноде запилить».
Акт номер 0, Вступление
Ок. Мне довелось обучать программистов вот уже как 10 лет. Я видел разный народ. Кто-то приходил ко мне с вопросами о том, как компилятор оптимизирует код с поддержкой MMX в процессоре, а кто-то спрашивал, можно ли скомпилировать код на Java в С#. Разница между первыми и вторыми – это понимание того как работает процессор.
В этот момент большинство из тех кто учился программировать по ютубу просматривая видео из серии «Как скачать генератор to-do list на node.js, React, brew, JSX, Pug, LESS за 10 секунд» начинают убегать. Не бойтесь. Я попытаюсь всё объяснить по-человечески. Конечно, есть на хабре и те, кто могут открыть бинарный файл в HEX, посмотреть на 7а 45 4с 46 01 01 01 00 и сказать: «Да этож линуксовский бинарник!» Таким не обязательно читать дальше.
Акт номер 1: Процессор
Всё начинается с процессора. Когда вы достаёте себе новый Intel Core i9 из коробки и смотрите на инструкции которые к нему прилагаются, вы найдёте пару страниц описания того как запилить новый камень на маму. Но вот настоящие инструкции к процессору вы в коробке не найдёте.
На сайте Intel вы всегда можете слить свежую копию мануала. Качайте на здоровье, он бесплатный. В нём 50 мегабайт и 5000 страниц. Ого. Ага. Процессор—это достаточно сложное устройство. Это только часть мануалов по процессору. Скачать можно больше.
Хорошо, заставить вас прочитать книгу в 5000 страниц будет не просто. Я буду говорить упрощениями.
Что такое процессор? Это компонент который выполняет арифметические, логические и другие команды ввода-вывода. Процессор это основной компонент в вашем компьютере.
Как заставить процессор выполнить команду? Передать процессору на вход код этой команды и параметры, которые вам нужны.
Процессоры обычно оснащены регистрами. Это определённый набор ячеек памяти который находится очень близко к ядру и позволяет процессору выполнять манипуляции с этими ячейками. Операции могут быть арифметическими и логическими. В процессорах интеловской архитектуры регистры обычно называют буквами по порядку.
Ок, то есть сейчас мы можем записать что-то в AX, прибавить к этому то что в BX, сравнить это с каким-то числом, и если результат сравнения был больше чем это число, перепрыгнуть в другой участок программы. Так раньше писали программы.
В дополнение ко всему этому процессор может запросить данные из оперативной памяти. С точки зрения процессора память очень медленная. Посему можно запросить данные из памяти и поместить их в кеш. (Которого на современных процессорах от 2х до 32х+ мегабайт). Кеш он быстрее оперативной памяти, но всё же медленный.
Хорошо, мы можем получать данные, изменять их и сохранять их в памяти. Если мне надо выполнить одну операцию сложения в каждой ячейке памяти в объёме 1 мегабайт, то есть это я должен выполнить эти команды (1x1024x1024) 1,048,576 раз? Да. Миллион раз. Процессор, работающий на частоте 2 гигагерца выполняет примерно 2,000,000,000 команд в секунду. То бишь, это миллион раз ему можно сделать 2000 раз в секунду. Неплохо.
Но со временем задачи становятся более и более сложными, и процессоры усложняются с этими задачами. Что если мне надо сделать эту операцию миллиард раз в секунду? Например современная игра в разрешении 4к выводит на экран 33,177,600 пикселов. Это надо выводить 60 раз в секунду. 33,177,600×60 = 1,990,656,000. Хаха. Это почти два миллиарда пикселов в секунду. А для того чтобы всё это обработать потребуется чуть больше чем просто прибавлять и отнимать значения из ячеек регистров. (На самом деле с видеоиграми всё становится ещё интереснее, потому что нынче над этой картинкой будет работать не только процессор, но и, понятное дело, видеокарта, которая содержит в себе кучу этих процессоров).
Ладно, вопрос понятен, как сделать так, чтобы процессор выполнял ещё больше инструкций в одну единицу времени? Создатели процессоров начали добавлять различные примочки типа SSE. Это набор инструкций который ускоряет воспроизведение видео. (Вернее ускорял. SEE это древняя технология. Сейчас, в большинстве случаев, видео занимается видеочип. Но SEE остались). Что можно делать с этими инструкциями? Ну, например, можно запихнуть сразу 16 значений в определённые 16 регистров и выполнить одну команду на всех 16ти за один такт. Удобно.
Современные процессоры имеют дополнительные модули для работы с видео, шифрованием, нейронными сетями и так далее. Таких примочек – пруд пруди. Посему и мануал на 5000 страниц.
Ну так вот, мы теперь примерно знаем как можно прочитать значения из памяти, как можно ими манипулировать и как положить всё это обратно. Но мы ничего из этого не можем передать пользователю. Да и получить от пользователя это мы тоже не можем.
На помощь приходят прерывания. Это специальные команды процессора, которые позволяют остановить выполнение программы и заняться чем-нибудь другим. Есть на хабре замечательная статья «О работе ПК на примере Windows 10 и клавиатуры». Эта статья в мельчайших деталях рассказывает о том, как сигнал от клавиатуры попадает в память где до него может добраться процессор. По такому же методу процессор может записать данные в видеопамять, и видеоадаптер нарисует эти данные на экране.
Всё просто, чики-пуки, правильно? Ага. Мы только что видели опкоды команд для одного кристалла Intel. А есть ещё, например, процессоры компании AMD. У них основной набор команд практически такой-же как у Intel, но вот примочки у них были свои. А есть ещё и другие процессоры, в которых набор комманд полностью отличается от того, что мы видели в Intel. Пример тому – мобильные процессоры. У них и архитектура другая.
То есть, если ты хочешь писать программу на опкодах, то тебе её придётся писать для каждого процессора, на котором эта программа будет запускаться. Что, удобно? Не очень. Да, это достаточно ресурсоёмко. Сидеть и запоминать эти опкоды и пихать их в процессор? Неужели кто-нибудь может запомнить всё это? (Я могу поспорить, что определённый процент хабравчан тут усмехнётся и начнёт вспоминать эти опкоды).
Акт номер 2: Ассемблер
Ладно, не боись. Всё это решили за тебя ещё в древности. Уже в 60х годах знали, как с этим разобраться. Для начала, почему бы не заменить численные опкоды чем-то более человекочитаемым? Например, использовать mov вместо 0x06. Так появился первый ассемблер. Программа на ассемблере выглядит вот так:
Ещё одна полезная фича компилятора это оптимизация вашего кода под определённый процессор. Например, если компилятор собирает программу под Intel, то он может автоматически заменить более простые и медленные конструкции, которые ты использовал в своей программе, более сложными командами под процессор Intel или AMD или что ты там используешь.
Основной плюс такого подхода заключался в том, что одна и та же программа написанная на ассемблере могла быть собрана для разных процессоров. То есть тебе не надо было всё переписывать заново. Победа!
Но как бы не был хорош такой подход, писать на ассемблере всё ещё занудно. Посему древние решили всё это упростить и улучшить и начали заниматься разработкой языков программирования. Один особо примечательный язык, который начал свою жизнь в 60х до сих пор живёт и процветает и по сей день это С.
Акт номер 3: Сиииии и Сипипииии
Чем же С был так хорош? Ну, давайте заменим определённые последовательности ассемблеровского кода более удобочитаемыми командами. Например, если мы хотим сравнить два числа и выполнить разный код по результатам этого сравнения, то мы можем заменить это
Ваш код становится намного более удобочитаемым. Плюс мы все знаем, что считывать данные с клавиатуры и писать данные на экран это то, что практически всякая программа будет делать по умолчанию. Посему мы можем написать стандартную библиотеку команд, которые будут доступны каждому, кто пишет на С.
После всего этого мы передаём нашу текстовую программу компилятору, который собирает эту программу в объектный файл. Этот объектный файл передаётся linker (линкеру), который прикручивает ваш код куда надо.
Так, стоп, а это откуда здесь взялось? Куда чего надо прикручивать? Так, ты в своём коде использовал printf? Да, использовал. Код printf это часть стандартного набора команд. Этот код – функция, которая была скомпилирована в отдельный объектный файл. Когда ты эту функцию вызываешь надо чтобы твой программный код заставил процессор прервать выполение твоей программы, выяснить, где в памяти находится printf, выставить регистр исполняемой команды процессора в определённое значение и вызвать нужное прерывание, чтобы процессор бросил твою команду и ринулся выполнять printf. После выполнения процессор должен вернуться к твоей программе. Опять прыгание по памяти и всё такое.
Писать всё это руками было бы очень муторно, но линкер решает эти проблемы. Он собирает все объектные файлы (куски исполняемой программы) в один большой исполняемый бинарник. Выясняет все имена функций и проставляет все адреса в памяти как надо. Тобишь всё складывается воедино линкером и он выдаёт тебе в руки один исполняемый файл. Ты его клик-клик и программа запускается!
Чем же так хорош С? Тем что он был достаточно прост, стандартен и позволял быстро писать программы не заморачиваясь тем, как работает ваш процессор. Компиляторов (обычно под этим понимается компилятор+линкер) для С было написано столько, что ныне их уже не счесть. С всегда был стандартным языком. В нём точно говорится, что если в программе написано if то в итоге код должен делать такое-то ветвление. (А если в программе написано봎볈볬, то твой код должен выпускать демонов из ноздрей.) Посему, если вы написали программу для своего любимого, на тот момент компьютера PDP-11, то её можно было бы скомпилировать и на нынешнем Intel Core i11.
Ух ты! Вот тут у нас и появляется концепт программы, которая пишется не для определённого процессора, и даже не для определённой операционной системы. Такую программу можно запустить на всём что под руку попадётся, главное чтобы у вас в руках был компилятор.
И компиляторы были и есть. Их в С более 50ти популярных. Просто утопия. Типа того. На самом деле, не всё ТАК уж прям утопично. Код, написанный для 32х битных систем может скомпилироваться, а может и не скомипилироваться на 64х битных системах. А вот код который дёргает 64х битные функции точно рухнет на 32х битных системах. Это ещё что. Windows, unix и MacOS имеют разные подсистемы управления памятью. Что-то может заработать на маке и выдать замечательное приветствие на винде:
Ну, эти проблемы в С решили. У нас есть система под названием makefile. Это программный комплекс который управляет процессом компиляции. Когда файлов у вас в проекте сотни и последовательность компилирования может меняться, когда надо сделать так чтобы система собиралась по-разному на Windows и Unix или проверяла, если сборка делается на 64х разрядном компьютере, вы пишите makefile.
Всё это становится очень утомительным. В добавок ко всему, С хорош в написании функций, но вот мы-то работаем с объектами. Посему пришлось писать улучшенную версию С, которая называется С++. Плюсы позволили создавать тръу ООП программы с классами, бллк-джеком и куртизанками. (Уж простите меня на ужасное утрирование. Разница между С и С++ достойна не то что отдельной статьи, можно будет и книгу написать. Но статья-то про rust, так что мы будем опускать детали.)
Акт номер 4: Ява и дотнет
Акт номер 5: Яваскрипт
Но тут можно пойти ещё дальше. Зачем компилировать код вообще? Почему бы просто не выполнять инструкции одна за другой? Так и сделали. Так появился javascript.
Код не компилировался вообще. Каждая строка программы последовательно читалась одна за другой и выполнялась как есть. Всё это было вообще шикарно. Никакой мороки с компиляторами, процессорами и оптимизацией. Код просто выполняется.
Но, со временем, мы начали понимать, что javascript должен не только выполняться, но выполняться быстро. Посему программу, которая запускает ваш скрипт начали пилить. Всё это началось с войны браузеров в далёких 2000х. Тогда самым-самым браузером был Internet Explorer 6. Он победил всех. На сцену вышли Mozilla и Google. Началась война. Все боролись за скорость работы сайтов. Javascript начал компилироваться для ускорения производительности. Появились движки для javascript. V8, движок из Google Chrome, в итоге победил всех и вся. Осталось дождаться, когда Firefox переключится на него и вторую войну браузеров можно считать закрытой.
После этого какой-то умелец взял V8 и запилил на нём Node.js. Зачем запускать javascript в браузере? Можно и без браузера. Научился писать на скриптах – пиши на них и серверную часть.
В итоге у нас появилась новая платформа. Вам, как разработчику, вообще чихать на процессор, который установлен на клиенте. Вам чихать на размер экрана и операционную систему. У вас есть доступ к странице, на которой всё это запускается и всё! Победа. Один код запускается на абсолютно разных машинах с максимальной скоростью.
Конечно, компьютеры становятся мощнее и мощнее с каждым годом, и если в 1990х мы могли рассчитывать только на 8,000,000 операций в секунду, то в 2010 мы уже говорили о 3,000,000,000 в секунду. А сейчас мы хоть и опустились до 2,000,000,000, но зато у нас у всех под капотом по 8-16 ядер, которые выполняют эти операции одновременно, да ещё и видеоадаптер, который дополняет всю эту армию вычислительных машин. Так что, по большому счёту нам на скорость начхать. Какая разница если мы получим данные и покажем их на экране за 25 миллисекунд или за 250 миллисекунд? Пользователь всё равно не заметит разницы.
Так и есть. Только это в ваших бизнес-приложениях он не заметит разницы. А вот если вы пишете игру, то разница между 25-ю и 250-ю миллисекундами очень даже заметна. Просто жесть как. Посему приходится выбирать.
Акт номер 0x00000000: Память
Хорошо, мы видели историю того, как изменялся подход к написанию программ и почему он изменялся. Единственный момент, на который мы не смотрели – это память. Этот момент является очень важным.
В древности ваша программа (в большинстве случаев) запускалась на процессоре как полновластный владелец всей системы. Вы могли обратиться к любому участку памяти, писать и читать из этого участка памяти и делать что вздумается. Этот подход был прост и ужасен. Вы могли в любой момент изменить память, которой пользовалась другая программа на компьютере. Решили сохранить в памяти огромную картинку с разрешением 320х240? Упс! Неправильно прописанный указатель переписывает содержание функций операционной системы, и вместо красивого изображения вы получаете полное зависание системы (если повезёт, если не повезёт, можно заодно и диск отформатировать).
Вирусы в те стародавние времена писались только так. Почему бы не перехватить функцию в DOS, которая пишет данные на диск? Да проще простого! Перехватывай. Диски стирались, криптовались и чего только не делались. Делов-то.
Со временем разработчики процессоров начали бороться с этим кошмаром путём усложнения модели работы с памятью. С 1985х в процессоры начали встраивать новый «защищённый режим» работы с памятью. Вместо того чтобы позволять каждой программе работать с памятью напрямую, программе предоставлялся интерфейс, для того чтобы запросить виртуальную память и работать с этой памятью. Память была виртуальной, потому что эта память не гарантировала выдачу вам блоков RAM с шестой по девятый. Вы просили систему дать вам полкило памяти, вы её получали. Когда ваша программа писала в эти полкило памяти, операционная система уже разбиралась что с этой памятью делать. В какой конкретно чип в RAM эти ваши данные положить. А если вы этими данными не пользовались, то система могла их и сбросить в Swap.
Самое главное, ваша программа получала свой виртуальный адрес, а система гарантировала, что никакая другая программа в этот кусок памяти писать не будет. В том числе система гарантировала, что другие программы в вашу память писать не будут. Всё работало просто замечательно:
Вся эта беготня с памятью создала необходимость управления этой памятью. Ваша программа на C должна получить память, обращаясь к операционной системе. Система вам эту память выдаст. А может и не выдать. Результат зависит, но скорее всего, будет такой вот:
После того как вы эту память получили вам нужно её «инициализировать», то бишь записать туда начальные значения переменных, которые вам нужны. Иначе вы могли получить кусок памяти, в которой валялся какой-то мусор.
Оффтоп: У Буратино было пять яблок. Он съел два. Сколько яблок осталось у Буратино? Думаете три? Фиг вам. 32764! Память кто будет инициализировать при работе с переменными?
А теперь самое прикольное – каждый раз, когда вы попросили у системы память, эта память будет оставаться вашей, пока не будет сделано одно из двух: либо вы эту память отдадите системе обратно, либо вы завершите программу, и тогда вся ваша память освободится.
Что же, это просто, так ведь? Если попросили полкило памяти, то и отдайте полкило памяти. Делов-то. А что если вы попросили полкило памяти и отдаёте её обратно кусками по 10 килобайт? И вот, 2 куска в самом конце не отдали (забыли, поставили неправильный знак сравнения в цикле и последние два куска остались за вами). А потом вы попросили ещё полкило, то есть теперь ваша программа занимает 520 килобайт. И опять отдаёте её кусками и 2 куска не отдали? Теперь у нас 40 лишних килобайт. Результат:
Такая штука называется утечкой памяти. И, в результате, вы сидите в 4 утра с красными глазами перед отладчиком и орёте благим матом «Ну где эта с_ка течёт?»
А ещё есть один прекрасный трюк, как насчёт того, чтобы попросить память у системы, а потом удалить указатель на эту память? В таком случае вы эту память и вернуть обратно не сможете. Результат?
А ещё можно обратиться к памяти по адресу 0x00000000 (нулевой адрес). Результат?
Короче вы поняли. Работа с памятью требует тщательного планирования и правильного управления. Любой программист на С и С++ обязательно проверит каждую функцию запроса памяти и убедится в том, что ничего нигде не течёт. Чем сложнее становится проект, тем сложнее эту память проверять. Появляются другие инструменты проверки. Например, знакомая каждому хабровчанину PVS-Studio. Статический анализатор, который может половить баги памяти в вашей программе.
Программист, помни, работа с памятью – это очень тяжёлая ответственность. Ладно. Это всё решили в Яве и Дотнете.
Акт номер 0xFFFFFFFF: Meet Garbage Collector
Автоматический сборщик мусора! Зачем вообще программисту выделать память? Почему бы просто не сделать так – когда он создаёт переменную, пусть платформа сама возьмёт память с полочки. А когда переменная больше не нужна (программист выкинул все указатели на эту переменную) то отдельная программа которая запускается параллельно с вашей программой, называемая сборщик мусора, возьмёт и сотрёт эти данные из памяти.
Всё просто прекрасно и хорошо. Но… Проблема в том, что сборщик мусора не всегда так уж и хорош и может создать ситуации, когда мусора становится слишком много. Когда ваше бизнес-приложение заточено на показ трёх значений курсов валют на экране, то сборщик мусора работает просто прекрасно. А вот если вы пытаетесь сделать ленту из видео файлов с «бесконечным скроллом» то сборщик мусора может запросить 8 гиг памяти у системы и конкретно всё затормозить.
Идея сборки мусора перекочевала в javascript. В общем-то, это не очень плохая идея. Она просто накладная. У вас запускается не только ваша программа, но и программа, которая следит чтобы ваша программа нормально работала.
Акт номер 6: LLVM
Ладно, наступили двухтысячные. Ява с Дотнетом борются за лидерство. Яваскрипт завоёвывает серверную часть. А вот Си с плюсами начинает трясти. Проблема заключалась в том, что количество компиляторов перевалило за исчислимые пределы и теперь считается иррациональными числами. На сцене существуют тяжеловесы – Microsoft C++ Compiler и GNU C. Не то, чтобы эти компиляторы «воевали» друг с другом, войны между ними быть не может, ибо они рассчитанны для абсолютно разных систем.
И тут на сцену выходит Apple, которая пытается сделать «всё для себя». Проблема вот в чём, самый популярный компилятор C для Unix-систем это gcc. Apple приходится использовать этот компилятор в своих продуктах, но лицензия GNU, которая идёт в добавку с этим компилятором накладывает жёсткие ограничения на политику яблоководов о том, чтобы сделать всё проприетарным. (Ежели вы берёте открытое программное обеспечение под лицензией GNU и дорабатываете его, вы обязаны оставить исходный код открытым.)
И тут внезапно в 2003 году выскочка из университета Иллинойса показывает миру свою лабораторную работу под названием LLVM. Это название ничего не значит. Просто название. Что это за зверь такой?
Это новая система компиляции. LLVM предоставляет доступ к очень низкоуровневому языку программирования который позволяет писать что-то типа ассемблера, только опять же, отрешенного от реального процессора. Этот код компилируется для конкретной платформы. На выходе мы получаем настоящий, чистокровный бинарник для конкретной системы без всяких фреймворков и тому подобных вещей.
Вместе со всем этим выходит clang. Это компилятор для Си-образных языков, который собирает Си и С++ в LLVM код. То есть ваши программы на C можно запросто пропустить через этот компилятор. А на выходе у вас есть поддержка Windows, Linux, MacOS для кучи процессоров: х86, х86-64, PowerPC, ARM, AArch64 и тд. И самое главное – Apache 2.0 лицензия, в которой выпускать модифицированный код необязательно. То есть, Apple смогла взять этот LLVM и сделать его проприетарно-закрытым! Из инструментов разработки Apple пропадает GNU компилятор и его заменяет LLVM компилятор, который отлично компилируется в байткод для LLVM, который в своё время отлично собирается под Apple.
Благодаря такому вниманию гиганта, проект получает поддержку и начинает развивать обороты. Хочешь написать свой язык? Пожалуйста! Пиши язык, который генерирует байт-код для LLVM, а мы его скомпилируем. Тебе не надо писать компилятор. Он уже есть. Просто пиши язык.
Акт номер 7: И где же rust?
И тут появляется rust. LLVM был просто средой компиляции. Работа с памятью как была проблемой программиста, так ею и осталась. Но ребята из Mozilla решили попробовать что-то новое. В 2010 они написали новый язык программирования, который использовал LLVM как компилятор.
Язык был си-образным и очень низкоуровневым. В нём не было примочек в виде сборщика мусора или фреймворка на 200+ мегабайт.
Но в язык была зашита принципиально новая система работы с памятью. Вместо того чтобы плодить БСОДы направо и налево, вам был дан borrow-checker. (Проверяльщик заимствования? Я не знаю, как правильно это перевести. Я его так и буду называть borrow-checker). Вшитый прямо в компилятор. Подход заключается в следующем: вы пишите код как будто у вас есть сборщик мусора. Вы просто объявляете строку и память для неё появляется автоматически. А после того как вы эту переменную используете, память освобождается сама по себе.
Но это всё не происходит потому что у вас есть сборщик мусора. Компилятор сидит и запихивает куда нужно команды, которые запрашивают память у системы и освобождают эту память. Это не создаёт проблем с производительностью, ибо сходный код на С был бы так же быстр. Вам всё так же пришлось бы запрашивать память и освобождать её. Разница в том что вам не надо постоянно смотреть на БСОДы и Appcrash repots. Компилятор даст вам знать, что вот тут, в строке номер 10 у вас есть потенциальная ошибка памяти. Так что сидите и правьте.
Следующая важная фича rust называется zero-cost abstractions. Это подход к разработке языка. Если вы даёте пользователю какую-то специальную функцию, то это функция не должна ничего стоить.
Когда вы создаёте новый поток в rust, то он не будет «тяжелее» fork(). Может быть в вашем коде вы увидите следующее:
Выглядит это всё круто, но под капотом этого странного способа создавать замыкания в rust (||) вы найдёте fork(). Rust сам по себе не будет писать менеджер потоков за вас. Посему, писать всё придётся самому. Если тебе нужен менеджер соединений с базой данных, пожалуйста, вот тебе чистый лист, пиши. (Либо ищи и качай его с crates.io)
Что мы получили в итоге? Rust это язык, который является относительно быстрым и не нуждается в гигантском фреймворке, который надо таскать с собой на конечную систему пользователя. Он позволяет вам предотвратить ошибки управления памятью в процессе написания программы. Вариантов словить утечку намного меньше. Всё прекрасно, так?
Да. Всё прекрасно. Но rust это не простой язык для изучения. Вам надо очень хорошо разбираться в архитектуре компьютеров и понимать как на самом деле работает память. Вам надо хорошо знать системное программирование и иметь хорошее представление о том как работает heap и stack в операционной системе. Rust не прощает ошибок. Но, в отличие от C и C++, rust не прощает ошибок с памятью на этапе компиляции.
Итог: Rust это хороший язык в сообществе Cи-образных языков, который позволяет писать удивительно быстрый код и предотвращает большое количество ошибок работы с памятью.
Акт номер 0xFE: Заключение
Как мне выбрать язык для своего проекта? Вы должны знать свой проект. Какова нагрузка на ваш проект? Сколько он проживёт? Сколько ему надо жить? Как долго и кто его будет поддерживать?
На самом деле – это те вопросы, на которые вам надо ответить. Если вы пишете скрипт, который вы выкинете через 2 дня, пишите его на чём попало. Главное, чтобы не в продакшин.
Если вы пишете драйвер для нового устройства, то можно попробовать rust. Если вы действительно пишите драйвер, то вы уж точно знаете как правильно работать с памятью и весь этот трёп про ассемблер выше по тексту для вас будет детским лепетом.
Играетесь с новым адуриноподобным устройством на ARM? Попробуйте rust! Будет весело.
Если у вас есть WEB приложение, которое должно работать на одном сервере и обслуживать 200 человек в вашей организации, то вам будет достаточно node.js. На нём писать проще. Когда компания вырастает до 2000 человек, то надо уже серьёзно подумывать про переход на шарпы или яву. Но когда аудитория сайта переваливает за 200000 человек, то мы можем говорить о переходе на rust.
Или вот, например, у вас есть docker контейнер, в котором у вас вертится микросервис написанный на Java. Этот «микросервис» занимает 200+ мегабайт места на жёстком диске. С использованием C или Rust вы могли бы это сократить до 20 мегабайт. Обновление и запихивание всего этого дела на серверы может прилично сократить трафик.
На rust написаны куски кода для Discord, Microsoft Azure IoT Engine, Open DNS, Firefox, Linux Kernel, и тд.
Для кого rust? Для суровых бородатых системных программистов, которые хотят скорости и готовы часами проектировать своё программное обеспечение с учётом потребления памяти и производительности. Написание игр или компонентов рендеринга, драйверов устройств и так далее – это удел rust.
Следует оговориться, что если вы будете работать с WebAssembly (wasm), то вам точно нужно попробовать rust. Так как код, генерируемый rust использует LLVM, а LLVM может компилировать в wasm, использовать rust для этих целей будет просто удовольствием.
Написание WEB приложения на rust это не обязательно полезная деятельность. Если вы действительно хорошо разбираетесь в системном программировании, и можете писать на С++ с закрытыми глазами, то вам стоит писать WEB на rust. Иначе, вы будете часами сидеть перед функцией, которая принимает параметры возвращаемые из формы, и горько плакать, потому что перед вами будет стоять непосильная задача распарсить эти параметры в JSON.
Акт номер 0xFF: Учимся
Если вы решили учить rust для WEB программирования, но ещё никогда им не пользовались, то для начала я рекомендую выучить rust, читая официальное руководство. Я очень сильно не советую пытаться начать пилить серверную часть на rust если вы никогда ничего на этом языке не писали.
Для начала, напишите хотя-бы парсер текста. Простой grep, например. Потом разберитесь, как эту программу распарралелить. Когда вы научитесь пользоваться областями видимости и без проблем будете создавать замыкания и новые потоки, можно будет переключаться именно на WEB программирование на rust.
После того как язык перестанет быть для вас полной кашей, можете обратиться к “Fullstack Rust” by Andrew Weiss. Я никакого отношения к этой книге не имею, за исключением того, что я её прочитал, и она в деталях объясняет, как правильно писать WEB сервер на rust, как пользоваться wasm и так далее. Не пытайтесь читать эту книгу, если вы ничего про rust не знаете.
А если не хотите обзаводиться этой книгой, что же, не проблема! Мы лёгких путей не ищем!
После этого идём в http://actix.rs и учим его. Это один из самых передовых WEB фреймворков для rust.
Можно выучить rocket – это самый новый WEB фреймворк для rust. Здесь синтаксис проще и работа быстрее. Единственное что мне в rocket не понравилось – это то что он не компилируется на стандартном компиляторе rust и заставляет вас установить nightly билд. Это не очень хорошо для продакшена.
После актикса можно учить http://diesel.rs. Это фреймворк для работы с базами данных.
Попутно выучите serde. Систему сериализации и десереализации данных в rust.
С подобным багажом знаний уже можно написать приличный WEB сервер с базой данных и блек-джеком.
Ну а если вы хотите окунуться в новый мир невероятного wasm то начать надо будет с: https://github.com/rustwasm/wasm-bindgen
В попытках выучить всё это вы наткнётесь на кучу различных пакетов, про которые стоит знать. Натыкайтесь. Будет весело.
Читать дофига, учиться и того больше. Ставим компилятор rust и начинаем эксперименты.