Що робили програмісти перед змінною сферою, де все глобально?

Отже, мені доводиться мати справу з начебто мовою серця (так званою PowerOn), де я маю основний метод, кілька типів даних для визначення змінних і має можливість мати підпроцедури (по суті недійсні методи), які не повертають тип не приймає жодних суперечок. Проблема тут полягає в тому, що ВСЕ є глобальним. Я читав про такі типи мов, але більшість книг займає такий вигляд: "Добре, ми використовуємо коня та карету, але тепер, ось машина, тому давайте навчимося працювати над ТОМУ!" Ми НІКОЛИ не переживемо тих днів " . Я мушу визнати, розум намагається мислити поза межами та обсягом .

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

Моє запитання: для тих, хто має досвід такого типу, як програмісти мали справу з великою кількістю змінних у глобальному ігровому полі? Я відчуваю, що це просто став душевним жонглюючим трюком, але мені було б цікаво дізнатись, чи є відомі підходи.

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

Постарайтеся мати невелику кількість змінних, які ви завжди використовуєте для тимчасових країн, і пам’ятайте, що вони є тимчасовими. Постійно використовуючи ті самі, ви ввійдете в звичку слідкувати за тим, де вони дійсні чи ні.

Крім того, ви хочете переглянути документацію та переконатися, що ви знаєте, наскільки довгими можуть бути імена змінних та скільки символів насправді унікальні. Я знаю НІЧЕ про PowerOn, але якщо це досить архаїчно, щоб мати лише глобальний обсяг, то можливо, що він має обмежену довжину унікальності для ідентифікаторів.

Я вже бачив речі з довгими ідентифікаторами, але ідентифікатори яких були унікальними лише у перших 8 символах. Таким чином, ви можете мати RonnyRayGun та RonnyRayBlaster, і вони насправді є однаковою змінною. У таких випадках я рекомендую тримати імена змінних під "унікальним" обмеженням, щоб менше шансів випадково зіткнутися.

Словник даних.

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

Ранні вбудовані системи з мікроскопічною оперативною пам’яттю мали подібну проблему та подібне рішення. Провідний програміст підтримував головну карту оперативної пам’яті до окремих байтів, показуючи, яку оперативну пам’ять використовували, які модулі для яких цілей. Програмісти, які потребували виділення оперативної пам’яті, перейшли до головного програміста, який, обговоривши це питання, зробив відповідний запис у зошит і дав хлопцеві свою оперативну пам’ять. (Ви не хотіли бути у взутті програміста, який взяв байт оперативної пам’яті, не очистивши його від головного програміста. Повірте мені це.)

Ця проблема також з’явилася, коли програмістам довелося будувати великі системи в ранніх версіях BASIC. Це виявилося особисто для мене при використанні дуже примітивного менеджера "баз даних" під назвою "Інформація" (продукт компанії Henco, Inc., штат Нью-Джерсі - НАДІЙНІШЕ вже давно!). Обидві ці мови мали дуже обмежену лексику змінної назви.

Зростання мов програмування з блоком дії збіглося з появою більш швидких, великих машин, і це не випадково. На ранніх комп'ютерах оперативна пам'ять вимірювалася в МБ, кБ або навіть у байтах; просто не було можливості навіть мати стільки змінних, які б їх плутали, коли програма набула великого розміру, оскільки програми ніколи не мали такого великого розміру . Досягнення мов програмування зазвичай досягалися тоді, коли люди визнавали, що їхні старі навички програмування не зростали, коли арена стала значно більшою; Блок блоку був винайдений як механізм захисту програмістів проти їх обмеженої пам'яті.

Обчислювальна техніка була також набагато більш рідкісною та екзотичною діяльністю, коли комп’ютери були фантастично дорогими, і цілком можливо, що лише спеціально схильні до математики та геніальність люди в першу чергу стали програмістами (хоча такі порівняння не доцільно перевіряти і, безумовно, політично запалюють). У перші дні програмне забезпечення зазвичай постачалося безкоштовно з комп'ютером, щоб переконати людей купувати його в першу чергу; думка, що інституційні користувачі навіть намагатимуться писати власні програми, спочатку була невідома.

Мій боже, це багато років тому (бурхливі спогади :)).

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

Це досить схоже на програмування PLC, хоча сучасні PLC тепер дозволяють вам мати "теги" (ака-змінні), локальні для програми. Тим не менш, багато людей просто програмують, використовуючи всі глобальні теги.

Я виявив, що якщо ви збираєтеся це робити, вам потрібно використовувати структуровану конвенцію про іменування. Наприклад: Motor1_DriveContactor_Run. Якщо ваш язик відбувається зі структурами підтримки (іноді відомі як визначені користувачем типи) , то ви можете також використовувати їх для створення ієрархії структурованих даних, таких як: Motor[1].DriveContactor.Run.

Це тримає все організовано, і, як правило, інтелігенція є достатньо гідною, щоб допомогти вам.

Я насправді навчився програмувати мовою Authorware, де все було глобальним. На щастя, у нього були масиви і після певного моменту щось називалося списками, які були схожі на загальні об’єкти.

Програма Authorware насправді мала фізичну структуру (Authorware базувалася на метафорі діаграми), а її мова сценаріїв базувалася на старому стилі Pascal. Що ми зробили, це пов’язати фізичну структуру з індексами в масиві, і часто індекси масиву містили б списки, які ми би розглядали як локальний об'єкт для фізичної частини, яку ми використовували.

Програмне забезпечення було розроблено для eLearning, тому однією з ікон ми були Сторінка. Сторінки будуть додані до Рамки. Отже, для сторінки 1 ми заглянемо в якийсь масив в індексі 1 (авторське програмне забезпечення було індексовано 1) і витягнемо дані для цієї сторінки, в якій буде зберігатися список, який буде виконувати роль псевдооб'єкта. Тоді Сторінка матиме логіку, яка виводить "властивості" об'єкта на ім'я. Якщо у вас немає нічого подібного до «Об’єктів», але у вас є масиви, ви можете просто домовитися про те, які дані куди йдуть.

Це насправді не так, як ми робимо, коли ми отримуємо дані з бази даних та виконуємо ін'єкцію залежностей, за винятком того, що все справді глобально, і ти просто вирішуєш все скласти у маленькі поля та дивитись лише на той, який ти переймаєтесь зараз.

Залежно від того, що ви намагаєтеся зробити і що підтримує ваша мова, це може допомогти вам принаймні розбити речі на більш керовані шматки.

Коли я був в університеті, нас детально вчили про "Глобальну змінну проблему" - сукупність помилок та проблем з підтримкою коду, викликаних безліччю глобальних змінних.

Деякі змінні небезпечніші за інші.

Безпечний : Змінні, які не впливають на потоковий контроль, наприклад 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";

Не знаю, як вони зробили.

Але я думаю, що сучасні мови OOP мали дуже схожу проблему щодо зіткнення імен .

Рішення полягає у прийнятті простору імен . Це абстрактне поняття, але широко прийняте декількома реалізаціями (пакети Java, простір імен .NET, модулі Python).

Якщо мова, якою ви користуєтесь, має не надто вузьке обмеження щодо довжини імен, тоді ви можете застосувати простір імен до хорошої іменної змінної.

Отже, назва змінної також представляє область змінної.

Спробуйте визначити шаблон іменування , як це: order_detail_product_code, order_detail_product_unit_price. Або для тимчасових лічильників або свопів: tmp_i, tmp_swap.

У мовах усі змінні були глобальними (я використав пару), ми використовували конвенцію про іменування змінної. Наприклад: якщо я насправді хотів використовувати змінну як глобальну, я можу використовувати префікс "m_" або "_". Звичайно, це все ще покладається на розробників, щоб мати цю дисципліну