Часть 4)

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

Процедурная модель

Самое простое для выполнения на компьютере и прочих автоматических девайсах – это процедурные языки программирования. В них есть чёткая последовательность шагов, каждый со своим номером, и выполнение происходит строго по порядку. Есть логические и арифметические действия, по результатам которых можно сделать переход не на следующий шаг, а на какой-то другой с заданным номером. Так получаются ветвление алгоритма на разных условиях и циклы.

Пример такого алгоритма – переход дороги:

• 1. пока не дошли до дороги: вперёд 1 шаг
  (а точнее:
  • 1а. дошли до дороги? да – переход на шаг 2, нет – переход на шаг 1б
  • 1б. пройти вперёд по тропинке на 1 шаг
  • 1в. переход на шаг 1а)
• 2. пока есть машины ждать 1 секунду
• 3. перейти дорогу

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

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

Предикатная модель

Предикатная модель более близка к человеческой форме записи и обработки знаний. С её помощью изначально записывали математические формулы и логические построения. Суть её в том, что имеется набор правил, которые никак не связаны между собой порядком исполнения. Но! У каждого правила есть условие активации, состояние (например, состояние вычислительной среды), при котором это правило может выполняться, и выполнение этого правила меняет состояние. Какой-то внешний исполнитель проверяет все правила из набора и применяет правило, которое подходит к текущему состоянию. Для изменённого состояния вновь ищется подходящее правило и так далее. Конечно, внутри самого правила может встречаться и последовательная запись инструкций выполнения, но это уже для удобства и не принципиально. Могут быть и сигнальные состояния, т.е. состояния, которые не встречаются во внешней среде, а которые вырабатываются самими правилами как промежуточные, для активации других правил, когда мы хотим сложное правило разбить на набор простых.

Например, для перехода дороги, набор правил был бы таким (формат – входное условие: действие):

• - (у дороги, машины есть) : ждать 1 секунду
• - (не у дороги) : вперёд 1 шаг
• - (у дороги, машин нет) : перейти дорогу

Исполнитель при этом сам развернёт набор правил в нужную последовательность действий, в зависимости от ситуации, например:

• - (у дороги: нет, машин нет: неизвестно) : вперёд 1 шаг
• - (у дороги: нет, машин нет: неизвестно) : вперёд 1 шаг
• - (у дороги: да, машин нет: нет) : ждать 1 секунду
• - (у дороги: да, машин нет: нет) : ждать 1 секунду
• - (у дороги: да, машин нет: да) : перейти дорогу

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

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

- (не у дороги, поворот на тропинке есть) : развернуться в сторону, ведущую к дороге

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

Зато и преимущества у такой записи весомые. В случае открытия новых неожиданностей, в процедурной записи нам бы пришлось перелопатить весь алгоритм и поправить все места, где эта неожиданность может встретиться. В предикатной записи (внимание!) в идеале достаточно добавить новое правило, которое бы меняло неожиданное состояние в одно из уже знакомых состояний. (Конечно, здесь не всё так просто, но об этом дальше.) Такую запись ещё можно назвать ситуативной, что будет точно отражать её суть – действие по ситуации, а не по жёсткому алгоритму. Некоторые задачи, которые трудно программировать в процедурном виде, в предикатном виде формулируются потрясающе просто, перекладывая всю тяжесть подбора цепочек правил на исполнителя.

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

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

В природе тоже есть такая форма кодирования (но она естественно отступает от жёсткого формализма), и она обеспечивает мощное и устойчивое кодирование и обработку информации, но исполнитель здесь - уже природные законы. Так, например, кодируются и реплицируются молекулы ДНК, они "катаются" по молекулярным цепочкам, сами встраиваются в нужное для себя место (в ненужное они не смогут прицепиться - параметры молекулярных связей не те), исправляют ошибки, пропущенные или наоборот продублированные куски. Похожее есть и в работе всего организма, взаимодействии особей, построении интеллекта.

Хороший пример был про шахматы у Пенроуза. Ситуация на доске была такая, что одна из сторон минимальными действиями могла поддерживать равновесие сил и выйти на ничью. Компьютерные же программы, которые действовали перебором вариантов, начинали ломать это равновесие, добиваясь ближнего во времени преимущества, которое на дальних шагах оборачивалось полным разгромом. (Но вывод из этого Пенроуз сделал неправильный – якобы человеческий мозг может до конца проверять «вечные» варианты в конечное время за счёт «дёргания» неизвестных физических процессов.)

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

Для случая с переходом дороги, это, например, была бы встреча с развилкой на тропинке. Программа должна найти правильный путь среди всех развилок. Для обычных дорог есть простой и однозначный алгоритм, здесь программа не будет блуждать вечно и съедать огромные ресурсы. Для вывода математических теорем и похожих случаев «карта дорог» будет меняться в зависимости от того, куда мы пойдём, с каждым нашим шагом вперёд мы будем видеть новый кусочек карты вокруг, близко от себя, но не сможем посмотреть вдаль или в сторону параллельной дорожки. И только пройдя по какому-то из путей вперёд, мы сможем увидеть, что там такое. А чтобы увидеть, что будет на параллельной дорожке, мы должны вернуться обратно к развилке и пойти по этой самой дорожке. Всю же карту сразу иметь нельзя - её размер больше чем бесконечен, и это касается многих кусков карты помельче! (см. )

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

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

Есть, конечно, такая штука, называемая нечёткие правила и вывод на них. Что она делает – вместо обычных булевых значений 0/1 использует весь диапазон от 0 до 1, и вычисление проходит не булевыми, а вещественными операциями, и результат соответственно – вещественное число, близость которого к нулю или к единице определяет близость к ложности или истине вычисляемого выражения. Это уже ближе к тому, что надо для интеллекта, но далеко не всё. Потому что на выходе получается только одно результирующее значение. Нечёткие правила хорошо обрабатывают нечёткость входных параметров, но не нечёткость/неопределённость ситуации в целом. Потому что для неопределённой ситуации будет не один результирующий вариант, а много. И при выводе с неопределённостями система должна будет не раз пройти через взрыв вариантов из-за неопределённости, и отсечение неперспективных вариантов. (Нечёткие правила – не моя тема, но насколько я знаю, они этого не делают.) Причём не просто запускать альтернативные цепочки и смотреть, какая из них быстрее приведёт к результату, а позволять их взаимодействие, в результате которых могут как родиться новые цепочки, так и исчезнуть старые, но это уже забегая вперёд, будет в следующих частях.

Как видим, ситуативная/предикатная модель – очень мощная штука, и заманчиво использовать её для построения искусственного интеллекта – знай себе, выписывай правила и добавляй их в копилку правил, а уж компьютер сам составит правильные логические цепочки. Японцы так и хотели сделать, даже компьютер пятого поколения на Пролог-процессорах сконструировали. И, как вы уже догадались, эта идея потерпела крах. Причины те же: взрыв вариантов, потребность обрабатывать неопределённости, нечёткости и похожие ситуации. Да ещё и всё это помноженное на то, что сам человек оперирует гигантским объёмом таких правил, в которых (помните?) весьма развесистые условия активации, да и вытащить их из головы, формализовать, задача весьма непростая. Ведь то, что человек выписывает в качестве формального правила – далеко не то, что у него творится в голове, да и необязательно правильно он это выписывает. Тут нужна отдельная система, которая бы занималась добычей знаний в правильном виде, во всём их гигантском объёме и развесистости условий активации.

Современные программные модели

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

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

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

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

Итог

Теперь нам понятно как программируют компьютеры, и чего в этом программировании не хватает, для того, чтобы обрести интеллект. Предикатная/ситуативная модель – мощная штука, и если ей удастся преодолеть проблемы, связанные со взрывом вариантов, обработкой неопределённостей и нечёткостей, то это будет хорошая база для создания интеллекта. Правда при этом она уйдёт от чёткости формализма и получит в дополнение кучу «особенностей» естественного интеллекта, но это уже другой разговор.

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

Однако основные принципы работы компьютера, заложенные во времена их рождения, действуют до сих пор. Данные пере даются с помощью сигнала методом "имеется сигнал или нет". Так появился "бит" . Бит - это единица информации, которая может принимать значение 0 или 1. Восемь бит объединяются в байт, один байт равен 8 битам. Число 8 появилось из-за того что первые компьютеры были восьмиразрядными и могли работать одновременно только с 8 разрядами, например, 01011001. Первые нули можно убирать.

В один байт можно записать любое число от 0 до 255. Указанный диапазон чисел очень мал, поэтому чаще используют более крупные диапазоны: два байта = слово, два слова = двойное слово.

Компьютер стал работать в двоичной системе счисления. Любое десятичное число можно записать как двоичное. Подробное преобразование рассматривать не будем, если кому-то интересно, пишите в комментариях – расскажу.

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

Шестнадцатеричная система выглядит по-другому. Каждый разряд со­держит шестнадцать состояний. Поэтому один разряд может принимать значения: 1, 2, 3, 4, 5, 6, 7, 8, 9, А, В, С, D , Е, F . Буква "А" соответствует цифре 10 в десятичной системе, "В" - 11 и т. д.

Например, число 1 B в шестнадцатеричной системе равно 27 в десятичной.

На протяжении всех материалов мы будем иногда встречаться с шестнадцатеричной сис­темой исчисления. В этом случае, чтобы отличать шестнадцатеричное число от десятичного, перед ним будет стоять знак #, например, #25, так принято в Delphi .

С числами с плавающей точкой работа идёт совершенно не так, рассматривать это мы не будем.

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

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

1.2. Машинный язык

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

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

Реальная программа, которую выполняет компьютер, представляет собой по­следовательность единиц и нулей. Такую последовательность называют машинным языком.

Например, команда сложения двух регистров в шестнадцатеричной системе выглядит так: $03С3. Это мало о чем го­ворит, и запомнить такую команду очень тяжело. Намного проще написать "сло­жить число 1 и число 2".

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

1.3. История языков программирования

Язык, на котором пишется программа, называется языком программирования.

Первым компилятором был Assembler (переводится как "сборщик"). Писать на нем почти так же сложно, как и в ма­шинных кодах, но теперь уже использовались не числа, а понятные человеку слова .

Текст на рисунке можно разделить на три колонки:

· адрес инструкции;

· машинный код инструкции;

· код на языке Ассемблера.

Например, команда копирования регистров выглядела так: mov еах, ebx . В данном случае mov - это команда языка программирования, еах и ebx - имена регистров.

На языке Assembler про­грамму писать легче, но программа, написанная в машинных кодах, ра­ботала быстрее и более гибко. При написании программы в машинных кодах программист ничем не ограничен, а при работе с ассемблером есть ограничения. Не всегда возможно повлиять на результат.

После создания ассемблера языки программирования стали появляться один за другим. Так появились С, ADA , FoxPro , Fortran , Basic , Pascal и др. Некоторые из них были предназначены только для обучения, другие были ориентиро­ваны на профессиональных программистов.

Язык Assembler в настоящее время в основном используется только в качестве вставок для языков высоко­го уровня, а машинные коды используются для написания того, что не может сделать компилятор.

Затем получило развитие объектно-ориентированное программирование. Язык С превратился в C++, Pascal в Object Pascal и т. д.

Последней крупной революцией, происходящей в программировании, считается переход на визуальное программирование. Этот переход происходит в настоящее время. Визуальность дает еще более удобные средства разработки для бы­строго написания кода, но проигрывает ООП по быстроте работы. Одни из часто используемых языков, поддерживающих визуальное программирование, являются Delphi и C #, хотя прогресс не стоит на месте и визуальные компоненты появляются для многих других языков.

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

1.4. Исполнение машинных команд

Кроме байта существуют и другие размерности:

· 1 килобайт = 1024 байт;

· 1 мегабайт = 1024 килобайт;

· 1 гигабайт = 1024 мегабайт.

· 1 терабайт = 1024 гигабайт.

· и т.д.

В компьютере большинство значений являются степенью числа 2, потому что компьютер оперирует двоичной системой, и таким образом можно максимально эффективно использовать его воз­можности. Именно из-за этого при расчёте размерностей используется 1024 (2 в степени 10).

Рассмотрим некоторые понятия.

Сегмент - это область внутренней памяти компьютера.

Когда операционные системы были 16-битными, процессор не мог работать с памя­тью размером более 64 килобайт, потому что это максимальный размер области памяти, который можно адресовать, используя в этих целях адрес длиной в два байта. Поэтому память делилась на сегменты по размеру и по назначению. В дан­ный момент используются 32-разрядныю ОС, которая может адресовать до 4 Гбайт оперативной памяти и 64-разрядные ОС. Поэтому можно сказать, что память стала сплошной. Однако деление ее по назначению все-таки осталось.

Существуют следующие сегмент s ы памяти:

· сегмент кода - область памяти, в которую загружается машинный код, который бу­дет потом выполняться процессором;

· сегмент данных - область памяти для хранения данных;

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

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

Регистр - ячейка памяти в процессоре. Её размер зависит от разрядно­сти. В 32-разрядных процессорах ячейки 32-битные, но есть и 64-битные. Таких регистров у процессора несколько, и каждый из них предназначен для определен­ных целей. Существуют также регистры общего значения, которые программа мо­жет использовать на свое усмотрение.

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

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

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

Какие языки используются для создания обычных прикладных программ (т.е. программ, написанных непосредственно для пользователей)? Их бесчисленное множество, самые популярные из них – C++ и Delphi. Они предоставляют наибольшее количество возможностей для разработки программ на все случаи жизни. Именно их используют профессиональные программисты.

Однако и С++, и Delphi были созданы на основе более простых языков. Для C++ это язык C (называют «Си»). Предшественник Delphi – это Pascal. Многие их учат ещё в школе на уроках информатики. Язык Pascal был создан именно для обучения программированию, так как является очень простым и понятным. Сейчас он используется практически во всех школах, колледжах, университетах и институтах.

После освоения Pascal изучение Delphi проходит, что называется «на ура». Такая последовательность освоения языков, т.е. сначала именно Pascal, а потом Delphi или C, C++, является весьма желательной. На вопрос «Какой язык программирования лучше» можно ответить, что для обучения начинающим лучше всего подойдет Паскаль (Pascal).

Для разработки мультфильмов и анимации была создана специальная программа – Adobe (Macromedia) Flash. Также Flash используют при разработке сайтов и для создания компьютерных игр. Язык, применяемый во Flash, – ActionScript. Он получил огромную популярность в наши дни, так как используется во всех современных интернет-проектах.

HTML является сокращением от англ. HyperText Markup Language и переводится как «язык разметки гипертекста». С его помощью создается большинство веб-страниц. Знание HTML значительно упрощает работу со своим блогом или сайтом, но не является при этом обязательным.

Более совершенные и функциональные (но более сложные) языки, чем HTML, – это PHP, Ajax, SQL.

Для разработки игр и программ на телефоны используются, в основном, два языка – Java и C++. Про C++ мы уже говорили, а Java является языком программирования, созданным на основе C++.

Для создания 3D игр и фильмов используют язык Python. Он даёт огромнейший спектр возможностей для управления 3D графикой.

Язык Фортран был разработан для сложных математических вычислений, создан в 1954-1957 годах. Слово Fortran произошло от первых букв: FORmula TRANslator, то есть, переводчик формул. Он выполняет математические, инженерные и различные научные задачи и применяется в очень мощных компьютерах.

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

P.S. Статья закончилась, но можно еще прочитать.

Вот мы уже познакомились с устройством компьютера… Но так и не поняли главного – как именно он работает? На каком языке общается с человеком? Как удается ему понимать и обрабатывать столько разной информации – текст, картинки, звуки?

Человеку это удается просто – мы даже не задумываемся, как именно наш мозг справляется со всеми этими видами информации. Но ведь компьютер – не человек. Ни глаз, ни ушей у него нет, нет и мозга – в привычном нам значении этого слова. Думать, рассуждать компьютер не может. А значит, нужно как-то переводить все информацию, которую мы «скармливаем» нашему компьютеру, на понятный ему язык.

А понимает компьютер только один язык – цифровой! А в его азбуке нет букв – одни цифры – не зря же компьютерный язык называют еще и «цифровым». Да и цифр немного – всего две: 0 и 1.

Хорошая азбука, что и говорить! Такую даже первоклассник выучит за секунду… Да только мала - много ли слов составишь из ее «букв»?

Немного. Но для компьютера - вполне достаточно. «Слова» эти, в отличие от человеческого языка, одинаковы по длине, в каждом из них - ровно восемь знаков. И выглядят эти «слова» вот так:
10101000 10001111 10000110

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

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

Почему был выбран именно такой, не самый удобный и практичный «алфавит»? Причина проста: ведь вся информация в компьютере переносится электрическим током - точно так же, как кровь разносит кислород по всему нашему телу. А какой самый простой способ заставить ток передавать информацию? Либо дать ему доступ к какому-то важному участку, либо нет. Если сигнал есть - мы получаем единицу. Нет тока - понятное дело, перед нами ноль. Если бы мы захотели заложить в компьютерный алфавит большее количество сигналов, нам пришлось бы проделывать с электрическим током более сложные операции - например, постоянно менять напряжение. А так все удобно и просто - либо сигнал есть, либо его нет!

Конечно, двоичные числа иногда кажутся громоздкими – например, число 254 в двоичной системе выглядит так:
11111110

Но это только кажется. И вот тебе очень простой, но впечатляющий фокус для ваших знакомых. Как ты думаешь, сколько числе можно показывать с помощью пальцев рук? Тебе кажется – десять? А вот и не угадали: в двоичной системе с помощью десяти пальцев ты сможешь показать 1024 числа – любое число от 0 до 1023!
0 на двоичном языке – это 0000000000
1023 – 1111111111

Нетрудно догадаться, что двоичный «ноль» будет соответствовать согнутому пальцу, а единица-разогнутому!

Точно так же ты сможешь доказать, что число 4 и 100 – это одно и то же. И это правда – если число 4 принадлежит к нашей, десятичной системе, а 100 – к двоичной.

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

• Переменные - в переменной можно хранить и вызывать меняющиеся данные. Переменными можно управлять, у переменных есть типы (очень упрощенно говоря - числа, символы и так далее), которыми и определяется тип хранящихся в переменной данных. Наименования переменных принято задавать такими, чтобы человек, читающий исходный код, мог получить представление о том, что в переменной хранится - так будет проще понять логику работы программы.
• Условные конструкции (они же - условные выражения) - это действие, которые выполняется в том случае, если выражение или конструкция истинно или ложно. Наиболее распространенной формой таких выражений можно назвать конструкцию «If-Then» (если-то). Если выражение истинно (например, если x = 5), то произойдет действие №1, а если ложно (x != 5), то действие №2.
• Функции - в разных языках программирования их называют по-разному: где-то это процедуры, где-то - методы, где-то - вызываемые единицы. По сути же, функции представляют собой мини-программы, входящие в состав большой программы. Функцию можно вызывать несколько раз, что позволяет программисту создавать сложные программы.
• Ввод данных - достаточно широко трактуемое понятие, присутствующее в почти что каждом ЯП. Суть его - обработка данных, введенных пользователем, и их хранение. То, как будут собраны данные, зависит от программы и доступных пользователю способов ввода данных (с клавиатуры, из файла и так далее). Понятие ввода данных тесно связано с понятием вывода данных - то есть того, каким образом данные будут возвращены пользователю (выведены на экран, записаны в файл и так далее).

Установите все необходимое ПО. Многим ЯП нужны компиляторы - программы, переводящие программный код в понятные для компьютера инструкции. Впрочем, есть и ЯП другого типа (вроде Python), в которых программы выполняются сразу, а компиляция их не требуется.

• У некоторых ЯП есть так называемые IDE (Integrated Development Environment, интегрированная среда разработки), в которые входят редактор кода, компилятор/интерпретатор и отладчик (дебаггер). Это дает программисту возможность работать над программой, образно выражаясь, по принципу одного окна. Также в IDE могут входить визуальные представления иерархий объектов и директорий.
• Есть и онлайн-редакторы кода. Эти программы подсвечивают синтаксис программного кода несколько иначе, а также предлагают разработчику доступ к ряду полезных и простых инструментов.

Дополнительно