Apa yang dilakukan programmer sebelum lingkup variabel, di mana semuanya bersifat global?

Jadi, saya harus berurusan dengan bahasa yang tampaknya kuno (disebut PowerOn) di mana saya memiliki metode utama, beberapa tipe data untuk mendefinisikan variabel, dan memiliki kemampuan untuk memiliki sub-prosedur (pada dasarnya void methods) yang tidak mengembalikan tipe atau menerima argumen apa pun. Masalahnya di sini adalah bahwa SEMUA adalah global. Saya sudah membaca jenis-jenis bahasa ini, tetapi sebagian besar buku menggunakan pendekatan "Ok, kita gunakan untuk menggunakan kuda dan cariage, tapi sekarang, ini sebuah mobil jadi mari kita belajar bagaimana bekerja pada ITU!" Kami TIDAK PERNAH akan menghidupkan kembali hari-hari itu " . Harus saya akui, pikiran sedang berjuang untuk berpikir di luar jangkauan dan luasnya .

Nah, inilah saya. Saya mencoba mencari cara terbaik untuk mengelola apa pun kecuali variabel global di beberapa metode terbuka . Yap, bahkan iterator untuk forloop harus didefinisikan secara global, yang saya temukan sendiri daur ulang di berbagai bagian kode saya.

Pertanyaan saya: bagi mereka yang memiliki pengalaman jenis ini, bagaimana programmer menangani sejumlah besar variabel dalam bidang bermain global? Saya merasa itu hanya menjadi trik sulap mental, tetapi saya akan tertarik untuk mengetahui apakah ada pendekatan yang diketahui.

Anda akan memerlukan semacam trik pembukuan mental (konvensi penamaan, dll.) Agar tetap lurus. Juga, dokumen, dokumen, dokumen. Karena semua variabel adalah global, miliki satu dokumen dengan semuanya terdaftar, jika Anda bisa.

Cobalah untuk memiliki sejumlah kecil variabel yang selalu Anda gunakan untuk sementara, dan ingat bahwa MEREKA SEMENTARA. Dengan terus-menerus menggunakan kembali yang sama, Anda akan terbiasa melacak di mana mereka valid atau tidak.

Juga, Anda ingin melihat dokumentasi dan memastikan Anda tahu berapa lama nama variabel bisa, dan berapa banyak karakter yang sebenarnya unik. Saya tidak tahu apa-apa tentang PowerOn, tetapi jika itu cukup kuno untuk hanya memiliki lingkup global, maka ada kemungkinan bahwa ia memiliki panjang keunikan terbatas pada pengidentifikasi.

Saya telah melihat banyak hal sebelumnya dengan pengidentifikasi panjang, tetapi pengidentifikasi yang hanya unik dalam 8 karakter pertama. Jadi Anda bisa memiliki RonnyRayGun dan RonnyRayBlaster dan mereka sebenarnya adalah variabel SAMA. Dalam kasus seperti itu saya sarankan menyimpan nama variabel di bawah batas 'unik' sehingga Anda cenderung tidak sengaja bertabrakan.

Kamus data.

Dalam repositori pusat (biasanya kantor programmer utama), ada pengikat looseleaf, yang berisi satu halaman untuk setiap variabel global. Halaman tersebut memberi nama, definisi, tujuan, dan rutinitas mana yang mengatur atau menggunakannya.

Sistem tertanam awal dengan RAM mikroskopis memiliki masalah yang sama, dan solusi yang serupa. Pemrogram utama mempertahankan peta RAM master, hingga masing-masing byte, menunjukkan RAM apa yang digunakan oleh modul mana untuk tujuan apa. Programmer yang membutuhkan alokasi RAM khusus pergi ke programmer utama, yang, setelah mendiskusikan masalah ini, membuat entri notebook yang sesuai dan memberikan RAM kepada orang itu. (Anda tidak ingin berada di posisi programmer yang mengambil byte RAM tanpa membersihkannya dengan programmer utama. Percayalah pada saya ini.)

Masalah ini juga muncul ketika programmer harus membangun sistem besar di versi awal BASIC. Itu muncul untuk saya secara pribadi ketika menggunakan manajer "database" yang sangat primitif bernama Info (produk Henco, Inc. dari New Jersey - HARAPAN sekarang sudah lama hilang!). Kedua bahasa tersebut memiliki kosakata nama variabel yang sangat terbatas.

Munculnya bahasa pemrograman dengan ruang lingkup blok bertepatan dengan kedatangan lebih cepat, mesin yang lebih besar, dan itu bukan kebetulan. Komputer awal memiliki RAM yang diukur dalam MB, kB atau bahkan dalam byte; tidak ada peluang untuk memiliki begitu banyak variabel sehingga mereka akan bingung ketika program menjadi besar, karena program tidak pernah mendapat yang besar . Kemajuan dalam bahasa pemrograman biasanya dibuat ketika orang-orang mengakui bahwa kebiasaan pemrograman lama mereka tidak meningkat ketika arena menjadi jauh lebih besar; ruang lingkup blok diciptakan sebagai mekanisme pertahanan untuk programmer terhadap memori mereka sendiri yang terbatas.

Komputasi juga merupakan aktivitas yang jauh lebih langka dan eksotis ketika komuter sangat mahal, dan mungkin hanya orang-orang yang secara matematis cenderung dan cerdik menjadi programmer di tempat pertama (meskipun perbandingan seperti itu tidak praktis untuk diuji, dan tentu saja pemborosan politik). Pada hari-hari awal, perangkat lunak biasanya dikirimkan secara gratis dengan komputer untuk meyakinkan orang untuk membelinya di tempat pertama; pemikiran bahwa pengguna institusional bahkan akan mencoba untuk menulis program mereka sendiri pada awalnya tidak diketahui.

Ya ampun, itu bertahun-tahun yang lalu (kenangan menggelegak :)).

Saya tidak tahu bahasa yang Anda maksud, tetapi secara umum kami beradaptasi dengan apa yang kami miliki. Itu bukan masalah besar. Anda perlu lebih memperhatikan nama var yang sering berisi (dalam bentuk singkat, pada hari-hari itu jumlah byte sangat berharga) referensi ke sub atau fungsi, seperti mIORead1jika Anda memiliki penangan untuk membaca data dari file 1, atau Anda memiliki berbagai counter vars seperti i, j, k dll. yang dengan sistem Anda sendiri, Anda tahu apa gunanya, jika dapat digunakan kembali dan sebagainya. Itu lebih hardcore (tidak ada helm atau sarung tangan saat itu) :-)

Ini sangat mirip dengan pemrograman PLC, meskipun PLC modern sekarang memungkinkan Anda untuk memiliki "tag" (alias variabel) yang bersifat lokal untuk suatu program. Namun, banyak orang hanya memprogram menggunakan semua tag global.

Saya telah menemukan, jika Anda akan melakukan itu, Anda perlu menggunakan konvensi penamaan terstruktur. Misalnya: Motor1_DriveContactor_Run. Jika bahasa Anda kebetulan struktur pendukung (kadang-kadang dikenal sebagai jenis yang ditetapkan pengguna) maka Anda juga dapat menggunakan mereka untuk membuat hirarki data terstruktur, seperti: Motor[1].DriveContactor.Run.

Itu membuat semuanya teratur, dan biasanya kecerdasan cukup baik untuk membantu Anda.

Saya benar-benar belajar memprogram dalam bahasa yang disebut Authorware, di mana semuanya bersifat global. Untungnya, ia memiliki Array dan setelah titik tertentu sesuatu yang disebut Daftar, yang mirip dengan objek generik.

Program Authorware sebenarnya memiliki struktur fisik (Authorware didasarkan pada metafor diagram alir), dan bahasa skripnya didasarkan pada Pascal gaya lama. Apa yang kami lakukan adalah menghubungkan struktur fisik dengan indeks dalam Array, dan sering indeks Array akan berisi Daftar yang akan kami perlakukan sebagai objek lokal untuk potongan fisik yang kami gunakan.

Authorware dirancang untuk eLearning, jadi salah satu ikon yang kami miliki adalah Halaman. Halaman akan dilampirkan ke Kerangka. Jadi, untuk Halaman 1, kita akan melihat pada beberapa Array di indeks 1 (Authorware adalah 1-diindeks) dan mengeluarkan data untuk halaman itu, yang akan disimpan Daftar yang akan bertindak sebagai objek semu. Halaman kemudian akan memiliki logika yang akan mengeluarkan "properti" objek dengan nama. Jika Anda tidak memiliki sesuatu seperti Objects, tetapi Anda memiliki Array, Anda dapat dengan mudah memiliki konvensi tentang data apa yang digunakan.

Ini tidak jauh berbeda dari apa yang kita lakukan ketika kita mengambil data dari database dan melakukan injeksi ketergantungan, kecuali bahwa semuanya benar-benar global, dan Anda hanya memilih untuk memasukkan semuanya ke dalam kotak kecil dan hanya melihat satu-satunya yang Anda inginkan. khawatir dengan sekarang.

Bergantung pada apa yang Anda coba lakukan dan apa yang didukung bahasa Anda, ini mungkin membantu Anda setidaknya memecah hal-hal menjadi potongan-potongan yang lebih mudah dikelola.

Ketika saya masih di universitas, kita diajarkan panjang lebar tentang "Masalah Variabel Global" - kumpulan masalah bug dan pemeliharaan kode yang disebabkan oleh banyak variabel global.

Beberapa variabel lebih berbahaya daripada yang lain.

Aman : Variabel yang tidak memengaruhi flow-of-control misalnya LastName

Berbahaya : Variabel apa pun yang mempengaruhi aliran kendali program, misalnya DeliveryStatus

Paling berbahaya dulu:

• Status gabungan (mode dan sub-mode)
• Nilai gabungan (total, sub-total)
• Status tunggal (mode)
• Nilai tunggal (hitung)

Untuk menghindari "masalah variabel global", Anda harus melakukannya

• Dokumentasikan setiap variabel dan fungsi.
• Simpan variabel terkait berdekatan (dengan kode yang menggunakannya) di bagian yang sama dari kode sumber.
• Sembunyikan variabel "berbahaya", jadi programmer lain tidak tahu keberadaannya. Hindari menggunakannya secara langsung, terutama di bagian kode yang lain.
• Menyediakan fungsi yang membaca / menulis variabel berbahaya (sehingga pemrogram lain tidak perlu).

Untuk menyusun kode Anda , ketika tidak ada struktur yang tersedia dalam bahasa tersebut, gunakan komentar dan konvensi penamaan:

/* --------------------------- 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";

Tidak tahu bagaimana mereka melakukannya.

Tapi saya pikir bahasa OOP modern memiliki masalah yang sangat mirip mengenai tabrakan penamaan .

Solusinya adalah mengadopsi namespace . Ini adalah konsep abstrak, tetapi banyak diadopsi oleh beberapa implementasi (paket Java, .NET namespace, modul Python).

Jika bahasa yang Anda gunakan tidak memiliki batasan yang terlalu sempit tentang panjang penamaan, maka Anda dapat menerapkan namespace ke penamaan variabel yang baik.

Jadi nama variabel juga mewakili ruang lingkup variabel.

Coba tentukan pola penamaan seperti ini: order_detail_product_code, order_detail_product_unit_price. Atau untuk penghitung sementara atau swap: tmp_i, tmp_swap.

Dalam bahasa semua variabel bersifat global (saya telah menggunakan pasangan) kami menggunakan konvensi penamaan variabel. Sebagai contoh: jika saya benar-benar ingin menggunakan variabel sebagai global saya mungkin menggunakan awalan "m_" atau "_". Tentu saja ini masih bergantung pada pengembang untuk memiliki disiplin ini