От транзистора до компьютера

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

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

Статья большая!


Это сообщение отредактировал Avaddon74 - 29 июн 2026 в 21:48

И так, всё началось с изобретения транзистора, грубо говоря, у него есть три контакта: вход, выход и управляющий блок. Логика работы простая, на вход идет напряжение, на выходе напряжение, а управляем мы этим напряжением, через управляющий блок другим напряжением меньше или таким же. Если на управляющий блок приходит напряжение, то ворота открываются и на выходе есть наше напряжение, если на блоке нет напряжения, то ворота закрываются и на выходе нет напряжения.

Это удобно использовать, например, для управления двигателем, подали слабое напряжение на управляющий блок - двигатель включился, сняли напряжение – двигатель выключился. Управляем сильными токами слабым.

Эта основа и легла в построении цифрового сигнала. Бинарность, или по другому, только два состояния:

• 0 или 1
• белое – черное
• беременна – не беременна (не может быть чуть-чуть беременна)
• и т.д.

Но электричество оно аналоговое, например, нам нужно четко только два состояния 0 вольт и 1 вольт, но напряжение может быть и 0.5 вольт и 0.3, 0.6 и т.д. Для этого можно поставить «фильтр» на управляющий блок, который будет работать по принципу: если напряжение ниже 0,5 вольт, то выключено, если больше, то включено. Это и есть самое базовое преобразование аналогово сигнала в цифровой.

Таким образом, появляется понятие Бит – это один сигнал с состоянием: 0 или 1 и минимальная единица цифровой информации.
Один транзистор может управлять одним сигналом: есть сигнал — 1, нет сигнала — 0. Если взять два таких сигнала, мы получим два бита и четыре возможных состояния.

Слева сигналы в двоичной системе, справа как мы записываем их в привычной нам, десятеричной системе.

Код

0 0 - 0 0 1 - 1 1 0 - 2 1 1 - 3

3 сигнала – 3 бита, 8 состояний

Код

0 0 0 - 0 0 0 1 - 1 0 1 0 - 2 0 1 1 - 3 1 0 0 - 4 1 0 1 - 5 1 1 0 - 6 1 1 1 - 7

На этом и строится логическая работа в электронике. 2 в степени n, где n – количество бит или сигналов, а результат - количество состояний. И поэтому в компьютере всё выражается через степень двойки.

Теперь нам нужно где-то сохранить эти сигналы, это и будет - память. Самое примитивное объяснение, это описать на конденсаторе. Его задача хранить энергию пока он отключен от цепи, и отдавать её если подключен к цепи (это не единственная его задача, но сейчас это не важно). И так, мы подали напряжение на конденсатор и отключили его из цепи. Мы записали Единицу.

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

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

Например, жесткий диск, его устройство простое, на металлическую пластину мы «записываем» определенное магнитное поле, например, если магнитное поле направленно на юг – то мы считаем Единицу, если на север, то мы считаем 0. Потом считывающая головка просто определяет направление магнитного поля и понимает, какой сигнал записан. Такой же принцип и с магнитофонной лентой.

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

Для примера возьмем 1 + 1 = 2

Для этого нам нужно ввести ещё одно понятие, Битность – это сколькими сигналами мы управляем за раз. Например, 2-х битная операция сложения будет выглядеть так, 4 входа – по 2 бита на число и 2 выхода – 2 бита на результат.

Код

Получим 0 1 + 0 1 = 1 0 (это не десять, а 1 и 0)

На самом деле там всё сложнее, существует переполнение и т.д. Но как базовый пример, с чего всё начиналось, подойдет.
Переполнение, это если мы используем 2 + 2 = 4, то четверка уже не впишется в два сигнала, тогда нужно три выхода:

Код

1 0 + 1 0 = 1 0 0 (каждая цифра – отдельный сигнал, а не десять плюс десять равно сто!)

Теперь у нас есть математика, но немного вернемся ещё к важному моменту.

Если мы возьмем 8 сигналов, то получим уже 8 бит или это 1 байт. Это единица уже блока информации. Проектировщики просто пришли к соглашению, что минимальный блок информации в компьютере будет именно 8 бит из-за удобства архитектуры и кодирования данных.
8 бит, это уже приличный объем данных 256 состояний или от 0 до 255 в числах.

Именно это «магическое» число 255 встречается везде в компьютерах. День программиста празднуется на 256-ый день в году

Совсем коротко о двоичной системе и как хранить данные. При таком подходе, мы можем хранить числа только от 0 до 255 в одном байте, например:

Число 1 будет выглядеть в сигналах так 00000001 - (8 сигналов, на первом сигнале есть напряжение, на остальных нету) Двоичная система читается справа налево.
Число 10 будет выглядеть в сигналах так 00001010
А число 175 будет выглядеть в сигналах так 10101111

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

Теперь осталось реализовать схемы базовых операций: Сложение, Вычитание, Умножение, Деление.
Также нужно реализовать логические операции, например:

если был 0, то сделает 1 и наоборот из 1 в 0 - операция НЕ
или если было 0 0, то сделает 0, а если хоть одна единица то 1 - операция ИЛИ

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

Теперь, у нас есть способ хранения сигнала и простые схемы с логическими и математическими вычислениями.
Добавляем блок управления схемами, он будет выбирать, какую математическую или логическую операцию использовать.
Добавляем ячейки хранения данных – это регистры, сейчас грубо возьмем, что их 4. Из какого регистра нам считать данные и в какой регистр записать результат.

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

Для всех операций будет использована 8-ми битная система, и ячейки для хранения (регистры) так же будут каждая из 8-ми бит, отсюда и первые массовые процессоры будут называться 8-ми битными. Теперь вы понимаете, что такое 8-мибитная приставка «Денди»

Ну что, пришло время научить управлять нашим процессором

Разберем опять пример 1 + 1 = 2

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

Код

Записать число 1 в первый регистр (что хотим сложить) Записать 1 во второй регистр (с чем хотим сложить) Сложить первый регистр со вторым и записать результат в четвертый регистр

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

Что можно сделать в такой ситуации, можно пронумеровать наши операции числами, например:
1 – запись, 2 – чтение, 3 – сложение, 4 – вычитание и т.д.

И также в таблице процессору определить какие данные из каких регистров брать.
А регистрам дать номера: 1, 2, 3, 4
Теперь нам нужно договориться, чтоб процессор четко разделял инструкции, что в инструкции всегда будет 4 числа (Это самый простой пример, в реальности намного сложнее!)

Теперь наша инструкция выглядит так:

• Первый байт – команда
• Второй – куда записать
• 3 и 4 байты – номер регистра или данные

Тогда инструкция процессору будет выглядеть так

Код

1 1 1 0 (это не биты, а десятеричные коды/номера) в битах будет так 00000001 00000001 00000001 00000000

Т.е. 32 бита. Процессор получив такой сигнал, пойдет по своей схеме транзисторов выберет определенную схему «запись в регистр», определит в какой регистр писать и поместит туда число 1. Но для 32-х бит не обязательно 32 «провода», мы можем их передавать последовательно по 8-ми проводам. Далее:

Код

1 2 1 0 (записать во второй регистр 1) 00000001 00000010 00000001 00000000 3 4 1 2 (3 – сложение, первого регистра со вторым, результат в 4 регистр) 00000011 00000100 00000001 00000010

Всё!
Мы научили наш процессор математике! Просто передавая последовательно сигналы. Теперь нам нужно упаковать это всё в последовательность. Номера регистров и инструкции мы пишем в 16-тиричной системе (так удобнее программистам):

Код

0x01 0x01 0x01 0x00, 0x01 0x02 0x01 0x00, 0x03 0x04 0x01 0x02

Это всё те же самые числа, только по порядку, 0x - нам говорит, что это 16-тиричная система, чтоб мы не путали с 10-тиричной.
Теперь мы просто по проводам передадим нужные сигналы через управление транзисторами.

Поздравляю! Мы только что написали первую программу на машинном коде!

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

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

Память разбита на блоки (ячейки) по 8 бит или 1 байт, и у каждой ячейки есть свой адрес: 0, 1, 2, 3, …, n

Адрес ячейки мы также записываем в шестнадцатеричной системе, например 0xA0, это число 160 в десятеричной системе, т.е. ячейка под номером 160. И так же есть контроллер, который знает адреса этих ячеек и как с ними работать.
Когда мы обращаемся к памяти, например на чтение, мы говорим, дай нам данные из ячейки 0xA0, и мы на выходе получаем последовательность из 8-ми сигналов которые хранились в этой ячейке, что-то типа 01010010

Адрес ячейки так же передается сигналами и при записи и при чтении:

Код

запиши в 10100000 значение 01010010

Это всё делается через блок управления, в одну часть схемы подаем сигналы адреса в другую часть схемы данные. Собственно и всё, этих знаний для дальнейшего объяснения достаточно.

Самая простая аналогия памяти, это шкаф с ящиками, где каждый ящик пронумерован. И командами мы говорим: Положи в пятый ящик число 1, а потом достань содержимое пятого ящика и скажи, что там лежит.

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

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

А также дырокол, который мог «распечатать» результат на такой карте или ленте.

Вот, упрощенно так бы выглядела перфокарта с нашей первой программой.

Коротко, стоит ещё упомянуть, каким образом мы храним различные символы в памяти.

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

Также появляется электронная память – Оперативная память. Принцип похожий: у нас всё ещё есть ячейки, куда можно положить данные и потом забрать их обратно. Только теперь это уже не отверстия в перфокарте, а электронное устройство на микросхемах.

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

Я думаю, на этом стоит завершить описание «железа». Теперь, у вас есть более-менее представление о виде компьютера. Это не только сам процессор, но и оперативная память, для хранения промежуточных результатов, это устройства ввода, сначала перфокарты, потом уже более сложные устройства и клавиатура, это устройства вывода, дырокол для перфокарт, экраны, это постоянное хранилище ваших файлов, таких как HDD, SSD и т.д.

Переходим к языкам программирования и созданию систем управления компьютером.

А теперь пришло время познакомиться с Ассемблером.

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

Код

X = ((a + b) * c) / (a * b / 2)

И потом рассчитать при значениях a = 7, b = 20, c = 2
а потом нужны такие же расчеты при a = 10, b = 7, c = 5
Напомню, что простой пример 1 + 1 = 2 у нас превратился в

Код

0x01 0x01 0x01 0x00, 0x01 0x02 0x01 0x00, 0x03 0x04 0x01 0x02

И потом ведь ещё нужно было прочитать этот код. Представьте, что вместо слов в тексте у вас будут только числа соответствующие этому слову, напишите такой текст из чисел, а потом попытайтесь его прочитать… представили?

Поэтому, был разработан язык программирования Ассемблер. Задача была писать код не в машинных кодах - числах, а использовать названия операций – слова или сокращения. И теперь наш пример будет выглядеть так (это условный пример ассемблера):

Код

mov r1, 1; записать число 1 в первый регистр mov r2, 1; записать число 1 во второй регистр add r4, r1, r2; сложить r1 и r2, результат записать в r4

После выполнения этих инструкций в регистре r4 находится число 2. Следующая инструкция уже может считать это значение и сохранить его в оперативную память компьютера

Код

store 0xA0, r4; сохранить значение из r4 в ячейку памяти с адресом 0xA0

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

Вот такой вот он – Ассемблер!

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

Код

mov – 1, read – 2, add – 3, …, store - 15

Теперь, мы можем сопоставить наши команды, с командами процессору.

Как происходит написание программы.

• Программист пишет код на ассемблере
• Записывает его в файл
• Далее запускает транслятор и говорит, вот этот файл нужно перевести в машинный код

По факту, это также будет делать наш процессор, но у него уже есть инструкции как это сделать
Транслятор запишет всё в новый файл, который уже не содержит mov, add, имена регистров и т.д. а будет выглядеть как наша первая программа:

Код

0x01 0x01 0x01 0x00, 0x01 0x02 0x01 0x00, 0x03 0x04 0x01 0x02, 0x0F 0xA0 0x04 0x00

Т.е. очень приближенно, задача транслятора, пробежаться по таблице и заменить наши слова, на команды, заменить имена регистров на номера регистров и потом записать в новый файл только уже просто числами. Вот такой файл с машинным кодом впоследствии будет называться – исполняемый файл, в более современном представлении для Windows - файл.exe. И его уже можно запускать на машине.

А если нужно что-то подредактировать, то мы опять открываем наш код на ассемблере, читаем его, редактируем и заново запускаем транслятор.

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

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

Но есть ещё одна проблема, существуют разные системы команд процессоров. Такие несовместимые между собой системы команд выделяют в разные архитектуры процессоров. Единого набора команд для всех архитектур не существует.

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

Запомним эту проблему на будущее, она ещё сыграет свою роль.

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

В связи с озвученными проблемами, программирование было очень сложным, муторным и долгим процессом. Разумеется, программисты не пытались с этим смириться, а искали выходы, как это всё упростить. Начали появляться различные языки программирования, более удобные для нас чем Ассемблер: Fortran, BASIC и т.д.

Но одним из самых влиятельных языков, который оказал огромное воздействие на будущие программы и новые языки был язык программирования C (читается как «си»).

Наш пример выше уже будет выглядеть так:

Код

int a = 1 + 1;

Всё!!! Согласитесь, уже можно спокойно читать. Больше ничего для такого примера не нужно, после этого переменная ‘a’, будет содержать уже 2, нам не нужно расписывать в какие регистры складывать, в какую область памяти потом копировать результат, какую операцию выбрать на процессоре и т.д. Компилятор (о нём далее) сам выстроит все нужные цепочки, и сам выберет где хранить переменную.

А тот сложный пример выше будет выглядеть так:

Код

// это комментарий к программе int a = 7; int b = 20; float c = 2.0; float x = ((a + b) * c) / (a * b / 2);

И опять всё! Больше нет ни какого геморроя. Это вам сейчас этот язык кажется очень сложным, а тогда это был прорыв. Немного забегая вперед, современные языки стали ещё проще.

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

Теперь у нас есть программа на языке Си, осталось только научить процессор с ней работать.

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

Первые версии этих программ, а лучше сказать инструментов, были написаны на машинном коде или Ассемблере, ну а уже позже использовался сам язык Си. Да, да, на Си можно написать компилятор для Си :)

• Появляется такое понятие, как препроцессор. Его задача - обработать специальные команды языка Си: подключить указанные файлы, заменить одни выражения другими, удалить комментарии и выполнить другие действия. Коротко говоря, он подготавливает исходный код к следующему этапу.
• Т.к. язык Си уже был более обширным, то для него понадобился продвинутый транслятор, который называется компилятор. Он перегоняет код из Си в ассемблерный код, по каждому файлу.
• Далее запускается трансляция из ассемблера, в машинный код.
• А последним запускается Линковщик - его цель собрать все файлы с машинным кодом воедино и на выходе уже появится готовый исполняемый файл.

Если мы внесли правки, то, как и с Ассемблером, нам нужно выполнить все эти процессы повторно.

Вот мы и подходим к созданию операционных систем (ОС). До этого мы обсуждали только работу с процессором, но ведь у нас есть ещё и мониторы для вывода информации, и хранилища данных для файлов. И с этими устройствами нужно как-то работать.

Представим, что программе нужно вывести на экран слово «Привет». Тогда нам нужно знать, по каким проводам передавать данные, какие команды понимает именно этот экран, куда записать код символа и как проверить, что устройство закончило работу.

Код

mov device, 2; выбрать устройство экрана mov port, 15; выбрать нужный порт mov data, 207; условный код первого символа «П» send port, data; отправить сигнал устройству wait device; дождаться выполнения

И такие команды нужно повторять для каждого символа!

То же самое происходит и с файлами. Нам придется напрямую управлять жестким диском и знать его систему команд.

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

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

И теперь, через текстовую командную оболочку, мы можем общаться с ОС:

Код

Print Привет

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

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

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

На этом всё.
Всем спасибо за внимание кто дочитал! Надеюсь, вам было интересно.


P.S. Зная как тут любят цепляться, что это всё нейронки пишут. Статья написана мной, не нейронкой! Нейронку подключал только для проверки логических ошибок и двойного толкования в тексте. Но переписывал спорные моменты сам. Сценарий тоже сам, идеи для картинок процентов на 80 сам писал. Генерация картинок выполнялась с помощью нейронки. Я бы сам запарился всё это рисовать!