Ассемблер – это язык, с помощью которого понятным для человека образом пишутся команды процессора. На самом деле процессор понимает не команды Ассемблера, а последовательности из нулей и единиц. Преобразованием команд Ассемблера в команды процессора занимается компилятор (например, TASM, MASM, WASM). Обычно одна команда Ассемблера соответствует одной команде процессора, хотя не всегда – иногда для упрощения вида программ под одной командой маскируется несколько (например, команда Ассемблера (но не команда процессора!) invoke). Программы, написанные на Ассемблере не уступают в качестве и скорости программам, написанным на машинном языке, так как компилятор просто переводит мнемонические обозначения команд в последовательности байтов (нулей и единиц, если так понятнее)

Человек не может одновременно удерживать в голове большое количество чисел, тем более из нулей и единиц. Если бы он писал программу даже всего из 100 команд, он вынужден был бы вручную для себя обозначать как-нибудь эти команды, делать пояснения. Но так как работа эта несложная, но утомительная, то лучше её поручить компилятору, а программист пусть лучше занимается более полезными делами. Программы, написанные на Ассемблере могут быть на порядок более сложными, чем программы, написанные на машинном языке, так как человек больше думает об алгоритме, и меньше отвлекается на такие пустяки, типа как кодируется команда сложения регистра eax и числа 2. Но всё-таки, я считаю, что писать большие программы на Ассемблере – это плохо. Существуют языки высокого уровня, на которых при одном и том же уровне ума и памяти программиста он сможет писать более сложные программы. Это в основном достигается за счёт использования содержательных названий переменных, разбиения программы на процедуры и модули, также язык высокого уровня скрывает от человека многие действия, которые его могут отвлекать от сути (например, программист может не думать, что для организации цикла for может требоваться несколько команд Ассемблера, он может не думать, что позволяет, а что не позволяет конкретная архитектура процессора. Например, нет такой команды в Ассемблере, которая бы могла пересылать значения из одной ячейки памяти в другую, а в языках высокого уровня это сплошь и рядом). Кроме того, программа на языке высокого уровне обычно короче, чем соответствующая программа на Ассемблере, и больше поддаётся изменению и коррекции. Но всё-таки, если бы всё было так хорошо, небыло бы смысла использовать Ассемблер. Конечно, программа на языке высокого уровня будет работать медленнее, чем программа на языке высокого уровня. Высокой скорости алгоритма при реализации его на Ассемблере можно добиться в основном за счёт удержания основных переменных (которые используются чаще всего) в регистрах и использования особенностей конкретного процессора. Обращение к регистрам происходят быстрее раз в десять, чем обращения к ячейкам памяти, поэтому стоит по возможности избегать хранение основных переменных в ячейках памяти. Если рабочих регистров (eax, ebx, ecx, edx, esi, edi) не хватает – можно испоьзовать ebp и esp, но следуя определенным ограничениям. Но чаще всего во внутренне цикле активно используется не так уж много переменных (при рациональном написании программы)

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

Я предпочитаю сначала написать программу на языке высокого уровня, проверить правильность работы, а затем искать в ней места, которые чаще всего выполняются. Это могут быть самые внутренние циклы, в компьютерной графике это могут быть процедуры типа putpixel, line, ClearDevice и другие. Эти процедуры стоит написать на Ассемблере и максимально оптимизировать. Но когда мы ими пользуемся, мы можем забыть про то, что они написаны на Ассемблере. Мы просто их вызываем. Такой подход обеспечнивает хороший стиль программы, и при этом высокую скорость. Если же просто всё написать на Ассемблере, то это во-первых, долго, во-вторых, делает программу менее понятной и менее изменяемой. Исправить в ней что-либо будет раз в десять труднее, чем при правильном подходе. В-третьих, эта программа будет работать только на той платформе, под которую её пишем. Может, лет через 20 архитектура процессоров будет совсем другой, и не будет поддерживать эти команды. А в программе, написанной на языке высокого уровня надо будет изменить только ассемблерные вставки, что проще раз в десять, так как понятно конкретное предназначение каждой вставки, и по объёму меньше раз в десять – ведь объём вставок обычно не превышает 10% объёма всей программы, то есть получается, В СТО РАЗ меньше работы

Существует такой закон: 20% программного кода выполняется 80% времени. Если оптимизировать эти 20%, то можно получить значительный выигрыш и без изменения остального кода программы. Оптимизировать нужно некоторые часто вызываемые процедуры, внутренние циклы, и т п. Не стоит без необходимости оптимизировать участки программ, если это делает их менее понятными. В этом случае понижается надёжность программы. В конечном итоге, выигрыш должен быть заметным прежде всего для пользователя программы, а ему нужна прежде всего стабильность работы программы (при разумной скорости), и только затем высокое быстродействие
Закон Парето 20 и 80
Закон Парето 20 и 80

Если вас интересует, зачем нужен Ассемблер, можете почитать здесь

Для изучения Ассемблера можно использовать Турбо-Паскаль , но он 16-разрядный, и не поддерживает команды процессоров выше 80286. Поэтому если вы хотите, чтобы компилятор понимал все описанные здесь команды, стоит использовать, например, Free Pascal 1.94 for DOS. Скачать его можно здесь

Итак, начинаем описание Ассемблера. Первая страница