Что такое программирование снизу вверх сверху вниз?

13 ответов на вопрос “Что такое программирование снизу вверх сверху вниз?”

  1. Flamehunter Ответить

    ПРОГРАММИРОВАНИЕ СВЕРХУ ВНИЗ И СНИЗУ ВВЕРХ
    Программирование сверху вниз представляет собой способ реализации и тестирования в иерархической последовательности, начиная с модулей, требования к которым вытекают из требований к программе в целом.
    Программирование снизу вверх ? это способ реализации и тестирования в обратной иерархической последовательности, начиная с модулей нижайшего уровня, которые по предъявляемым к ним требованиям дальше всего отстоят от программы в целом.
    Сторонники метода сверху вниз считают, что их подход более естественный, дает возможность руководству лучше оценивать состояние работ и зачастую исключает болезненный процесс объединения модулей, необходимый при разработке снизу вверх.
    Сторонники же метода снизу вверх утверждают, что их подход ведет к более основательной отладке модулей и лучшему выделению и использованию стандартных модулей, а также облегчает комплектацию штата программистов.
    Чтобы понять процессы программирования сверху вниз и снизу вверх, программу следует рассматривать как структуру из модулей в виде дерева или сети с верхним уровнем, содержащим управляющие элементы, в соответствии с заданными требованиями. Обычно структура расширяется книзу по мере того, как управляющий модуль вызывает подчиненные функции, которые в свою очередь вызывают следующие функции.
    Программирование сверху вниз начинается с самого высокого уровня, затем разрабатывается следующий уровень и объединяется в единую программу путем тестирования и т.д. до тех пор, пока не будет достигнут низ структуры. Каждый незапрограммированный модуль заменяется при сборке “заглушкой”, которая удовлетворяет требованиям интерфейса, но не выполняет его функций или выполняет их частично. Заглушки заменяются или дорабатываются до настоящих модулей в соответствии с планом программирования. На каждой стадии процесса реализации уже созданная программа должна правильно функционировать по отношению к более низкому уровню.
    Программирование снизу вверх начинается с модулей самого низкого уровня. Отладка обычно ведется с помощью специальных отладочных программ ? от отдельных блоков самого низкого уровня до полного набора блоков.
    Возможность исключения из процесса разработки программы фазы объединения компонент делает программирование сверху вниз привлекательным с точки зрения надежности. Поскольку каждая часть программы тестируется по мере ее включения в целое, то полностью реализованная программа является уже и полностью оттестированной. Такой способ объединения позволяет на каждом шаге иметь обозримую программу. Ошибки и несоответствия ее отдельных частей выявляются и устраняются на ранних стадиях программирования.
    Метод снизу вверх использует уже освоенные способы тестирования. Метод сверху вниз как более новый не так хорошо изучен. Его применение позволяет уменьшить стоимость разработки и повысить надежность программы, зато метод снизу вверх исключает риск.
    Оба метода требуют от пользователей соблюдения особой осторожности: при использовании метода снизу вверх необходимо все время помнить об общих целях проекта, а при использовании метода сверху вниз ? добиваться уяснения правил взаимодействия между модулями до начала кодирования. Невыполнение этих требований в обоих случаях может привести к серьезным нарушениям проекта в ходе реализации,
    Практическое использование методов программирования сверху вниз и снизу вверх
    Метод программирования снизу вверх является известным и общепризнанным, в то время как метод программирования сверху вниз ? относительно новый. Первые упоминания о нем в литературе появились около 10 лет назад; тогда его называли “программированием приращениями”. До создания методов структурного программирования этому методу уделялось мало внимания. Да и сейчас он нечасто используется на практике. Это объясняется, скорее, его новизной, чем какими-либо изъянами в концепции. Однако программирование сверху вниз требует новой технологии и методов управления, и поэтому его применение тормозится инерционностью более, чем другие аспекты структурного программирования.
    Решение этой проблемы может быть компромиссным. Метод сверху вниз представляет большой интерес при объединении в единое целое, а метод снизу вверх ? при разработке общих хорошо отлаженных блоков. Иными словами, оба метода можно применять одновременно. В таких случаях первый шаг разработки программы заключается в создании общей логической структуры, а затем общих блоков низкого уровня, которые наиболее часто используются, после чего применяется метод сверху вниз. Уровни написания программ и доработки спускаются сверху, но новые блоки добавляются по мере необходимости. Зтот компромисс дает лучший результат, чем каждый метод в отдельности.
    Проектирование сверху вниз – Обзор
    При проектировании сверху вниз один или больше элементов детали определяются элементом сборки, например, компоновочным эскизом или геометрией другой детали. Замысел проекта (размеры элементов, размещение компонентов в сборке, расположение по отношению в другим деталям, етс.) отталкивается от верхнего уровня (сборка) и двигается вниз (к деталям), что обуславливает название “сверху вниз”.
    Например, при создании болта на пластмассовой детали с использованием команды Вытянуть Вы можете выбрать параметр До поверхности и выбрать дно печатной платы (другая деталь). Такой выбор позволит сделать установочный болт достаточной длины, чтобы он достал до печатной платы, даже если плата будет перемещена в будущей версии сборки. Таким образом, длина болта определяется сборкой, а не статическим размером детали.
    Методы
    Вы можете использовать все или некоторые методы проектирования сверху вниз:
    Отдельные элементы могут быть спроектированы сверху вниз путем ссылок на другие детали в сборке, как в случае с установочным болтом, описанном выше. При проектировании снизу вверх деталь строится в отдельном окне, где отображается только она. Однако, программа SolidWorks позволяет вам редактировать детали во время работы в окне сборки. Это делает геометрию всех других компонентов сборки доступными для создания ссылки (например, копирование или создание размера по отношению к). Такой метод полезен для работы с деталями, которые в основном статичны, но имеют некоторые элементы, связанные с другими компонентами сборки.
    Целые детали могут быть построены с использованием метода сверху вниз путем cоздания новых компонентов в контексте сборки. Созданные компоненты прикреплены (сопряжены) к другим существующим компонентам сборки. Геометрия созданного вами компонента базирована на существующем компоненте. Этот метод полезен для таких деталей как кронштейны и арматура, которые часто в большей степени или полностью зависимы от других деталей, которые определяют из форму и размер.
    Сборка полностью может быть спроектирована сверху вниз путем создания компоновочного эскиза, который определяет размещение компонентов, ключевые размеры и т.д. Затем создаются трехмерные детали с использованием одного из вышеперечисленных методов таким образом, что трехмерные детали следуют эскизу в из размерах и местоположению. Скорость и гибкость эскиза позволяет вам быстро проверить несколько версий проекта перед построением трехмерной геометрии. Даже после построения трехмерной геометрии, эскиз позволяет вам сделать большое количество изменений в одном центральном месторасположении.

  2. Malolace Ответить

    При
    создании средних по размеру приложений
    (несколько тысяч строк исходного кода)
    используется структурное
    программирование    ,
    идея которого заключается в том, что
    структура программы должна отражать
    структуру решаемой задачи, чтобы
    алгоритм решения был ясно виден из
    исходного текста. Для этого надо иметь
    средства для создания программы не
    только с помощью трех простых операторов,
    но и с помощью средств, более точно
    отражающих конкретную структуру
    алгоритма. С этой целью в программирование
    введено понятие подпрограммы
    – набора операторов, выполняющих
    нужное действие и не зависящих от
    других частей исходного кода. Программа
    разбивается на множество мелких
    подпрограмм, каждая из которых выполняет
    одно из действий, предусмотренных
    исходным заданием. Комбинируя эти
    подпрограммы, удается формировать
    итоговый алгоритм уже не из простых
    операторов, а из законченных блоков
    кода, имеющих определенную смысловую
    нагрузку, причем обращаться к таким
    блокам можно по названиям.
    Идеи
    структурного программирования
    появились в начале
    70-годов     в
    компании IBM, в их разработке участвовали
    известные ученые Э.
    Дейкстра, Х. Милс, Э. Кнут, С. Хоор.
    Структурное
    программирование основано на модульной
    структуре программного продукта и
    типовых управляющих
    структурах
    алгоритмов обработки данных различных
    программных модулей.
    Типы
    управляющих структур:
    –
    последовательность;
    –
    альтернатива
    (условие выбора);
    –
    цикл.
    Распространены
    две методики (стратегии) разработки
    программ, относящиеся к структурному
    программированию:
    –
    программирование
    «сверху вниз»;
    –
    программирование
    «снизу вверх».
    Программирование
    «сверху вниз», или нисходящее
    программирование –     это
    методика разработки программ, при
    которой разработка начинается с
    определения целей решения проблемы,
    после чего идет последовательная
    детализация, заканчивающаяся детальной
    программой.
    Сначала
    выделяется несколько подпрограмм,
    решающих самые глобальные задачи
    (например, инициализация данных,
    главная часть и завершение), потом
    каждый из этих модулей детализируется
    на более низком уровне, разбиваясь в
    свою очередь на небольшое число других
    подпрограмм, и так происходит до тех
    пор, пока вся задача не окажется
    реализованной.
    В
    данном случае программа конструируется
    иерархически – сверху вниз: от главной
    программы к подпрограммам самого
    нижнего уровня, причем на каждом уровне
    используются только простые
    последовательности инструкций, циклы
    и условные разветвления.
    Такой
    подход удобен тем, что позволяет
    человеку постоянно мыслить на предметном
    уровне, не опускаясь до конкретных
    операторов и переменных. Кроме того,
    появляется возможность некоторые
    подпрограммы не реализовывать сразу,
    а временно откладывать, пока не будут
    закончены другие части. Например, если
    имеется необходимость вычисления
    сложной математической функции, то
    выделяется отдельная подпрограмма
    такого вычисления, но реализуется она
    временно одним оператором, который
    просто присваивает заранее выбранное
    значение (например, 5). Когда все
    приложение будет написано и отлажено,
    тогда можно приступить к реализации
    этой функции.
    Программирование
    «снизу вверх», или восходящее
    программирование     –
    это методика разработки программ,
    начинающаяся с разработки подпрограмм
    (процедур, функций), в то время когда
    проработка общей схемы не закончилась.
    Такая
    методика является менее предпочтительной
    по сравнению с нисходящим программированием
    так как часто приводит к нежелательным
    результатам, переделкам и увеличению
    времени разработки.
    Очень
    важная характеристика подпрограмм
    – это возможность их повторного
    использования. С интегрированными
    системами программирования поставляются
    большие библиотеки стандартных
    подпрограмм, которые позволяют
    значительно повысить производительность
    труда за счет использования чужой
    работы по созданию часто применяемых
    подпрограмм.
    Подпрограммы
    бывают двух видов – процедуры
    и функции.
    Отличаются они тем, что процедура
    просто выполняет группу операторов,
    а функция вдобавок вычисляет некоторое
    значение и передает его обратно в
    главную программу (возвращает значение).
    Это значение имеет определенный тип.
    Чтобы
    работа подпрограммы имела смысл, ей
    надо получить данные из внешней
    программы, которая эту подпрограмму
    вызывает. Данные передаются подпрограмме
    в виде параметров или аргументов,
    которые обычно описываются в ее
    заголовке так же, как переменные.
    Подпрограммы
    вызываются, как правило, путем простой
    записи их названия с нужными параметрами.
    Подпрограммы
    активизируются только в момент их
    вызова. Операторы. Которые находятся
    внутри подпрограммы, выполняются,
    только если эта подпрограмма явно
    вызвана.
    Подпрограммы
    могут быть вложенными     –
    допускается вызов подпрограммы не
    только из главной программ, но и из
    любых других программ.
    В
    некоторых языках программирования
    допускается вызов подпрограммы из
    себя самой. Такой прием называется
    рекурсией
    и опасен тем, что может привести к
    зацикливанию – бесконечному
    самовызову    .
    Достоинства
    структурного программирования:
    –
    повышается
    надежность программ (благодаря хорошему
    структурированию при проектировании,
    программа легко поддается тестированию
    и не создает проблем при отладке);
    –
    повышается
    эффективность программ (структурирование
    программы позволяет легко находить
    и корректировать ошибки, а отдельные
    подпрограммы можно переделывать
    (модифицировать) независимо от других);
    –
    уменьшается
    время и стоимость программной
    разработки;
    –
    улучшается
    читабельность программ.
    Таким
    образом, технология структурного
    программирования при разработке
    серьезных программных комплексов,
    основана на следующих принципах:
    –
    программирование
    должно осуществляться сверху вниз;
    –
    весь проект
    должен быть разбит на модули
    (подпрограммы) с одним входом и одним
    выходом;
    –
    подпрограмма
    должна допускать только три основные
    структуры – последовательное
    выполнение, ветвление (if, case) и повторение
    (for, while, repeat).
    –
    недопустим
    оператор передачи управления в любую
    точку программы (goto);
    –
    документация
    должна создаваться одновременно с
    программированием в виде комментариев
    к программе.
    Структурное
    программирование эффективно используется
    для решения различных математических
    задач, имеющих алгоритмический характер

  3. Сын виликого Отца Ответить

    rev4: очень красноречивый комментарий пользователя Sammaron отметил, что, возможно, этот ответ ранее путал сверху вниз и снизу вверх. Хотя первоначально в этом ответе (rev3) и других ответах говорилось, что “снизу вверх – это запоминание” (“примите подзадачи”), он может быть обратным (то есть “сверху вниз” может означать “принять подзадачи” и ” снизу вверх “может быть” составить подзадачи “). Ранее я читал о запоминании как о другом типе динамического программирования, в отличие от подтипа динамического программирования. Я цитировал эту точку зрения, несмотря на то, что не подписывался на нее. Я переписал этот ответ, чтобы быть независимым от терминологии, пока в литературе не будут найдены надлежащие ссылки. Я также преобразовал этот ответ в вики сообщества. Пожалуйста, предпочитайте академические источники. Список литературы: {Интернет: 1, 2 } {Литература: 5 }

    резюмировать

    Динамическое программирование – это все, чтобы упорядочить ваши вычисления таким образом, чтобы избежать пересчета дублирующейся работы. У вас есть основная проблема (корень вашего дерева подзадач) и подзадачи (поддеревья). Подзадачи обычно повторяются и перекрываются.
    Например, рассмотрим ваш любимый пример Фибоначчи. Это полное дерево подзадач, если мы сделали наивный рекурсивный вызов:
    TOP of the tree
    fib(4)
    fib(3)…………………. + fib(2)
    fib(2)……… + fib(1) fib(1)……….. + fib(0)
    fib(1) + fib(0) fib(1) fib(1) fib(0)
    fib(1) fib(0)
    BOTTOM of the tree
    (В некоторых других редких проблемах это дерево может быть бесконечным в некоторых ветвях, что означает отсутствие завершения, и, следовательно, нижняя часть дерева может быть бесконечно большой. Более того, в некоторых задачах вы можете не знать, как выглядит полное дерево впереди. время. Таким образом, вам может понадобиться стратегия/алгоритм, чтобы решить, какие подзадачи выявить.)

    Мемоизация, табуляция

    Существует как минимум два основных метода динамического программирования, которые не являются взаимоисключающими:
    Заметка – это подход laissez-faire: вы предполагаете, что вы уже вычислили все подзадачи и не знаете, каков оптимальный порядок оценки. Как правило, вы выполняете рекурсивный вызов (или некоторый итерационный эквивалент) из корня и либо надеетесь, что вы приблизитесь к оптимальному порядку оценки, либо получите доказательство того, что вы поможете достичь оптимального порядка оценки. Вы должны убедиться, что рекурсивный вызов никогда не пересчитывает подзадачу, потому что вы кэшируете результаты, и, таким образом, дублированные поддеревья не пересчитываются.
    пример: если вы вычисляете последовательность Фибоначчи fib(100), вы бы просто назвали это, и это вызвало бы fib(100)=fib(99)+fib(98), что вызвало бы fib(99)=fib(98)+fib(97) ,… и т.д., fib(99)=fib(98)+fib(97) будет называть fib(2)=fib(1)+fib(0)=1+0=1. Тогда он, наконец, разрешит fib(3)=fib(2)+fib(1), но ему не нужно пересчитывать fib(2), потому что мы его кешируем.
    Это начинается в верхней части дерева и оценивает подзадачи от листьев/поддеревьев назад к корню.
    Табулирование – Вы также можете думать о динамическом программировании как о алгоритме “заполнения таблицы” (хотя, как правило, многомерный, эта “таблица” может иметь неевклидову геометрию в очень редких случаях *). Это похоже на запоминание, но более активное и включает в себя еще один шаг: вы должны заблаговременно выбрать точный порядок, в котором вы будете выполнять вычисления. Это не должно означать, что порядок должен быть статическим, но что у вас гораздо больше гибкости, чем при запоминании.
    пример: если вы выполняете Фибоначчи, вы можете рассчитать числа в следующем порядке: fib(2), fib(3), fib(4)… кэшировать каждое значение, чтобы вам было легче вычислять следующие. Вы также можете думать об этом как о заполнении таблицы (еще одна форма кэширования).
    Лично я не часто слышу слово “табуляция”, но это очень приличный термин. Некоторые люди считают это “динамическим программированием”.
    Перед запуском алгоритма программист рассматривает все дерево, а затем пишет алгоритм для оценки подзадач в определенном порядке по направлению к корню, обычно заполняя таблицу.
    * сноска: иногда “таблица” не является прямоугольной таблицей с сетчатым соединением, как таковым. Скорее, он может иметь более сложную структуру, такую как дерево, или структуру, специфичную для проблемной области (например, города в пределах расстояния полета на карте), или даже решетчатую диаграмму, которая, хотя и имеет вид сетки, не имеет структура соединения “вверх-вниз-влево-вправо” и т.д. Например, пользователь 3290797 связал пример динамического программирования нахождения максимального независимого набора в дереве, который соответствует заполнению пробелов в дереве.
    (В самом общем смысле, в парадигме “динамического программирования”, я бы сказал, что программист рассматривает все дерево, а затем пишет алгоритм, который реализует стратегию для оценки подзадач, которая может оптимизировать любые свойства, которые вы хотите (обычно сочетание сложности времени). и сложность пространства.) Ваша стратегия должна начинаться где-то с некоторой конкретной подзадачи и, возможно, может адаптироваться на основе результатов этих оценок. В общем смысле “динамического программирования” вы можете попытаться кэшировать эти подзадачи и многое другое. как правило, старайтесь не пересматривать подзадачи с тонким отличием, возможно, в случае графов в различных структурах данных. Очень часто эти структуры данных по своей сути похожи на массивы или таблицы. Решения подзадач могут быть выброшены, если они нам не нужны больше.)
    [Ранее этот ответ сделал выражение о терминологии “сверху вниз” и “снизу вверх”; ясно, что есть два основных подхода, называемых Мемоизация и табуляция, которые могут быть в биографии с этими терминами (хотя и не полностью). Общий термин, который используют большинство людей, – это “Динамическое программирование”, а некоторые говорят “Мемоизация” для обозначения этого конкретного подтипа “Динамическое программирование”. В этом ответе отказывается указывать, что является “сверху вниз” и “снизу вверх”, пока сообщество не сможет найти надлежащие ссылки в научных статьях. В конечном счете, важно понимать различие, а не терминологию.]

    Плюсы и минусы

    Простота кодирования

    Memoization очень легко закодировать (обычно вы можете * написать аннотацию “memoizer” или функцию-обертку, которая автоматически сделает это за вас), и она должна быть вашей первой линией подхода. Недостатком табуляции является то, что вы должны придумать порядок.
    * (это на самом деле легко, только если вы пишете функцию самостоятельно и/или пишете на нечистом/нефункциональном языке программирования… например, если кто-то уже написал предварительно скомпилированную функцию fib, она обязательно делает рекурсивные вызовы сама себе, и вы не можете волшебным образом запоминать функцию, не гарантируя, что эти рекурсивные вызовы вызовут вашу новую запомненную функцию (а не оригинальную неметизированную функцию))

    Рекурсивность

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

    Практические проблемы

    В случае с мемоизацией, если дерево очень глубокое (например, fib(10^6)), вам не хватит места в стеке, потому что каждое отложенное вычисление должно быть помещено в стек, и у вас будет 10 ^ 6 из них.

    Оптимальность

    Любой подход может не быть оптимальным по времени, если порядок, в котором вы выполняете (или пытаетесь) посещать подзадачи, не является оптимальным, в частности, если существует несколько способов вычисления подзадачи (обычно это разрешает кэширование, но теоретически возможно, что кэширование может не в некоторых экзотических случаях). Мемоизация, как правило, добавляет сложность времени к сложности пространства (например, при табулировании у вас больше свободы в отбрасывании вычислений, например, при использовании табуляции в Fib позволяет использовать пространство O (1), но при запоминании в Fib используется O (N). пространство стека).

    Расширенные оптимизации

    Если вы также решаете чрезвычайно сложные проблемы, у вас может не быть иного выбора, кроме как выполнять табулирование (или, по крайней мере, играть более активную роль в управлении напоминанием, куда вы хотите его направить). Кроме того, если вы находитесь в ситуации, когда оптимизация абсолютно необходима, и вы должны оптимизировать, табулирование позволит вам выполнить оптимизацию, которую в противном случае запоминание не позволило бы вам сделать разумным способом. По моему скромному мнению, в обычной разработке программного обеспечения ни один из этих двух случаев никогда не встречался, поэтому я бы просто использовал памятку (“функция, которая кэширует свои ответы”), если что-то (например, пространство стека) не делает необходимым табулирование… хотя Технически, чтобы избежать выброса стека, вы можете: 1) увеличить предельный размер стека в языках, которые позволяют это, или 2) потреблять постоянный фактор дополнительной работы для виртуализации вашего стека (ick), или 3) программы в стиле передачи продолжения, который в действительности также виртуализирует ваш стек (не уверен, что это сложно, но в основном вы будете эффективно извлекать цепочку отложенных вызовов из стека размера N и фактически вставлять ее в N последовательных вложенных функций thunk… хотя в некоторых языках без Оптимизация хвостовых вызовов: вам может потребоваться батут, чтобы избежать выброса из стека).

    Более сложные примеры

    Здесь мы перечислили примеры, представляющие особый интерес, которые представляют собой не только общие проблемы DP, но и интересно различают запоминание и табулирование. Например, одна формулировка может быть намного проще, чем другая, или может быть оптимизация, которая в основном требует табуляции:
    алгоритм вычисления расстояния редактирования [ 4 ], интересный как нетривиальный пример двумерного алгоритма заполнения таблиц

  4. Morarad Ответить

    Самостоятельная работа:
    Алгоритм задачи представляется только как композиция трёх базовых типов алгоритмов: линейных, ветвлений и циклов. Эти конструкции могут быть соединены или вложены друг в друга произвольным образом, но никаких других способов управления последовательностью выполнения операций не используется.
    В алгоритме задачи выделяются модули. Модуль – это либо логически законченный фрагмент общей задачи, либо часто повторяющийся блок расчётов.
    Каждый модуль оформляется по определённым правилам в виде подпрограммы, и в текст основного алгоритма вместо него вставляется короткая инструкция вызова подпрограммы. Когда выполнение программы доходит до этой инструкции, выполняется фрагмент, заложенный в подпрограмму, после чего управление передаётся на команду, следующую за инструкцией вызова подпрограммы.
    Различают подпрограммы функции (используется как операнд в выражениях) и процедуры (используется как оператор). Общий вид подпрограммы:
    Заголовок: Имя и Формальные параметры
    Тело подпрограммы
    Признак окончания подпрограммы
    В инструкции по вызову указывается имя подпрограммы и фактические параметры, то есть значения формальных параметров, с которыми следует выполнить тело подпрограммы в данном месте.
    Пример. Дан массив целых чисел {Ai},i=1, 2, …, 15. Программа вычисляет произведение сумм некоторых элементов массива А. Так как операции, которые следует выполнить для суммирования, не зависят от конкретных значений используемых чисел, алгоритм суммирования оформлен в виде подпрограммы. Поскольку каждая из сумм, которые входят в конечное произведение, не представляет интереса сама по себе, подпрограмма оформлена по типу подпрограммы-функции.
    Функция СУММА(I1,I2)
    начало: S=0
    начало цикла для I=I1 до I2
    S=S+A(i)
    конец цикла
    СУММА=S
    конец функции
    начало программы
    писать(“введите значения массива А”)
    начало цикла для j=1 до 15
    читать А(j)
    конец цикла
    читать G,W,T,L
    Р:= СУММА(G,W)*СУММА(T,L)
    писать (“произведение равно”,Р:6)
    конец программы
    В программу введены константы: G=1; W=12;T=8;L=15. Это – фактические параметры, которые надо использовать вместо формальных параметров I1 и I2 при вычислении значения Р. В результате переменная Р примет значение произведения сумм элементов с 1 по 12 и с 8 по 15 из массива А.
    Разработка программы идёт пошагово, методом сверху-вниз. Сначала пишется текст основной программы, в которой вместо фрагментов, выделенных в подпрограммы, ставят «заглушки». Это подпрограммы, в которых вместо реально нужных операторов ставят сигнальные печати или ввод данных, которые должна была бы сосчитать эта подпрограмма. Таким образом проверяют и отлаживают основной алгоритм. Затем подпрограммы-заглушки по очереди заменяют на нужные подпрограммы, отлаживают и тестируют их. Такая технология облегчает создание программы, уменьшает количество ошибок и облегчает нахождение допущенных ошибок.
    Альтернативный способ – метод снизу-вверх: сначала пишут и отлаживают все подпрограммы, потом с их помощью строят, как из кубиков, основную программу.
    Основные языки программирования, использующие структурную технологию:
    – Ада, Си – языки общего назначения;
    – Бейсик (до Visual Basic);
    – КОБОЛ – для экономических задач (много операторов, облегчающих манипуляции с файлами);
    – Фортран, Паскаль, ПЛ/1 – для вычислительных задач (удобные средства для записи формул).
    XXV. Основные принципы объектно-ориентированного программирования
    Самостоятельная работа: [4] стр. 157–181
    Объектно-ориентированное программирование (ООП) применяют при программировании разных манипуляций над объектами (программы управления размерами и положением окон Windows, листами книги Excel, файлами и т. п.).
    Основные принципы составления алгоритма решения таких задач:
    – Моделируемая система состоит из объектов. Объекты могут быть вложены друг в друга (объект лист Excel – это часть объекта книга Excel).
    – Объекты каким-то образом взаимодействуют между собой.
    – Каждый объект характеризуется своим состоянием и поведением. Состояние объекта задаётся значением некоторых его свойств (объекты типа «книга Excel» имеют свойства имя, размер, открыта/закрыта и т. п.). Действия, которые можно выполнять над объектом или которые он сам может выполнять, называются методами (объект типа «книга Excel» можно открыть, закрыть, переименовать, перенести в другую папку и т. п.). После каждого действия изменяются какие-то свойства объекта.
    Основные термины и понятия:
    Класс объектов – шаблон, определяющий основные свойства, методы и события группы объектов, объединяемых в класс. По другому: Класс объектов – это множество объектов, имеющих общее поведение и общую структуру
    События – ситуации, в которых надо программировать какой-то отклик объекта (что делать, когда над гиперссылкой или кнопкой расположен курсор, или щёлкает курсор, или происходит двойной щелчок).
    Наследование – порождает иерархию объектов. В основном классе (родителе) можно выделять подклассы. Они состоят из объектов, входящих в класс родителя и обладают наряду со всеми его характеристиками дополнительной группой свойств, которых у других объектов класса-родителя нет. Пример: класс-родитель – окно Windows, подклассы – диалоговые окна, окна документов, окна папок. Подклассы окон документов – окна документов Word, окна документов Excel, окна документов Power Point и т. п.
    Определение наследования в Интернет-тестах: свойство ООП, которое может быть смоделировано с помощью таксонометрической классификационной схемы (иерархии).
    Инкапсуляция – сокрытие деталей программ, создающих и манипулирующих объектами. Создание объектов, манипулирование ими оформляется в виде подпрограмм. Программист указывает в своей программе только то, что и с каким объектом нужно сделать или какой результат нужно получить. То есть объекты рассматриваются как «чёрные ящики». Такой способ упрощает разработку программы и её модификацию.
    Полиморфизм –.одно и то же имя может обозначать в разных подклассах одного класса разные методы для выполнения одного и того же типа действий (трансформация объекта: для подкласса овал – один метод (программа), для подкласса прямоугольник – другой.
    По другому. Использование одного имени для задания общих для класса действий, что означает способность объектов выбирать внутренний метод, исходя из типа данных.
    По другому. Возможность использования разных функций с одним и тем же именем в разных классах.
    Основные языки ООП:
    – С++ – для системного программирования;
    – Java, JavaScript, PHP, Perl – для разработки сценариев в динамических Veb-страницах;
    – Simula – первый язык, построенный по принципам ООП;
    – Delphi (Object Pascal) – удобен для программирования баз данных.
    XXVI. Этапы решения задач на компьютере
    Самостоятельная работа    : [3] стр. 198–209; [4] стр. 182–184
    1. Постановка задачи:
    – сбор информации о задаче;
    – описание исходных данных и конечных целей;
    – определение формы выдачи результатов.
    2. Анализ и исследование модели задачи:
    – анализ существующих аналогов;
    – анализ технических и программных средств;
    – разработка мат. модели;
    – разработка структур данных.
    3. Разработка алгоритма:
    – выбор метода проектирования алгоритма;
    – выбор формы записи алгоритма (блок-схема, псевдокод и т.п.);
    – выбор тестов и метода тестирования;
    – проектирование алгоритма.
    4. Программирование:
    – выбор языка программирования;
    – уточнение способа организации данных;
    – запись алгоритма на выбранном языке.
    5. Отладка и тестирование:
    – синтаксическая отладка: исправление ошибок в форме записи конструкций;
    – отладка семантики и логической структуры (семантика – система правил истолкования отдельных конструкций языка): проверка правильности организации, например, циклов, ветвлений и т. п., соответствия типов переменных в выражениях, логическая структура – правильная последовательность обработки данных;
    – тестовые расчёты и анализ результатов тестирования;
    – совершенствование программы.
    6. Деятельность, направленная на исправление ошибок в программной системе, называется отладкой .Тестирование – прогон отлаженной программы на эталонных вариантах исходных данных, для которых заранее известны результаты.
    7. Анализ результатов тестирования и, если нужно, уточнение модели и повторение п.п. 2–5.
    8. Сопровождение программы: составление документации по мат. модели, алгоритму, программе, набору тестов, использованию готовой программы и т. п.
    ? Интегрированная система программирования включает среди прочих компоненты:
    :#5 текстовый редактор – для создания исходного текста программы;
    #5 компилятор и #5интерпретатор – для перевода исходного текста программы в машинный код.
    ? Система программирования представляет программисту возможность:#5 автоматической сборки разработанных модулей в единый проект
    ? В состав средств программирования на языках высокого уровня входят:
    #5 трансляторы,#5интерпретаторы.
    ? Интерпретатор: #5 воспринимает исходную программу на исходном языке и выполняет её построчно, не создавая исполняемого модуля.
    Исполняемый файл создаётся из исходного текста программы компилятором и предполагает выполнение следующих процессов:
    а) компиляция
    б) компоновка
    ? Ошибка в форме записи программы приводит к сообщению о синтаксической ошибке:
    ? На этапе отладки программы:#5 проверяется корректность работы программы.
    На этапе тестирования проверяется правильность составления алгоритма и выделения существенных закономерностей в моделируемой системе.
    —————————————————————————————————————————

  5. Тону в твоих слезах* Ответить

    Программирование, процесс подготовки задач для решения их на ЭВМ, состоящий из следующих этапов: составление «плана решения» задачи в виде набора операций (алгоритмическое описание задачи); описание «плана решения» на языке программирования (составление программы); трансляция программы с языка программирования на машинный язык (в виде последовательности команд, реализация которых техническими средствами ЭВМ и есть процесс решения задачи). Программированием называют также раздел прикладной математики, изучающий и разрабатывающий методы и средства составления, проверки и улучшения программ для ЭВМ.
    Основными технологиями разработки программного обеспечения являются:
    1. Структурное программирование;
    2. Модульное программирование.
    Структурное программирование
    Сутью структурного программирования является возможность разбиения программы на составляющие элементы.
    Идеи структурного программирования появились в начале 70-годов в компании IBM, в их разработке участвовали известные ученые Э. Дейкстра, Х. Милс, Э. Кнут, С. Хоор.
    Распространены две методики (стратегии) разработки программ, относящиеся к структурному программированию: программирование “сверху вниз” и программирование “снизу вверх”.
    Программирование “сверху вниз”, или нисходящее программирование – это методика разработки программ, при которой разработка начинается с определения целей решения проблемы, после чего идет последовательная детализация, заканчивающаяся детальной программой. Является противоположной методике программирования «снизу вверх».
    При нисходящем проектировании задача анализируется с целью определения возможности разбиения ее на ряд подзадач. Затем каждая из полученных подзадач также анализируется для возможного разбиения на подзадачи. Процесс заканчивается, когда подзадачу невозможно или нецелесообразно далее разбивать на подзадачи.
    В данном случае программа конструируется иерархически – сверху вниз: от главной программы к подпрограммам самого нижнего уровня, причем на каждом уровне используются только простые последовательности инструкций, циклы и условные разветвления.
    Программирование “снизу вверх”, или восходящее программирование – это методика разработки программ, начинающаяся с разработки подпрограмм (процедур, функций), в то время когда проработка общей схемы не закончилась. Является противоположной методике программирования «сверху вниз».
    Такая методика является менее предпочтительной по сравнению с нисходящим программированием так как часто приводит к нежелательным результатам, переделкам и увеличению времени разработки.
    Достоинства структурного программирования:
    1) повышается надежность программ (благодаря хорошему структурированию при проектировании, программа легко поддается тестированию и не создает проблем при отладке);
    2) повышается эффективность программ (структурирование программы позволяет легко находить и корректировать ошибки, а отдельные подпрограммы можно переделывать (модифицировать) независимо от других);
    3) уменьшается время и стоимость программной разработки;
    4) улучшается читабельность программ.
    Резюме
    Технология структурного программирования при разработке серьезных программных комплексов, основана на следующих принципах:
    – программирование должно осуществляться сверху вниз;
    – весь проект должен быть разбит на модули (подпрограммы) с одним входом и одним выходом;
    – подпрограмма должна допускать только три основные структуры – последовательное выполнение, ветвление (if, case) и повторение (for, while, repeat).
    – недопустим оператор передачи управления в любую точку программы (goto);
    – документация должна создаваться одновременно с программированием в виде комментариев к программе.
    Структурное программирование эффективно используется для решения различных математических задач, имеющих алгоритмический характер.

  6. Dular Ответить

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

  7. Thetathris Ответить


    Суть — изучение базиса и необходимого фундамента для дальнейшего продвижения. Подход «Снизу-Вверх» популярен не только во многих онлайн и офлайн курсах, но и в образовательных учреждениях (например, в университетах или колледжах). Вы начинаете с нуля и изучаете только одну концепцию или тему за раз. Идея состоит в том, чтобы получить прочный фундамент и основы программирования, которые в дальнейшем помогут вам развиваться в любом направлении программирования.
    Главным преимуществом является то, что вы действительно изучаете основы. Не имеет значения, делаете ли вы 3D-игру или интерактивный веб-сайт — фундаментальные основы применимы и используются везде.
    Учить каждую концепцию отдельно — легче, так как это происходит изолированно. Если выбранный вами курс с подходом «Снизу-Вверх» хорошо структурирован, то вы не будете подвергнуты бомбардировке 1000 разными терминами/концепциями за раз. Вам предоставляется каждая новая тема изолированно в «удобно-съедобном» виде. Сначала идут базовые вещи (например, что такое переменная, функция, программа и т.д.), а затем уже происходит плавный переход к более сложным темам (например, к классам, циклам, ООП и т.д.).
    Минусом, если его вообще можно так назвать, является скорость продвижения. Хотя это всё также индивидуально. Сначала вы тратите время, чтобы получить необходимые знания и только потом применяете их на практике. А чтобы сделать что-либо значительное, вам потребуется многое узнать. Например, для реализации интерактивного веб-сайта вам могут понадобиться недели, если не месяцы обучения. А для создания более-менее хорошей 3D-игры вам понадобятся месяцы, если не годы.
    А когда период изучения затягивается, а счастья от мгновенного результата вы не получаете, то здесь и начинается конфликт ожиданий. Но суть в том, что большинству новичков гораздо интереснее создать веб-сайт за день, нежели неделю разбираться со всеми нюансами циклов или массивов. Это не плохо и не хорошо, это факт.

    Метод «Сверху-Вниз»


    Суть — создание рабочих проектов с самого старта обучения. Большинство программистов-самоучек начинали свой путь именно с этого подхода. Цель — создать готовый, рабочий проект. Например, 3D-игру или красивый интерактивный веб-сайт. Самый быстрый способ реализовать проект с нуля — следовать подробному туториалу. Повторяя в точности все шаги из выбранного вами гайда вы сможете в течение относительно небольшого срока создать готовый проект с нуля.
    Главным преимуществом является то, что вы сходу что-то делаете, вы не погружаетесь в изучение базы, не тратите время на то, чтобы ознакомиться и разобраться со всеми концепциями и их нюансами. Вы тупо делаете проект. И это чувство мгновенного результата от своих действий мотивирует вас на протяжении прохождения всех уроков.
    Но в этом и кроется главный недостаток — вы не учите основы. Базис, который вам необходим для дальнейшего роста вы просто-напросто пропускаете.
    В конце туториала вы даже можете не понимать, как работает ваше творение. Если уроки недостаточно подробные, то у вас будут большие пробелы в знаниях, которые заполнить быстро уже не получиться. Вам всё равно придётся потратить якобы «сэкономленное» время на изучение основ. Если же вы попытаетесь отслониться от инструкций туториала хоть малейшим действием, то весь ваш проект может рухнуть в одну минуту, и вы даже не поймёте, почему так сталось и как это исправить. Вам просто нужно всё копировать и повторять. Даже не пытайтесь заглянуть под капот. Не смотрите в эту бездну ??

    Какой подход выбрать?

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

    Чувствуете, что перегружены и не понимаете, что делает ваш код? Переключитесь на подход «Снизу-Вверх». Вернитесь к теории и разберитесь с тем, что и как делает ваш код. Постарайтесь заполнить пробелы в своих знаниях.
    Надоедает изучение абстрактных концепций программирования? Переключитесь на подход «Сверху-Вниз». Создайте что-то маленькое, например, простенький сайт или игру. Постарайтесь применить на практике полученные знания и ощутите «счастье от мгновенного результата».
    Легко и просто не будет, но и не настолько сложно, чтобы это не осилить. Не беспокойтесь слишком много о том, что вы ещё чего-то не знаете — это дело времени. Но и не забывайте о том, что без действий ничего, абсолютно ничего не будет. А чтобы вам в этом помочь, а именно в изучении программирования, в частности С++, был создан курс по C++, который вы могли видеть здесь.
    В этом курсе как раз и совмещаются эти 2 подхода. Все темы раскрываются поочерёдно и изложены в «удобно-съедобном» виде. Вся теория сразу же иллюстрируется в примерах и в конце уроков (не каждого!) есть тесты: задания, которые вам нужно решить, применив полученные знания из урока на практике. Также в конце каждой главы есть итоговый тест — то самое чувство мгновенного результата и самостоятельной практики. Поэтому пробуйте то, что подходит вам, совмещайте разные подходы и не забывайте о самом главном — получать удовольствие от процесса.

  10. VideoAnswer Ответить

Добавить ответ

Ваш e-mail не будет опубликован. Обязательные поля помечены *