# data[].attributes.body
Языки высокого уровня удобны для программистов. Их легко писать, отлаживать и поддерживать.
Это машинно-независимый язык.
Легко учиться.
Менее подвержен ошибкам, легко находит и отлаживает ошибки.
Приводит к повышению производительности программирования.

# data[].attributes.body
Программы, разработанные с использованием языков низкого уровня, зависят от машины и не являются переносимыми.
Его сложно разрабатывать, и поддерживать.
Подвержены ошибкам.
Приводит к низкой производительности программирования.
Программист должен обладать дополнительными знаниями компьютерной архитектуры конкретной машины

# data[].attributes.body
Для перевода исходного кода в машинный требуется дополнительное время перевода.
Работают сравнительно медленнее, чем программы низкого уровня.
Менее эффективны в использовании памяти.
Невозможно напрямую взаимодействовать с оборудованием.

# data[].attributes.body
сложны в освоении, нужны хорошие знания ЭВМ, ориентированы на использование в конкретной ЭВМ

# data[].attributes.body
дружелюбный интерфейс по отношению к пользователю.

машинно-независимый код

легко учить

используется англ. яз.

# data[].attributes.body
они мобильные, человекоориентированные, проще в освоении

# data[].attributes.body
1) используется бинарный код/ ассемблей - сложен в освоении
2) программа зависит от машины

# data[].attributes.body
дополнительное время для перевода HLL в LLL

программы высокого уровня грузятся дольше

не взаимодействует с системой напрямую

# data[].attributes.body
Программы низкого уровня более подвержены ошибкам. Они зависят от машины и не переносимы.

# data[].attributes.body
занимает большой объем памяти, необходим компилятор, медленный

# data[].attributes.body
Его сложно разрабатывать, отлаживать и поддерживать и программист должен иметь дополнительные знания об архитектуре компьютера конкретной машины, для программирования на языке низкого уровня

# data[].attributes.body
Языки высокого уровня удобны для программистов. Легко научиться. Это машинно-независимый язык.

# data[].attributes.body
Легко можно освоить и удобно писать отлаживать

# data[].attributes.headline
преимущества ЯП высо

# data[].attributes.body
преимущества ЯП высокого уровня удобны для программистов, легко учить, легко находить ошибки

недостатки
работают медленнее чем программы низкого уровня

# data[].attributes.body
Перевод данного кода в машинный код занимает много времени.
Невозможно связаться напрямую с оборудованием.

# data[].attributes.body
Нет необходимости в каком-либо компиляторе или интерпретаторах для перевода исходного кода в машинный код.

# data[].attributes.body
Эффективный
Может контактировать с оборудованием напрямую

# data[].attributes.body
Быстро и эффективно использует память,
предназначен для взаимодействия с аппаратным устройством, Они в основном используются для разработки операционных систем, драйверов устройств, баз данных и приложений, требующих прямого доступа к оборудованию.

# data[].attributes.headline
ЯП низкого уровня бы

# data[].attributes.body
ЯП низкого уровня быстрые и эффективно используют память. Напрямую связывается с устройствами.

# data[].attributes.body
Не портативные и зависят от машины

# data[].attributes.body
Зависят от машины и не являются переносимыми. Более подвержены ошибкам.

# data[].attributes.body
легкий в освоении
можно выполнять более сложные задачи

# data[].attributes.body
Менее подвержен ошибкам и легко находит и устраняет ошибки. Их легче писать и изучать. Работает быстрее чем коды низкого уровня

# data[].attributes.body
Программы, разработанные с использованием языков низкого уровня, зависят от машины и не переносимы.

# data[].attributes.body
Медленнее чем языки низкого уровняи менее эффективны для памяти

# data[].attributes.body
Зависимые и непереносимые

# data[].attributes.body
быстро и эффективно
нет необходимости в компиляторах и интерпретаторах
может напрямую связываться с аппаратными устройствами

# data[].attributes.headline
Они удобны для прогр

# data[].attributes.body
Они удобны для программистов. Они мобильные, а также проще в освоении. Легко найти ошибки и устранить их.

# data[].attributes.body
Программы низкого уровня сравнительно быстрее, чем программы высокого уровня.

# data[].attributes.body
зависят от машины и не переносимы
низкая производительность программирования

# data[].attributes.body
Работают быстро и эффективно, нет необходимости в компиляторах или интерпретаторах.

# data[].attributes.body
Быстрая и эффективная работа в связи с прямым взаимодействием с памятью и регистрами устройства.
Нет необходимости использовать компиляторы и интерпретаторы, для преобразования исходного кода в машинный код.

# data[].attributes.body
Программы работают быстрее и эффективнее используют память, также не требует никакого компилятора или интерпретатора для работы

# data[].attributes.body
они быстрее ,не нуждаются в компиляторе,они могут напрямую связываться с устройствами

# data[].attributes.body
- быстрее и эффективнее в использовании памяти
- программисты могут лучше использовать процессор и память в работе
- не нужны какие-либо компиляторы или интерпретаторы для перевода исходного кода в машинный
- яп низкого уровн может напрямую взаимодействовать с аппаратными устройствами

# data[].attributes.body
Необходимость иметь дополнительные знания об архитектуре машины для программирования
Зависимость самого кода от машины из чего следует не переносимость самого кода

# data[].attributes.body
Языки программирования низкого уровня более подвержены ошибкам и обычно приводят к низкой производительности программирования.

# data[].attributes.body
легко усвоить,машинно-зависимый язык,легко находит ошибки

# data[].attributes.body
Языки высокого уровня удобны для программистов, т.е. с ними легко работать и писать. Намного легче изучать сам язык и устранять ошибки в коде.

# data[].attributes.body
- удобен для программистов, легко учится
- машино-независимый язык
- легче найти и исправить ошибки в коде
- переносится на другие устройства

# data[].attributes.body
быстрые, эффективные,нет необходимости компиляторах, также напрямую связывается с устройствами

# data[].attributes.body
Удобные, легко писать, легче найти и исправить ошибки в коде

# data[].attributes.body
Требуется высокая квалификация программиста.

# data[].attributes.body
хорошая автоматизация отладки программ позволяет быстро разрабатывать ПО
широкий алфавит языка позволяет понимать сам текст кода, что значительно упрощает задачу

# data[].attributes.body
Программы работают быстро и эффективно
Отпадает необходимость в использовании компиляторов и интерпретаторов
Прямая связь с устройством

# data[].attributes.body
- программы машино-зависимы и не переносятся на другие устройства
- трудно разрабатывать и поддерживать, каждому устройству нужен отдельный код
- подвержен ошибкам

# data[].attributes.body
Программы, написанные на низком уровне, более подвержены ошибкам, из-за чего её сложно поддерживать. Для написания программы требуются дополнительные знания программиста

# data[].attributes.body
не имеет возможность связаться напрямую с оборудованием,не портативны,они также зависят от машины,низкая производительность программирования

# data[].attributes.body
Прямая связь с аппаратными устройствами;
Работают быстро и эффективно используют память;
Нет необходимости в использовании компиляторов для преобразования исходного кода в машинный код.

# data[].attributes.body
Значительный объём памяти, занимаемый программой;
Громоздкость программ

# data[].attributes.body
Не нужен компилятор или интерпритатор для перевода кода, яп низкого уровня напрямую взаимодействуют с аппаратными устройствами, быстрые и эффективные

# data[].attributes.body
высокая скорость и эффективность работы, нет необходимости в компиляторе, напрямую устанавливают связь с устройствами

# data[].attributes.body
- тратится время на компиляцию для перевода кода в машинный
- работает медленнее
- не может напрямую взаимодействовать с аппаратными устройствами
- менее эффективно используют память

# data[].attributes.body
Программы на данном языке медленнее, чем программы на низком уровне ЯП. Обычно не очень эффективно используют память. Также не может связаться напрямую с оборудованием

# data[].attributes.body
Быстрая скорость чтения и эффективность работы. Использует меньше памяти.

# data[].attributes.body
Они зависят от машины и не портативные

# data[].attributes.body
Они являются более быстрыми чем ЯП высокого уровня

# data[].attributes.body
Программы, написанные на языках низкого уровня, работают быстро и эффективно используют память.

# data[].attributes.body
ЯП низкого уровня более быстрее чем ЯП высокого уровня, эффективны для памяти,

# data[].attributes.body
1.  работают быстро и эффективно используют память
2. можно напрямую связаться с аппаратными устройствами
3. нет необходимости в компиляторах или интерпретаторах для преобразования исходного кода в машинный

# data[].attributes.body
Они независимы от машины и портативны

# data[].attributes.body
Они более подвержены ошибкам

# data[].attributes.body
Сложно поддерживать и иногда случается утечка памяти,требуется знания об архитектуре машины

# data[].attributes.body
Прямое управление компьютерными регистрами и хранилищем, быстрая скорость

# data[].attributes.body
ЯП высокого уровня легко выучить,не треубует никаких дополнительных знаний компьютерной архитектуры,независимы от машины и портативны,обеспечивают выскоую абстракцию от оборудования

# data[].attributes.body
неэффективные с точки зрения памяти

# data[].attributes.body
Быстрая скорость, возможность управлять машиной на полную мощность

# data[].attributes.body
Программы написанные на Яп низкого уровня обладают эффективной памятью и являются быстрыми

# data[].attributes.body
1. программы низкого уровня более подвержены ошибкам
2. программисты должны иметь дополнительные знания о структуре компьютера конкретной машины
3. низкая производительность программирования

# data[].attributes.body
ЯП низкого уровня взаимодействует с железом компьютера и нет необходимости использовать интерпретатор

# data[].attributes.body
они сравнительно медленнее, переход исходного кода в машинный код занимает длительное время, менее эффективны для памяти чем ЯП низкого уровня, невозможность напрямую взаймодействовать с оборудованием

# data[].attributes.body
1.При работе с ЯП низкого уровня, высока вероятность наткнутся на "Bug".
2. Нужно хорошее знания структуры/строении самого компьютера.
3. Его нельзя переносить на другие устройства.

# data[].attributes.body
1. легко писать, удобны для программирования
2. менее подвержен ошибкам
3. повышенная производительность программирования

# data[].attributes.body
ЯП низкого уровня трудно выучить, не портативны, не обеспечивают абстракцию от оборудования, более подвержены ошибкам, затрудненное обслуживание, зависят от машины

# data[].attributes.body
1. перевод исходного кода в машинный занимает время
2. нет возможности напрямую связаться с оборудованием
3. менее эффективно используют память

# data[].attributes.body
1. Более легкий к использованию и для обучения.
2. Свободный язык не нужно знак о строении ПК
3. Меньше багов и ошибок во время кодинг.

# data[].attributes.body
Легкий в освоений, быстро находит ошибку. Машинно-независимый код, есть возможность переносить на другие устройства.

# data[].attributes.body
ПРОГРАММЫ написанные на яп низкого уровня часто подвергаются ошибкам

# data[].attributes.body
1. программы написанные на этих языках быстро выполняются и занимают меньше памяти.
2. нет необходимости в компиляторе в переводе исходного кода

# data[].attributes.body
Программы написанные на языке низкого уровня быстры и эффективны.
Нет необходимости в компиляторе или интерпретаторе, это сокращает время
Он может напрямую взаимодействовать с аппаратными устройствами

# data[].attributes.body
Программы, разработанные с использованием языков низкого уровня, работают быстро и эффективно используют память.

# data[].attributes.body
1. Удобны для программистов. Их легко писать, менять код.
2. легко учится.
3. легко находить и изменять ошибки

# data[].attributes.body
зависят от машины и не переносимы, а  также его сложно разрабатывать, отлаживать и поддерживать

# data[].attributes.body
программы разработанные с языком низкого уровня быстро и эффективно используют память

# data[].attributes.body
Программы созданные языком низкого уровня зависимы от машины и не переносимы
Его сложно разрабатывать поддерживать и отлаживать
Программы созданные языком низкого уровня  более подвержены к ошибкам

# data[].attributes.body
Язык программирования низкого уровня напрямую взаимодействует с регистрами и памятью. Язык низкого уровня не требует компилятора или интерпретатора для преобразования исходного кода

# data[].attributes.headline
Недостатки языка высокого уровня Даулет

# data[].attributes.subject
Недостатки языка высокого уровня Даулет

# data[].attributes.body
1.       Перевод исходного кода в машинный код занимает дополнительное время.

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

3.       По сравнению с низкоуровневыми программами они, как правило, менее эффективно используют память.

Невозможно связаться напрямую с оборудованием

# data[].attributes.body
Языки высокого уровня удобны для программистов. легко писать, отлаживать и поддерживать.
машинно-независимый язык..

# data[].attributes.body
Программы, разработанные с использованием языков низкого уровня, зависят от машины и не переносимы.
Его сложно разрабатывать, отлаживать и поддерживать.

# data[].attributes.body
Перевод исходного кода в машинный код занимает дополнительное время.
сравнительно медленнее, чем программы низкого уровня.

# data[].attributes.body
больше подвержены к ошибкам

# data[].attributes.headline
жанеля приемущества

# data[].attributes.subject
жанеля приемущества

# data[].attributes.body
1. Языки высокого уровня удобны для программистов. Их легко писать, отлаживать и поддерживать.

2. Он обеспечивает более высокий уровень абстракции от машинных языков.

# data[].attributes.body
1. сложно разрабатывать, поддерживать.
2. более подвержен к ошибкам

# data[].attributes.body
Программы высокого уровня сравнительно медленнее, чем программы низкого уровня.

# data[].attributes.body
Легко учиться
Машинно независимый
Менее подвержен к ошибкам
Приводит к повышению производительности программирования.

# data[].attributes.body
1. легко научиться писать
2. не зависимы от машины
3. легко устранять ошибки в коде
4. хорошая производительность программирования

# data[].attributes.body
не удаётся связаться напрямую с оборудованием, требуется дополнительное время для перевода исходного кода в машинный код

# data[].attributes.body
Они работают быстро и эффективно используют память. На прямую взаимодействуют с аппаратными устройствами

# data[].attributes.body
1. требует больше времени в переводе исходного кода в машинный
2. сравнительно медленно по сравнению с ЯП низкого уровня

# data[].attributes.body
легко находят и устраняют ошибки