Перспективные токены на начало 2022 года. 5 монет от аналитика
Мнения экспертов могут не совпадать с позицией редакции. «РБК-Крипто» не дает инвестиционных советов, материал опубликован исключительно в ознакомительных целях. Криптовалюта — это волатильный актив, который может привести к финансовым убыткам.
Трейдер Джейсон Пиццино назвал пять альткоинов, которые, по его мнению, способны показать стремительный рост в первом квартале следующего года. Аналитик посоветовал обратить внимание на токены Curve Dao Token (CRV), Polygon (MATIC), Terra (LUNA), Stacks (STX) и THORChain (RUNE).
Curve Dao Token
По словам Пиццино, ситуация на графике CRV в паре с биткоином указывает на то, что токен готов в ближайшие несколько месяцев выйти из зоны накопления и начать активно расти. Трейдер не исключил, что к подорожанию альткоин подтолкнет тренд на метавселенные.
Curve Finance — это децентрализованная торговая платформа для обмена криптовалютами и стейблкоинами. Биржа выпустила собственные токены управления CRV, которые позволяют держателям участвовать в развитии проекта.
Polygon
Токен Polygon выглядит перспективно, считает Пиццино. По его мнению, альткоин может показать хорошую доходность в ближайшие месяцы, если для этого сложится благоприятный фон на рынке альткоинов.
Polygon — это Ethereum-совместимый сайдчейн второго уровня, работающий по алгоритму PoS (Proof-of-Stake). Эта сеть работает быстрее и с меньшими комиссиями, чем основная сеть Ethereum.
Terra
Ситуация с токеном Terra аналогична перспективам Polygon, считает аналитик. Он пояснил, что токен Terra имеет большой потенциал, однако он может быть реализован только в том случае, если рынок альткоинов начнет активно расти. Основным драйвером, который может подтолкнуть альтернативные монеты к росту, Пиццино назвал обновление исторического максимума Ethereum.
Terra — это блокчейн-протокол, с помощью которого создаются привязанные к фиатным валютам стейблкоины. Владельцы токена LUNA могут предлагать предложения по улучшению блокчейна и голосовать за них.
Stacks
Токен Stacks в данный момент показывает хорошую динамику, уверен аналитик. Он напомнил о том, что альткоин за неделю подорожал более чем на треть. По прогнозу Пиццино, Stacks в ближайшие месяцы сохранит динамику роста и продолжит увеличивать капитализацию.
Stacks — это блокчейн-решение для реализации смарт-контрактов на базе биткоина. Приложения, построенные в экосистеме Stacks, наследуют все возможности первой криптовалюты.
THORChain
Токен THORChain уже перешел к росту в паре с биткоином после длительной фазы накопления, утверждает Пиццино. По его словам, в ближайшие месяцы альткоин способен обогнать по доходности Ethereum.
THORChain — это протокол, который создает мост между блокчейнами для быстрого и эффективного обмена активами.
Больше новостей о криптовалютах вы найдете в нашем телеграм-канале РБК-Крипто.
Интересный мод который позволит создать огромный и необычный мир из множества разных измерений, с данным модом вы сможете попадать из одного изменения в другое просто прокопав в него дыру, вас все равно будет телепортировать, но игровой процесс будет заключаться в постройке глубокой ямы или очень высокого столба.
На момент публикации мод не добавляет собственных измерений, он меняет обычный майнкрафт так, что теперь в самом низу мира вас будет ждать портал в ад, который так же изменится став более реалистичным. В обычном мире более не будет алмазов, все алмазы будут находиться в области между адом и обычным миром.
Изюминкой данного мода является то, что вы сами сможете настроить лестницу измерений используя сторонние моды, т.е после установки сторонних модов вы сможете разместить их измерения в определенной последовательности, что очень забавно, можно создать несколько уровней ада, поместить измерение пещер между адом и обычным миром, над обычным миром можно разместить измерение летающих островов, а над ним рай, чуть ниже я покажу как настраивается мод и как добавлять туда измерения.
Стандартная настройка мода:
Если продолжить копать вниз, вы встретите не ад, а некое переходное место, оно состоит из камня, в нем есть пещеры, но в нем есть и монстры из ада.
Вот так схематично выглядит переход:
Добавление других измерений в мод:
Я разобрался как работает мод и смог добавить под ад еще одно измерение, это не сложно и прочие измерения добавляются аналогичным образом.
Открываем файл \.minecraft\config\cd4017be\verticalDimensionStack.rcp при помощи Notepad++
Находим вот такие строчки:
Сюда, нам необходимо добавлять ID измерений в общем порядке измерений (какое измерение над каким).
Теперь измерение с ID 10 будет ПОД измерением ада, т.е если сломать бедрок в аду, то под ним будут блоки создающие портал в измерение с ID 10.
Как убрать бедрок:
Ищем такие строчки:
Итак, что бы заменить бедрок в аду, а так же заменить бедрок в верху измерения The Beneath я добавил следующие строчки:
Все точно так же, первая заменяет бедрок на золотые блоки, вторая заменяет бедрок на алмазные блоки.
После этих строчек идет настройка генерации мира над адом (стандартное измерение майнкрафт от 0 до 250 блоков, а ад от 0 до 128, потому автор создает дополнительную генерацию создавая переходный мир.) Здесь мы сможем настроить генерацию руд, более нам ничего не интересно и более сложно.
Сборка — Новое Поколение Майнкрафт от Лололошки
Опубликовано 19.07.2021 · Обновлено 19.07.2021
Описание
Новое Поколение — это новая, масштабная сборка известного и популярного ютубера Лололошки. На момент написания статьи по данной сборке «Lp. НовоеПоколение» выпущено уже 66 серий на ютуб канале «MrLololoshka (Роман Фильченков)».
Тут собрано огромное количество модов (а именно 135 модов и библиотек) на версию 1.15.2. Можете поиграть и самостоятельно насладиться этой крутой сборкой.
Скриншоты
Список модов
Всего в составе сборки 135 модов и библиотек:
Abnormals Core
Absent by design
Additional Enchanted Miner
AI Improvements
AmbientSounds
Advent of Ascension
Apotheosis
Ars Nouveau
Artifacts
AutoRegLib
Better Advancements
Better Burning
Better Caves
Better Mineshafts
Bookshelf
Bountiful
Byg
Camera
Chickensshed
Citadel
Client Tweaks
Clumps
Cofh Core
Comforts
Config
Controlling
Cooking For Blockheads
Cosmetic Armor Reworked
Crafting Tweaks
Craft Tweaker
ConnectedTextures
Cucumber
Curios API
Dimdungeons
Ding
Dungeons-plus
Enchanted book redesign
Enchantment Descriptions
Enchant with mob
Ensorcellation
Entangled
Evolved_RPG
Fancy menu
Farlanders
Farming For Blockheads
Fast Furnace
Fast Leaf Decay
Fast Workbench
Fishing real
Geckolib
FTB-backups
Glassential
Goblin traders
Gravestone
Health Overlay
Ice And Fire
Illagers plus
Immersive portals
Improved Backpacks
InventoryHud
invtweaks
Iron Jetpacks
JEI
JEI integration
Journeymap
Just Enough Resources
Klee Slabs
Konkrete
Kotlin for forge
Kottle
Light overlay
Locate biome
Lollipop
MCjtylib
MCW doors
MCW roofs
MCWS win
Mining helmet
MixinBootstrap
Modname tooltip
More dragon eggs
MouseTweaks
NewGenTweaks
Nomowanderer
Occultism
Omgourd
OpenLoader
OptiFine
Pamhc2 crops
Pamhc2 food core
Pamhc2 food extended
Pamhc2 trees
Patchouli
Placebo
Platter
Polymorph
Powah
Project MMO
Quark
RAD
Random patches
Repurposed structures
Resource fulbees
Restrictions
Rsgauges
Savage and Ravage
Save Your Pets
Scalable Cats Force
Scaling Health
Scuba gear
Serene Seasons
SilentGear
SilentLib
Skizzik
Solcarrot
Step
Storage Drawers
Structure gel API
Supermartijn642 configlib
Supplementaries
Survive
The Abyss 2
The Conjurer
The Endergetic Expansion
The one probe
Thermal innovation
Thermal
Toast Control
ToolBelt
Towers of the wild
UnionLib
Valhelsia Structures
Whisper woods
Woot
World Edit
Как установить сборку Лололошки
Видео — Как установить сборку Новое Поколение от Лололошки
О стеке простыми словами — для студентов и просто начинающих
Привет, я студент второго курса технического университета. После пропуска нескольких пар программирования по состоянию здоровья, я столкнулся с непониманием таких тем, как «Стек» и «Очередь». Путем проб и ошибок, спустя несколько дней, до меня наконец дошло, что это такое и с чем это едят. Чтобы у вас понимание не заняло столько времени, в данной статье я расскажу о том что такое «Стек», каким образом и на каких примерах я понял что это такое. Если вам понравится, я напишу вторую часть, которая будет затрагивать уже такое понятие, как «Очередь»
Теория
На Википедии определение стека звучит так:
Стек (англ. stack — стопка; читается стэк) — абстрактный тип данных, представляющий собой список элементов, организованных по принципу LIFO (англ. last in — first out, «последним пришёл — первым вышел»).
Поэтому первое, на чем бы я хотел заострить внимание, это представление стека в виде вещей из жизни. Первой на ум мне пришла интерпретация в виде стопки книг, где верхняя книга — это вершина.
На самом деле стек можно представить в виде стопки любых предметов будь то стопка листов, тетрадей, рубашек и тому подобное, но пример с книгами я думаю будет самым оптимальным.
Итак, из чего же состоит стек.
Стек состоит из ячеек(в примере — это книги), которые представлены в виде структуры, содержащей какие-либо данные и указатель типа данной структуры на следующий элемент.
Сложно? Не беда, давайте разбираться.
На данной картинке схематично изображен стек. Блок вида «Данные/*next» и есть наша ячейка. *next, как мы видим, указывает на следующий элемент, другими словами указатель *next хранит адрес следующей ячейки. Указатель *TOP указывает на вершину стек, то есть хранит её адрес.
С теорией закончили, перейдем к практике.
Практика
Для начала нам нужно создать структуру, которая будет являться нашей «ячейкой»
Новичкам возможно будет не понятно, зачем наш указатель — типа comp, точнее сказать указатель типа структуры comp. Объясню, для того чтобы указатель *next мог хранить структуру comp, ей нужно обозначить тип этой структуры. Другими словами указать, что будет хранить указатель.
После того как у нас задана «Ячейка», перейдем к созданию функций.
Функции
Функция создания «Стека»/добавления элемента в «Стек»
При добавлении элемента у нас возникнет две ситуации:
Разберем чуть чуть по-подробнее.
Во-первых, почему функция принимает **top, то есть указатель на указатель, для того чтобы вам было наиболее понятно, я оставлю рассмотрение этого вопроса на потом. Во-вторых, по-подробнее поговорим о q->next = *top и о том, что же означает ->.
-> означает то, что грубо говоря, мы заходим в нашу структуру и достаем оттуда элемент этой структуры. В строчке q->next = *top мы из нашей ячейки достаем указатель на следующий элемент *next и заменяем его на указатель, который указывает на вершину стека *top. Другими словами мы проводим связь, от нового элемента к вершине стека. Тут ничего сложного, все как с книгами. Новую книгу мы кладем ровно на вершину стопки, то есть проводим связь от новой книги к вершине стопки книг. После этого новая книга автоматически становится вершиной, так как стек не стопка книг, нам нужно указать, что новый элемент — вершина, для этого пишется: *top = q;.
Функция удаления элемента из «Стека» по данным
Данная функция будет удалять элемент из стека, если число Data ячейки(q->Data) будет равна числу, которое мы сами обозначим.
Здесь могут быть такие варианты:
Для лучшего понимания удаления элемента проведем аналогии с уже привычной стопкой книг. Если нам нужно убрать книгу сверху, мы её убираем, а книга под ней становится верхней. Тут то же самое, только в начале мы должны определить, что следующий элемент станет вершиной *top = q->next; и только потом удалить элемент free(q);
Если книга, которую нужно убрать находится между двумя книгами или между книгой и столом, предыдущая книга ляжет на следующую или на стол. Как мы уже поняли, книга у нас-это ячейка, а стол получается это NULL, то есть следующего элемента нет. Получается так же как с книгами, мы обозначаем, что предыдущая ячейка будет связана с последующей prev->next = q->next;, стоит отметить что prev->next может равняться как ячейке, так и нулю, в случае если q->next = NULL, то есть ячейки нет(книга ляжет на стол), после этого мы очищаем ячейку free(q).
Так же стоит отметить, что если не провести данную связь, участок ячеек, который лежит после удаленной ячейки станет недоступным, так как потеряется та самая связь, которая соединяет одну ячейку с другой и данный участок просто затеряется в памяти
Функция вывода данных стека на экран
Самая простая функция:
Здесь я думаю все понятно, хочу сказать лишь то, что q нужно воспринимать как бегунок, он бегает по всем ячейкам от вершины, куда мы его установили вначале: *q = top;, до последнего элемента.
Главная функция
Хорошо, основные функции по работе со стеком мы записали, вызываем.
Посмотрим код:
Вернемся к тому, почему же в функцию мы передавали указатель на указатель вершины. Дело в том, что если бы мы ввели в функцию только указатель на вершину, то «Стек» создавался и изменялся только внутри функции, в главной функции вершина бы как была, так и оставалась NULL. Передавая указатель на указатель мы изменяем вершину *top в главной функции. Получается если функция изменяет стек, нужно передавать в нее вершину указателем на указатель, так у нас было в функции s_push,s_delete_key. В функции s_print «Стек» не должен изменяться, поэтому мы передаем просто указатель на вершину.
Вместо цифр 1,2,3,4,5 можно так-же использовать переменные типа int.
Заключение
Полный код программы:
Так как в стек элементы постоянно добавляются на вершину, выводиться элементы будут в обратном порядке
В заключение хотелось бы поблагодарить за уделенное моей статье время, я очень надеюсь что данный материал помог некоторым начинающим программистам понять, что такое «Стек», как им пользоваться и в дальнейшем у них больше не возникнет проблем. Пишите в комментариях свое мнение, а так же о том, как мне улучшить свои статьи в будущем. Спасибо за внимание.
Путешествие по Стеку. Часть 1
В предыдущих материалах мы рассмотрели размещение программы в памяти – одну из центральных концепций, касающихся выполнения программ на компьютерах. Теперь обратимся к стеку вызовов – рабочей лошадке большинства языков программирования и виртуальных машин. Нас ожидает знакомство с удивительными вещами вроде функций-замыканий, переполнений буфера и рекурсии. Однако всему свое время – в начале нужно составить базовое представление о том, как работает стек.
Стек имеет такое важное значение, потому что благодаря ему любая функция «знает» куда возвращать управление после завершения; функция же, в свою очередь — это базовый строительный блок программы. Вообще, программы внутренне устроены довольно просто. Программа состоит из функций, функции могут вызывать другие функции, в процессе своей работы любая функция помещает данные в стек и снимает их оттуда. Если нужно, чтобы данные продолжили существовать после завершения функции, то место под них выделяется не в стеке, а в куче. Вышесказанное в равной степени относится как к программам, написанным на относительно низкоуровневом C, так и к интерпретируемым языкам вроде JavaScript и C#. Знание данных вещей обязательно пригодится — и если придется отлаживать программу, и если доведется заниматься тонкой подстройкой производительности, да и просто для того, чтобы понимать, что же там, все-таки творится внутри программы.
Итак, начнем. Как только мы вызываем функцию, в стеке для нее создается стековый кадр. Стековый кадр содержит локальные переменные, а также аргументы, которые были переданы вызывающей функцией. Помимо этого кадр содержит служебную информацию, которая используется вызванной функцией, чтобы в нужный момент возвратить управление вызвавшей функции. Точное содержание стека и схема его размещения в памяти могут быть разными в зависимости от процессорной архитектуры и используемой конвенции вызова. В данной статье мы рассматриваем стек на архитектуре x86 с конвенцией вызова, принятой в языке C (cdecl). На рисунке вверху изображен стековый кадр, разместившийся у верхушки стека.
Сразу бросаются в глаза три процессорных регистра. Указатель стека, esp, предназначается для того, чтобы указывать на верхушку стека. Вплотную к верхуше всегда находится объект, который был добавлен в стек, но еще оттуда не снят. Точно также в реальной жизни обстоят дела со стопкой тарелок или пачкой 100-долларовых банкнот.
Хранимый в регистре esp адрес изменяется по мере того, как объекты добавляются и снимаются со стека, однако он всегда указывает на последний добавленный и еще не снятый со стека объект. Многие процессорные инструкции изменяют значение регистра esp как побочный результат своего выполнения. Реализовать работу со стеком без регистра esp было бы проблематично.
В случае с процессорами Intel, ровно как и со многими другими архитетурами, стек растет в направлении меньших адресов памяти. Поэтому верхушка, в данном случае, соответствует наименьшему адресу в стеке, по которому хранятся валидные используемые данные: в нашем случае это переменная local_buffer. Думаю, должно быть понятно, что означает стрелка от esp к local_buffer. Здесь все, как говорится, по делу – стрелка указывает точно на первый байт, занимаемый local_buffer, и это соответствует тому адресу, который хранится в регистре esp.
Далее на очереди еще один регистр, используемый для отслеживания позиций в стеке – регистр ebp – базовый указатель или указатель базы стекового кадра. Данный регистр предназначен для того, чтобы указывать на позицию в стековом кадре. Благодаря регистру ebp текущая функция всегда имеет своего рода точку отсчёта для доступа к аргументам и локальным переменным. Хранимый в регистре адрес изменяется, когда функция начинает или прекращает выполнение. Мы можем довольно просто адресовать любой объект в стековом кадре как смещение относительно ebp, что и показано на рисунке.
В отличии от esp, манипуляции с регистром ebp осуществляется в основном самой программой, а не процессором. Иногда можно добиться выигрыша в производительности просто отказавшись от страндартного использования регистра ebp – за это отвечают некоторые флаги компилятора. Ядро Linux – пример того, где используется такой прием.
Наконец, регистр eax традиционно используется для хранения данных, возвращаемых вызвавшей функции — это высказывание справедливо для большинства поддерживаемых в языке C типов.
Теперь давайте разберем данные, содержащиеся в стековом кадре. Рисунок показывает точное побайтовое содержимое кадра, c направлением роста адресов слево-направо – это то, что мы обычно видим в отладчике. А вот и сам рисунок:
Локальная переменная local_buffer – это массив байт, представляющий собой нуль-терминированную ASCII-строку; такие строки — неизменный атрибут всех программ на C. Размер строки — 7 байт, и, скорее всего, она была получена в результате клавиатурного ввода или чтения из файла. В нашем массиве может храниться 8 байт и, следовательно, один байт остается неиспользуемым. Значение этого байта неизвестно. Дело в том, что, данные то и дело добавлются и снимаются со стека, и в этом «бесконечном танце операции добавления и снятия» никогда нельзя знать заранее, что содержит память, пока не осуществишь в нее запись. Компилятор языка C не обременяет себя тем, чтобы иницилизировать стековый кадр нулями. Поэтому содержащиеся там данные заранее неизвестны и являются в некоторой степени случайными. Уж сколько крови попило такое поведение компилятора у программистов!
Идем далее. local1 – 4-байтовое целое число, и на рисунке видно содержимое каждого байта. Кажется, что это большое число – только взгляните на все эти нули после восьмерки, однако здесь наша интуиция сослужила нам дурную службу.
Процессоры Intel используют прямой порядок байтов (дословно «остроконечный»), и это значит, что числа хранятся в памяти начиная с младшего байта. Иными словами, самый младший значащий байт хранится в ячейке памяти с наименьшим адресом. На рисунках и схемах байты многобайтовых чисел традиционно изображаются в порядке слева-направо. В случае с прямым порядком байт, самый младший значащий байт будет изображен в крайней левой позиции, что отличается от привычного нам способа представления и записи чисел.
Неплохо знать о том, что вся эта «остроконечная / тупоконечная» терминология восходит к произведению Джонатана Свифта «Путешествия Гулливера». Подобно тому, как жители Лилипутии чистили яйцо с острого конца, процессоры Intel тоже обрабатывают числа начиная с младшего байта.
Таким образом, переменная local1 в действительности хранит число 8 (да-да, прям как количество щупалец у осьминога). Что касается param1, то там во втором от начала октете изображена двойка, поэтому в результате получаем число 2 * 256 = 512 (мы умножаем на 256, потому что каждый октет – это диапазон от 0 до 255). param2 хранит число 1 * 256 * 256 = 65536.
Служебная информация стекового кадра включает в себя два компонента: адрес стекового кадра вызвавшей функции (на рисунке — saved ebp) и адрес инструкции, куда необходимо передать управление по завершении данной функции (на рисунке – return address). Эта информация делает возможным возвращение управления, и следовательно, дальнейшее выполнение программы как будто никакого вызова и не было.
Теперь давайте рассмотрим процесс «рождения» стекового кадра. Стек растет не в том направлении, которое обычно ожидают увидеть, и сначала это может сбивать с толку. Например, чтобы увеличить стек на 8 байт, программист вычитает 8 из значения, хранимого в регистре esp. Вычитание – странный способ что-либо увеличить. Забавно, не правда ли!
Возьмем для примера простенькую программу на C:
Предположим, программу запустили без параметров в командной строке. При выполнении «сишной» программы в Linux, первым делом управление получает код, содержащийся в стандартной библиотеке C. Этот код вызовет функцию main() нашей программы, и, в данном случае, переменная argc будет равна 0 (на самом деле, переменная будет равна «1», что соответствует параметру — названию, под которым запущена программа, но давайте для простоты это момент сейчас опустим). При вызове функции main() происходит следующее:
Шаг 2 и 3, а также 4 (описан ниже) соответствуют последовательности инструкций, которая называется «прологом» и встречается практически в любой функции: текущее значение регистра ebp помещается в стек, затем значение регистра esp копируется в регистр ebp, что фактически приводит к созданию нового стекового кадра. Пролог функции main() такой же, как и других функций, с той лишь разницей, что при начале выполнения программы регистр ebp содержит нули.
Если взглянуть на то, что располагается в стеке под argc, то будут видны еще некоторые данные – указатель на строку-название, под которым программа была запущена, указатели на строки-параметры, переданные через командную строку (традиционный C-массив argv), а также указатели на переменные среды и непосредствено сами эти переменные. Однако, на данном этапе нам это не особо важно, так что продолжаем двигаться по направлению к вызову функции add():
Функция main() сначала вычетает 12 из текущего значения в регистре esp для выделения нужного ей места и затем присваивает значения переменным a и b. Значения, хранимые в памяти, изображены на рисунке в шестнадцатеричной форме и с прямым порядком байтов – как и в любом отладчике. После присвоения значений, функция main() вызывает функцию add(), и та начинает выполняться:
Чем дальше, тем интересней! Перед нами еще один пролог, однако теперь уже четко видно как последовательность стековых кадров в стеке оказывается организованной в связный список, и регистр ebp хранит ссылку на первый элемент этого списка. Вот с опорой на это и реализованы трассировка стека в отладчиках и Exception-объекты высокоуровневых языков. Обратим внимание на типичную для начала выполнения функции ситуацию, когда регистры ebp и esp указывают в одно и то же место. И еще раз вспомним, что для наращивания стека осуществляется вычитание из значения, хранящегося в регистре esp.
Важно заметить следующее — при копировании данных из регистра ebp в память происходит непонятное на первый взгляд изменение порядка хранения байтов. Дело в том, что для регистров такого понятия как «порядок байтов» не существует. Иными словами, рассматривая регистр, мы не можем говорить о том, что в нем есть «старшие или младшие адреса». Поэтому отладчики показывают значения, хранимые в регистрах, в наиболее удобном для человеческого восприятия виде: от более значимых к менее значимым цифрам. Таким образом, имея стандартную нотацию «слева-направо» и «little-endian» машину, создается обманчивое впечатление, что в результате операции копирования из регистра в память байты поменяли порядок на обратный. Я хотел, чтобы картина, показанная на рисунках была максимально приближена к реальности – отсюда и такие рисунки.
Теперь, когда самая сложная часть у нас позади, осуществляем сложение:
Здесь у нас появляется неизвестный регистр, чтобы помочь со сложением, но в целом ничего особенного или удивительного. Функция add() выполняет вою работу и, начиная с этого момента все действия в стеке будут осуществляться в обратном порядке. Но об этом расскажем как-нибудь в другой раз.
Все, кто дочитал до этих строк, заслуживает подарок за стойкость, поэтому я с огромной гиковской гордостью презентую Вам вот эту единую схемку, на которой изображены все вышеописанные шаги.
Не так уж все и сложно, стоит только разложить все по полочкам. Кстати, маленькие квадратики очень сильно помогают понимаю. Без «маленьких квадратиков» в информатике вообще никуда. Надеюсь, мои рисунки позволили составить ясную картину происходящего, на которой интуитивно просто показан и рост стека, и изменения содержимого памяти. При ближайшем рассмотрении, наше программное обеспечение не так уж и сильно отличается от простой машины Тьюринга.
На этом завершается первая часть нашего путешествия по стеку. В будущих статьях нас ждут новые погружения в «байтовые» дебри, после чего посмотрим, что же на этом фундаменте способны выстроить высокоуровневые языки программирования. Увидимся на следующей неделе.
