/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function _createMdxContent(props) {
  const _components = Object.assign({
    p: "p",
    h2: "h2",
    a: "a",
    ol: "ol",
    li: "li",
    code: "code",
    pre: "pre",
    strong: "strong",
    ul: "ul"
  }, _provideComponents(), props.components);
  return _jsxs(_Fragment, {
    children: [_jsx(_components.p, {
      children: "Язык программирования по смыслу ничем не отличается от обычного языка общения: английский, русский, китайский и т. д. Назначение обычного языка — передавать информацию от одного человека другому. Программисту же необходимо передать информацию компьютеру."
    }), "\n", _jsxs(_components.h2, {
      id: "как-общаться",
      children: ["Как общаться?", _jsx(_components.a, {
        className: "anchor",
        href: "#как-общаться"
      })]
    }), "\n", _jsx(_components.p, {
      children: "Если надо кому-либо объяснить как сделать что-то мы рассказываем последовательность действий. Хороший пример — рецепт какого-нибудь блюда. Допустим тебе надо научить кого-то делать бутерброд с вареньем, тогда инструкция может выглядеть так:"
    }), "\n", _jsxs(_components.ol, {
      children: ["\n", _jsx(_components.li, {
        children: "Берешь кусочек хлеба"
      }), "\n", _jsx(_components.li, {
        children: "Намазываешь на него любимое варенье"
      }), "\n", _jsx(_components.li, {
        children: "Вуаля бутерброд с вареньем готов!"
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "Но если тебе надо научить компьютер делать бутерброд с вареньем, то все будет «немного» сложнее."
    }), "\n", _jsx(_components.p, {
      children: "Компьютер в отличии от человека не имеет накопленного опыта. «А в чем проблема?» спросишь ты. Проблема в том что компьютер не умеет открывать банки с вареньем или например, не знает что не стоит намазывать варенье ногой. В инструкции опущено очень много деталей которые и так понятны человеку, но компьютер это чистый лист и инструкция для него должна быть очень подробной."
    }), "\n", _jsx(_components.p, {
      children: "Набор инструкций компьютеру называется программой и пишутся эти инструкции на языках программирования."
    }), "\n", _jsxs(_components.h2, {
      id: "инструкции",
      children: ["Инструкции", _jsx(_components.a, {
        className: "anchor",
        href: "#инструкции"
      })]
    }), "\n", _jsxs(_components.p, {
      children: ["На самом низком уровне общение с компьютером ограничивается нулями и единицами — двоичная система или машинный код. Человеку практически невозможно читать код состоящий только из ", _jsx(_components.code, {
        children: "0"
      }), " и ", _jsx(_components.code, {
        children: "1"
      }), ", а писать такой код конечно можно попробовать, но тогда придется заниматься постоянным переводом в двоичный код. Например буква «A» в двоичной системе выглядит как ", _jsx(_components.code, {
        children: "01000001"
      }), ". С таким успехом код, даже небольшой программы, будет занимать сотни строк."]
    }), "\n", _jsx(_components.p, {
      children: "Для более удобного общения с компьютером был придуман язык Assembly. Вот так выглядит код программы которая пишет «Hello world!»"
    }), "\n", _jsx(_components.pre, {
      children: _jsx(_components.code, {
        className: "hljs language-assembly",
        children: "section        .text           \nglobal         _start            \n_start:  \n    mov edx, len   \n    mov ecx, msg   \n    mov ebx, 1  \n    mov eax, 4  \n    int 0x80  \n    mov eax, 1  \n    int 0x80section        .data               \n    msg        db \"Hello world!\", 0xa  \n    len        equ $ -msg\n"
      })
    }), "\n", _jsx(_components.p, {
      children: "Местами даже можно прочитать и понять отдельные слова, но все-таки это довольно близко к машинному коду и писать большие программы будет сложно."
    }), "\n", _jsxs(_components.p, {
      children: ["«Под капотом» у Assembly все те же нули и единицы. Получается как бы язык Assembly поверх бинарного языка. В программировании такое называется ", _jsx(_components.strong, {
        children: "уровнем абстракции"
      }), " языка."]
    }), "\n", _jsx(_components.p, {
      children: "Существует разделение языков программирования по уровню абстракции:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsxs(_components.li, {
        children: [_jsx(_components.strong, {
          children: "Высокоуровневые"
        }), " (Java, Python, Ruby, C# и т. д.)"]
      }), "\n", _jsxs(_components.li, {
        children: [_jsx(_components.strong, {
          children: "Среднеуровневые"
        }), " (С, С++, RUST)"]
      }), "\n", _jsxs(_components.li, {
        children: [_jsx(_components.strong, {
          children: "Низкоуровневые"
        }), " (Forth, CIL, Assembly)"]
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "Чем ближе язык к машинному коду тем он более низкоуровневый."
    }), "\n", _jsxs(_components.h2, {
      id: "перевод-намашинный-язык",
      children: ["Перевод на машинный язык", _jsx(_components.a, {
        className: "anchor",
        href: "#перевод-намашинный-язык"
      })]
    }), "\n", _jsxs(_components.p, {
      children: ["Когда мы общаемся мы переводим наши мысли на язык понятный тому кому необходимо донести информацию. Так же и компьютер использует переводчик — ", _jsx(_components.strong, {
        children: "компилятор"
      }), ", который превращает код написанный человеком в машинный код."]
    }), "\n", _jsxs(_components.p, {
      children: ["Существует и другой способ писать программы — с помощью ", _jsx(_components.strong, {
        children: "интерпретатора"
      }), ". Представь ты отправился в путешествие, но языка не знаешь и в общении тебе помогает переводчик — интерпретирует сказанные тобой слова на нужный язык."]
    }), "\n", _jsx(_components.p, {
      children: "Языки делятся и по способу исполнения их компьютером:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: _jsx(_components.strong, {
          children: "Компилируемые"
        })
      }), "\n", _jsx(_components.li, {
        children: _jsx(_components.strong, {
          children: "Интерпретируемые"
        })
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "Компилируемый язык, это как подготовка тщательно продуманного выступления. Ты пишешь свой текст заранее, редактируешь его, исправляешь ошибки и только после этого выходишь на сцену, чтобы исполнить своё выступление. Твой текст компилируется в специальную форму, которую зрители могут понять и оценить."
    }), "\n", _jsx(_components.p, {
      children: "Теперь представь, что ты даёшь выступление на импровизированной сцене. Ты не знаешь заранее, что скажешь, но ты готов к любому повороту событий. Когда ты выходишь на сцену, зрители слушают тебя и сразу же реагируют на твои слова. В этом случае твои слова аналогичны командам в интерпретируемых языках программирования. Ты даёшь команды (код), и интерпретатор (или ты сам, если ты и есть интерпретатор) сразу же их выполняет, без предварительной компиляции."
    }), "\n", _jsx(_components.p, {
      children: "Таким образом, основное отличие между компилируемыми и интерпретируемыми языками заключается в этапе преобразования и выполнения кода. В компилируемых языках код сначала компилируется в машинный код, а затем выполняется, в то время как в интерпретируемых языках код выполняется непосредственно интерпретатором на ходу."
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, props)
  })) : _createMdxContent(props);
}
return {
  default: MDXContent
};


/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function _createMdxContent(props) {
  const _components = Object.assign({
    p: "p",
    h2: "h2",
    a: "a",
    ul: "ul",
    li: "li",
    ol: "ol",
    h3: "h3",
    code: "code"
  }, _provideComponents(), props.components);
  return _jsxs(_Fragment, {
    children: [_jsx(_components.p, {
      children: "Программа может быть описана как некий набор инструкций, который говорит компьютеру, что делать. Подобно тому как инструкция говорит, что делать в определённой ситуации, программа говорит компьютеру, как выполнять определённую задачу или решать определённую проблему."
    }), "\n", _jsxs(_components.h2, {
      id: "инструкции",
      children: ["Инструкции", _jsx(_components.a, {
        className: "anchor",
        href: "#инструкции"
      })]
    }), "\n", _jsx(_components.p, {
      children: "Набор инструкций в программе это как пошаговый рецепт блюда, но намного подробней. Можно дополнить рецепт бутерброда с вареньем чтобы компьютеру было понятней что необходимо сделать. Вот только некоторые из дополнений:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: "Где найти хлеб и варенье?"
      }), "\n", _jsx(_components.li, {
        children: "Что делать если варенье испортилось?"
      }), "\n", _jsx(_components.li, {
        children: "На какую часть хлеба надо намазывать варенье?"
      }), "\n", _jsx(_components.li, {
        children: "Как понять что варенья достаточно на хлебе?"
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "Как видно из этих вопросов их может быть очень много и абсолютно в разных стилях написаны. Благодаря жизненному опыту человек может понять что фразы «варенье лежит в шкафу» и «варенье хранится в шкафу» одинаковые — человек знает что такое синонимы. Компьютер же обучен ограниченному количеству конструкций, но их достаточно чтобы описать программу абсолютно любой сложности и базовых конструкций всего 6 штук:"
    }), "\n", _jsxs(_components.ol, {
      children: ["\n", _jsx(_components.li, {
        children: "Переменные"
      }), "\n", _jsx(_components.li, {
        children: "Структуры данных"
      }), "\n", _jsx(_components.li, {
        children: "Операторы"
      }), "\n", _jsx(_components.li, {
        children: "Условные выражения"
      }), "\n", _jsx(_components.li, {
        children: "Циклы"
      }), "\n", _jsx(_components.li, {
        children: "Функции"
      }), "\n"]
    }), "\n", _jsxs(_components.h2, {
      id: "конструкции-языка",
      children: ["Конструкции языка", _jsx(_components.a, {
        className: "anchor",
        href: "#конструкции-языка"
      })]
    }), "\n", _jsx(_components.p, {
      children: "Конструкции в языках программирования это основные строительные блоки, из которых составляются программы. Давайте представим, что вы строите что-то с помощью конструктора или строительного набора. Каждый элемент набора выполняет определенную функцию и соединяется с другими элементами для создания конечного продукта."
    }), "\n", _jsxs(_components.h3, {
      id: "переменные",
      children: ["Переменные", _jsx(_components.a, {
        className: "anchor",
        href: "#переменные"
      })]
    }), "\n", _jsx(_components.p, {
      children: "Можно представить переменные как определенное место на складе, где хранится какая-нибудь вещь. Каждое место на складе имеет свое название или номер. Ты можешь положить на это место что угодно и запомнив название места вернуться к нему позже и то что ты там оставил все еще будет там лежать."
    }), "\n", _jsxs(_components.h3, {
      id: "структуры-данных",
      children: ["Структуры данных", _jsx(_components.a, {
        className: "anchor",
        href: "#структуры-данных"
      })]
    }), "\n", _jsx(_components.p, {
      children: "Структуры данных похожи на переменные, но это более организованный, специализированный способ хранения данных. Если переменная это место на складе, то структура данных это как небольшой склад для похожих данных и инструментов работы с ними. Например, кухня это структура данных — в ней хранятся продукты и инструменты для готовки."
    }), "\n", _jsxs(_components.h3, {
      id: "операторы",
      children: ["Операторы", _jsx(_components.a, {
        className: "anchor",
        href: "#операторы"
      })]
    }), "\n", _jsx(_components.p, {
      children: "Операторы похожи на действия которые мы применяем к вещам в повседневной жизни. Например, намазать варенье на хлеб или проверить что варенье не испортилось. В программировании это обычно символ или слово которое используется для выполнения определенных действий над данными."
    }), "\n", _jsxs(_components.h3, {
      id: "условные-выражения",
      children: ["Условные выражения", _jsx(_components.a, {
        className: "anchor",
        href: "#условные-выражения"
      })]
    }), "\n", _jsxs(_components.p, {
      children: ["Эти конструкции применяются когда программе надо принять решение в зависимости от ситуации — ответить на вопрос. Это развилка в коде позволяет подстраиваться программе под различные ситуации. Компьютер понимает только вопросы на которые можно ответить «да» — ", _jsx(_components.code, {
        children: "1"
      }), "  или «нет» — ", _jsx(_components.code, {
        children: "0"
      }), "."]
    }), "\n", _jsxs(_components.h3, {
      id: "циклы",
      children: ["Циклы", _jsx(_components.a, {
        className: "anchor",
        href: "#циклы"
      })]
    }), "\n", _jsx(_components.p, {
      children: "Циклы похожи на механизм, который повторяет определённые действия несколько раз. Это как если бы вы делали одно и то же действие снова и снова, пока не выполнится определённое условие. Например, намазывать варенье на хлеб пока не будет «достаточно»"
    }), "\n", _jsxs(_components.h3, {
      id: "функции",
      children: ["Функции", _jsx(_components.a, {
        className: "anchor",
        href: "#функции"
      })]
    }), "\n", _jsx(_components.p, {
      children: "Функция это сохраненный набор инструкций который можно применить в разных ситуациях. Например, у тебя есть готовая инструкция как сходить в магазин и купить какой-нибудь продукт — «Сходить в магазин за ...». Она знает как добраться до магазина, как найти товар, как оплатить его и принести домой. Таким образом можно отправить компьютер в магазин если в процессе приготовления бутерброда он не нашел хлеб или варенье — не надо будет каждый расписывать как сходить в магазин за хлеб и как сходить за вареньем, вместо этого можно просто написать «Сходить в магазин за хлебом» или «Сходить в магазин за вареньем»."
    }), "\n", _jsx(_components.p, {
      children: "Используя эти базовые конструкции можно объяснить компьютеру как сделать все что угодно."
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, props)
  })) : _createMdxContent(props);
}
return {
  default: MDXContent
};


/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const {useMDXComponents: _provideComponents} = arguments[0];
function _createMdxContent(props) {
  const _components = Object.assign({
    p: "p",
    h2: "h2",
    a: "a",
    table: "table",
    thead: "thead",
    tr: "tr",
    th: "th",
    tbody: "tbody",
    td: "td",
    img: "img",
    strong: "strong",
    ul: "ul",
    li: "li"
  }, _provideComponents(), props.components);
  return _jsxs(_Fragment, {
    children: [_jsx(_components.p, {
      children: "Схема программы играет довольно важную роль в процессе ее создания, особенно когда ты вообще не знаком с языками программирования."
    }), "\n", _jsx(_components.p, {
      children: "Представь, что ты планируешь построить дом. Прежде чем начать строить, тебе нужно сделать план, правильно? Ты рисуешь чертежи, на которых показано, как будет выглядеть дом снаружи и внутри, где будут окна, двери, комнаты и т. д. Эти чертежи помогают тебе понять, какие материалы и инструменты понадобятся, и как строить дом."
    }), "\n", _jsx(_components.p, {
      children: "Точно так же и с программированием. Схемы — это своего рода чертежи для программ. Они помогают разработчикам понять, как будет работать программа, какие части она будет содержать и как они будут взаимодействовать друг с другом."
    }), "\n", _jsx(_components.p, {
      children: "Преимущество схем в том что они универсальны. Чтобы нарисовать схему программы не обязательно знать языки программирования. Схема это цепочка действий, написанных на обычном языке."
    }), "\n", _jsx(_components.p, {
      children: "На этапе проектирования программы можно избавиться от большего количества проблем и ошибок. Потому что, рисуя схему ты думаешь только над решением задачи, а не занимаешься проблемами связанными с языком программирования. При чем новичкам в программировании может быть и не сразу понятно: программа не работает потому что ошибка в логике или ошибка коде."
    }), "\n", _jsxs(_components.h2, {
      id: "создание-схемы",
      children: ["Создание схемы", _jsx(_components.a, {
        className: "anchor",
        href: "#создание-схемы"
      })]
    }), "\n", _jsxs(_components.p, {
      children: ["Существует несколько видов схем которые используются для проектирования программ. Самым удобным и одновременно простым способом являются ", _jsx(_components.a, {
        href: "https://en.wikipedia.org/wiki/Flowchart",
        children: "блок-схемы"
      }), ". Для создания схемы нужно знать всего лишь несколько блоков."]
    }), "\n", _jsxs(_components.table, {
      children: [_jsx(_components.thead, {
        children: _jsxs(_components.tr, {
          children: [_jsx(_components.th, {
            children: "Блок"
          }), _jsx(_components.th, {
            children: "Описание"
          })]
        })
      }), _jsxs(_components.tbody, {
        children: [_jsxs(_components.tr, {
          children: [_jsx(_components.td, {
            children: _jsx(_components.img, {
              src: "/schemas/flowchart.termination.excalidraw.svg",
              alt: ""
            })
          }), _jsxs(_components.td, {
            children: [_jsx(_components.strong, {
              children: "Начало/Конец"
            }), _jsx("br", {}), "Обозначает начало и конец алгоритма соответственно. Начало обычно одно, а точек выхода алгоритма может быть несколько — удачное завершение или например алгоритм завершился с ошибкой."]
          })]
        }), _jsxs(_components.tr, {
          children: [_jsx(_components.td, {
            children: _jsx(_components.img, {
              src: "/schemas/flowchart.action.excalidraw.svg",
              alt: ""
            })
          }), _jsxs(_components.td, {
            children: [_jsx(_components.strong, {
              children: "Действие"
            }), _jsx("br", {}), "Представляет операции или действия, которые выполняются в алгоритме."]
          })]
        }), _jsxs(_components.tr, {
          children: [_jsx(_components.td, {
            children: _jsx(_components.img, {
              src: "/schemas/flowchart.io.excalidraw.svg",
              alt: ""
            })
          }), _jsxs(_components.td, {
            children: [_jsx(_components.strong, {
              children: "Ввод-вывод данных"
            }), _jsx("br", {}), "Операция ввода может запросить у пользователя какие-то данные, а операция вывода может отобразить юзеру любую необходимую информацию."]
          })]
        }), _jsxs(_components.tr, {
          children: [_jsx(_components.td, {
            children: _jsx(_components.img, {
              src: "/schemas/flowchart.decision.excalidraw.svg",
              alt: ""
            })
          }), _jsxs(_components.td, {
            children: [_jsx(_components.strong, {
              children: "Решение (условие)"
            }), _jsx("br", {}), "Блок представляет точку принятия решения в алгоритме, где выполняется проверка условия. В зависимости от результата проверки алгоритм может принять разные пути выполнения."]
          })]
        })]
      })]
    }), "\n", _jsx(_components.p, {
      children: "Ну и чтобы сразу разобраться как их применять можно взглянуть на блок-схему бутерброда с вареньем."
    }), "\n", _jsx(_components.img, {
      src: "/schemas/toast-scheme.excalidraw.svg",
      alt: ""
    }), "\n", _jsxs(_components.h2, {
      id: "практика",
      children: ["Практика", _jsx(_components.a, {
        className: "anchor",
        href: "#практика"
      })]
    }), "\n", _jsx(_components.p, {
      children: "Задачки для практики можно найти на любом сайте с челенджами по коду. Вот только некоторые из них:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: _jsx(_components.a, {
          href: "https://leetcode.com/",
          children: "Leetcode"
        })
      }), "\n", _jsx(_components.li, {
        children: _jsx(_components.a, {
          href: "https://www.codewars.com/",
          children: "Codewars"
        })
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "Заходишь на любой такой сайт, выбираешь простые задачи и не важно на каком языке программирования. Но важно чтобы задачка была логическая — чтобы ее можно было решить без использования компьютера."
    }), "\n", _jsx(_components.p, {
      children: "Несколько подходящих задач:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: _jsx(_components.a, {
          href: "https://leetcode.com/problems/find-the-maximum-achievable-number/description/",
          children: "Найти максимальное достижимое число"
        })
      }), "\n", _jsx(_components.li, {
        children: _jsx(_components.a, {
          href: "https://leetcode.com/problems/convert-the-temperature/description/",
          children: "Конвертер температуры"
        })
      }), "\n", _jsx(_components.li, {
        children: _jsx(_components.a, {
          href: "https://www.codewars.com/kata/53da3dbb4a5168369a0000fe",
          children: "Четное или нечетное"
        })
      }), "\n", _jsx(_components.li, {
        children: _jsx(_components.a, {
          href: "https://www.codewars.com/kata/5a3fe3dde1ce0e8ed6000097",
          children: "Определить век по году"
        })
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "В качестве проверки можно использовать тестовые данные которые предлагаются на страничке челенджа. Если применив различные входные параметры из задачки в твоей схеме не остается пробелов и процесс идет по задуманному пути, можно поздравить себя с успешным решением задачи."
    }), "\n", _jsx(_components.p, {
      children: "Для визуализации схем существуют хорошие инструменты:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsxs(_components.li, {
        children: [_jsx(_components.a, {
          href: "https://www.figma.com/figjam/",
          children: "Figma Jam"
        }), " — мой фаворит"]
      }), "\n", _jsx(_components.li, {
        children: _jsx(_components.a, {
          href: "https://miro.com/",
          children: "Miro"
        })
      }), "\n", _jsx(_components.li, {
        children: _jsx(_components.a, {
          href: "https://draw.io",
          children: "draw.io"
        })
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "В общем, схемы помогают разработчикам лучше понять задачу, разбить её на более мелкие части и представить, как эти части будут работать вместе, что помогает нам написать более эффективный и структурированный код. Имея практику в рисовании таких схем, гораздо проще писать программы. Когда схемы будут даваться легко, уже не понадобится их рисовать каждый раз перед тем как писать программу — схема будет сама вырисовываться у тебя в голове и останется ее только закодить."
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = Object.assign({}, _provideComponents(), props.components);
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, props)
  })) : _createMdxContent(props);
}
return {
  default: MDXContent
};


Введение