Что программисты делали до переменной области, где все глобально?

Итак, мне приходится иметь дело с, казалось бы, архаичным языком (называемым PowerOn), где у меня есть основной метод, несколько типов данных для определения переменных, и у меня есть возможность иметь подпроцедуры (по существу, пустые методы), которые не возвращают тип и не принимает никаких аргументов. Проблема здесь в том, что ВСЕ глобально. Я читал об этих типах языков, но в большинстве книг есть такой подход: «Хорошо, мы привыкли использовать лошадь и кариес, но теперь, вот машина, так что давайте узнаем, как работать с ЭТОМ!» Мы НИКОГДА не переживем те дни " . Я должен признать, что разум изо всех сил пытается мыслить вне рамок и масштабов .

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

Мой вопрос: как программисты справляются с большим количеством переменных в глобальном игровом поле? Я чувствую, что это стало просто умственным фокусом, но мне было бы интересно узнать, были ли какие-либо известные подходы.

Вам понадобятся какие-то умственные приемы ведения бухгалтерии (соглашения об именах и т. Д.), Чтобы все было понятно. Также документ, документ, документ. Поскольку все переменные являются глобальными, по возможности, имейте один документ со всеми ними в списке.

Постарайтесь иметь небольшое количество переменных, которые вы всегда используете для временных, и помните, что ОНИ ВРЕМЕННЫ. Постоянно повторно используя одни и те же, вы привыкнете отслеживать, где они действительны или нет.

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

Я видел вещи раньше с длинными идентификаторами, но чьи идентификаторы были уникальными только в первых 8 символах. Таким образом, вы можете иметь RonnyRayGun и RonnyRayBlaster, и они на самом деле те же переменные. В таких случаях я рекомендую держать имена переменных ниже предела «уникальности», чтобы избежать случайного столкновения.

Словарь с данными.

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

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

Эта проблема также обнаружилась, когда программистам приходилось создавать большие системы в ранних версиях BASIC. Он обнаружился лично для меня при использовании очень примитивного менеджера «базы данных» под названием Info (продукт Henco, Inc. из Нью-Джерси - НАДЕЖДА уже давно ушел!). Оба этих языка имели очень ограниченный словарь переменных имен.

Рост языков программирования с блочной областью совпал с появлением более быстрых, больших машин, и это не случайно. У ранних компьютеров ОЗУ измерялось в МБ, КБ или даже в байтах; просто не было возможности даже иметь так много переменных, что они были бы перепутаны, когда программа стала большой, потому что программы никогда не становились такими большими . Достижения в языках программирования обычно делались, когда люди осознавали, что их старые привычки программирования не расширялись, когда арена становилась намного больше; Область видимости блока была изобретена как механизм защиты программистов от собственной ограниченной памяти.

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

Боже мой, это много лет назад (бурлящие воспоминания :)).

Я не знаю язык, на который вы ссылаетесь, но в целом мы адаптировались к тому, что имели. Это не было большой проблемой. Вам нужно было уделять больше внимания именам var, которые часто содержат (в краткой форме, в те дни количество байтов было драгоценным) ссылку на sub или функцию, например, mIORead1если у вас есть обработчик для чтения данных из файла 1, или у вас были различные встречные переменные типа i, j, k и т. д., которые по вашей собственной системе вы знали, для чего они предназначены, если они могут быть использованы повторно и так далее Это было более хардкорно (тогда не было шлемов или перчаток) :-)

Это очень похоже на программирование ПЛК, хотя современные ПЛК теперь позволяют вам иметь «теги» (или переменные), которые являются локальными для программы. Тем не менее, многие люди просто программируют, используя все глобальные теги.

Я обнаружил, что если вы собираетесь это сделать, вам нужно использовать соглашение о структурированных именах. Например: Motor1_DriveContactor_Run. Если ваш язык происходит со структурами поддержки (иногда известные как определяемые пользователем типы) , то вы можете также использовать их для создания иерархии структурированных данных, таких как: Motor[1].DriveContactor.Run.

Это поддерживает все в порядке, и обычно intellisense достаточно приличный, чтобы помочь вам в этом.

Я действительно научился программировать на языке Authorware, где все было глобально. К счастью, у него были Массивы и после некоторой точки что-то, называемое списками, которые были похожи на общие объекты.

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

Authorware был разработан для электронного обучения, поэтому одной из наших иконок была страница. Страницы будут прикреплены к Framework. Итак, что касается страницы 1, мы бы посмотрели в массиве Array на индекс 1 (Authorware был 1-проиндексирован) и извлекли данные для этой страницы, которые будут хранить список, который будет действовать как псевдообъект. Страница будет иметь логику, которая будет извлекать «свойства» объекта по имени. Если у вас нет ничего подобного Objects, но у вас есть массивы, вы можете просто договориться о том, куда и куда идут данные.

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

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

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

Некоторые переменные более опасны, чем другие.

Безопасный : переменные, которые не влияют на поток управления, например, LastName

Опасный : любая переменная, которая влияет на поток управления программы, например DeliveryStatus

Сначала самое опасное:

• Состояние соединения (режим и подрежим)
• Составные значения (итого, подытог)
• Единый статус (режим)
• Отдельные значения (количество)

Чтобы избежать "проблемы глобальных переменных", вам нужно

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

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

/* --------------------------- Program mode ------------------------ */

var Mode_Standard = 1;      // Normal operation (SubMode unused)
var Mode_Backup   = 2;      // Backup mode      (SubMode is backup device)

var BackupMode_Disk = 1;    // SubMode: Backup to disk
var BackupMode_Tape = 2;    // SubMode: Backup to tape

var MainMode = Mode_Standard;
var SubMode = 0;

function Mode_SetBackup(backupMode)
{
    MainMode = Mode_Backup;
    SubMode = backupMode;
}

function Mode_SetStandardMode()
{
    MainMode = Mode_Standard;
    SubMode  = 0;
}

function Mode_GetBackupMode()
{
    if (MainMode != Mode_Backup)
        return 0;

    return SubMode;
}

/* --------------------------- Stock Control ------------------------ */

var Stock_Total =  123;      // Total stock       (including RingFenced)
var Stock_RingFenced = 22;   // Ring-fenced stock (always less than total)

// Adds further ring-fenced stock 
function Stock_AddRingFenced(quantity)
{
    Stock_Total      += quantity;
    Stock_RingFenced += quantity;
}

/* ------------------------- Customers ----------------------- */

var Customer_FirstName = "Tony";
var Customer_LastName  = "Stark";

Не знаю, как они это сделали.

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

Решение принимает пространство имен . Это абстрактная концепция, но широко принятая несколькими реализациями (пакеты Java, пространство имен .NET, модули Python).

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

Таким образом, имя переменной также представляет область видимости переменной.

Попробуйте определить шаблон именования следующим образом: order_detail_product_code, order_detail_product_unit_price. Или для временных счетчиков или свопов: tmp_i, tmp_swap.

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