Apa Pola Desain era pemrograman prosedural? [Tutup]

Mirip: Bagaimana pemrograman dilakukan 20 tahun lalu?

OOP cukup modis saat ini, berakar di Simula 67 pada 1960-an, dan kemudian dipopulerkan oleh Smalltalk dan C ++ . Kami memiliki KERING, SOLID, banyak buku tentang pola desain di dunia berorientasi objek.

Tapi apa prinsip utama dalam pemrograman sebelum adopsi paradigma OOP? Dan apa pola desain utamanya?

Saya adalah seorang pengembang Cobol sebelum saya belajar Java. Saya telah berkembang selama lebih dari 35 tahun.

Kembali pada hari-hari bahasa prosedural, sebagian besar pemrosesan dilakukan dalam batch. Kembali cukup jauh dalam sejarah, dan bahkan kompilasi program dilakukan dengan setumpuk kartu punch dalam batch.

Berlawanan dengan pernyataan Kilian Foth , kami memiliki pola desain pada tahun 1970-an dan 1980-an. Ada cara tertentu untuk mengkodekan pencocokan / penggabungan multi-file di Cobol. Ada cara tertentu untuk menambahkan kode transaksi ke file master (tape) di Cobol. Ada cara tertentu untuk membuat kode pembuatan laporan di Cobol. Itulah sebabnya Penulis Laporan IBM tidak pernah benar-benar mendapatkan daya tarik di banyak toko Cobol.

Ada penerapan awal prinsip KERING. Buat banyak paragraf sehingga Anda tidak perlu mengulangi lagi. Teknik pengkodean terstruktur dikembangkan pada 1970-an dan Cobol menambahkan kata-kata terstruktur (kata kerja) ke bahasa pada tahun 1985.

Secara umum, ketika kami menulis program Cobol baru, kami menyalin program Cobol lama dan mengubah nama untuk melindungi yang tidak bersalah. Kami hampir tidak pernah memberi kode program Cobol dari selembar kertas kosong atau layar kosong. Itu pola desain besar ketika Anda dapat menyalin dan menempelkan seluruh program.

Ada begitu banyak pola desain Cobol sehingga butuh bertahun-tahun bagi seorang programmer Cobol untuk mempelajari semuanya. Itulah salah satu alasan bahwa programmer Cobol saat ini, sebagian besar, masih menggunakan sintaksis 1985.

"Pola desain" dalam perangkat lunak tidak ada di era yang Anda bicarakan, karena konsepnya belum ditemukan. Ini saya tidak menjadi sembrono - itu benar-benar adalah alasan; disebut nama yang dapat dikenali adalah apa yang membuat pola Desain menjadi "Pola desain" daripada hanya kode yang Anda terus gunakan dalam satu bentuk atau yang lain (misalnya "Pabrik" daripada "jenis kelas statis yang saya suka gunakan daripada menggunakan bermacam-macam konstruktor ") dan konsep itu sendiri tidak terkecuali.

Yang mengatakan, tentu saja ada hal-hal yang memenuhi peran yang persis sama dalam pekerjaan praktisi seperti pola desain lakukan sekarang. Tetapi Anda akan kecewa mendengarnya: "tipuan guru" pada masa itu adalah hal-hal yang cukup membosankan bagi kami sekarang - misalnya daftar yang terhubung sendiri, loop dikontrol oleh indeks yang bertambah pada setiap iterasi, pengakses pintar "accessor" "Metode yang tampaknya tidak melakukan apa pun selain memberi Anda kelonggaran dalam mengubah pikiran tentang detail implementasi nanti.

Benar, hal-hal yang sekarang kita anggap remeh - yang kadang-kadang bahkan bagian dari bahasa yang kita gunakan - dulu merupakan konsep canggih (dan kadang-kadang dijaga dengan cemburu) yang hanya diketahui oleh pembuat kode yang lebih berpengalaman. Kemungkinannya, hampir semuanya tidak sepele yang Anda pelajari dalam kursus pemrograman dasar hari ini melewati fase di mana itu setara dengan moral "pola desain" untuk para praktisi zaman ini. Konstruksi perangkat lunak mungkin belum menjadi disiplin teknik yang ketat, tetapi jika Anda mempelajari seni 50-an dan 60-an, Anda tidak dapat menyangkal bahwa ia telah datang dengan cara yang luar biasa sejak awal.

Paradigma besar sebelumnya adalah pemrograman terstruktur . Alih-alih UML, ada berbagai diagram yang berbeda (diagram alir, diagram aliran data, diagram struktur, dll). Pengembangan sebagian besar dari atas ke bawah, dan mengikuti proses dekomposisi fungsional. Salah satu ide dasar adalah bahwa struktur program Anda harus menyerupai berlian: Modul utama di atas, menyebar keluar ke modul kontrol tingkat tinggi, yang memanggil rutin dalam modul tingkat rendah. Modul tingkat rendah ini dibangun di atas modul tingkat lebih rendah, yang kesemuanya (secara teoritis) akhirnya bertemu pada beberapa rutinitas I / O dasar. Modul tingkat tinggi seharusnya mengandung logika program, modul tingkat rendah lebih mementingkan integritas data dan penanganan kesalahan.

Konsep penting yang diperkenalkan selama ini adalah penyembunyian informasi, modularitas dan kohesi tinggi / kopling rendah. Lihat karya-karya Dave Parnas untuk beberapa makalah seminal tentang topik-topik ini. Lihat juga karya Larry Constantine, Tom DeMarco dan Ed Yourdon.

Saya kira satu yang besar (selain pemrograman terstruktur itu sendiri) adalah konsep melewati pegangan - di OO Anda memiliki objek dan berisi keadaan dan fungsionalitas. Kembali sebelum OO, Anda akan memiliki banyak fungsi independen, dan Anda akan memberikan pegangan ke beberapa kondisi di antaranya - cookie jika Anda mau. Ini memberi Anda prinsip OO tanpa benar-benar memiliki OO.

Anda dapat melihat ini banyak dalam kode Win32 lama, Anda akan melewati HANDLE yang merupakan jenis buram yang mewakili beberapa keadaan yang dialokasikan dalam kernel Windows. Anda bisa melakukannya sendiri dengan meneruskan pointer ke struct yang sebelumnya Anda alokasikan sebagai parameter pertama untuk fungsi yang dioperasikan pada data itu.

Karena belum ada yang menyebutkan yang jelas: satu pola desain besar di era prosedural adalah Object. Seperti banyak pola desain populer sebelum (misalnya Subroutine) dan setelah (misalnya Iterator), itu menjadi sangat populer sehingga bahkan mendapat dukungan bahasa.

"Mesin negara terbatas" dapat dihitung sebagai Pola, dan FSM ditulis (misalnya untuk protokol komunikasi) menggunakan bahasa pra-OO.

Juga "interrupt handler" dan TSR yang dulu populer misalnya pada DOS.

Istilah-istilah seperti "Kode Spaghetti" dan "Satu Titik Keluar" sebenarnya adalah kemunduran untuk era itu. Saat ini kami memanggil kode yang tidak kami sukai "kode spageti", tetapi sebenarnya itu adalah referensi untuk kode yang diikat bersama (buruk) dengan GOTO dan JMP.

(Hari ini kita menderita "kode ravioli", di mana kode itu seperti sekelompok kelas yang tidak terkait, dikemas dengan ketat, seperti sepiring ravioli. Namun, beberapa pakar OO bertanya dengan tepat, "Tapi bukankah itu yang seharusnya dilakukan oleh OO? terlihat seperti?")

"Single Point of Exit" hari ini hanyalah roadbump refactoring yang membuat frustrasi. Banyak devs yang saya ajak bicara bahkan belum pernah mendengarnya, dan kaget ketika saya menjelaskannya. Tetapi di masa lalu itu berarti jangan melompat keluar dari blok kode tiba-tiba & ke kode spageti. Lompat maju ke akhir logika, lalu keluar dengan anggun.

Meregangkan ingatan saya, jauh ke belakang, saya sepertinya ingat bahwa ide menggabungkan kode ke dalam prosedur adalah lompatan besar ke depan. Gagasan bahwa Anda dapat mengemas prosedur menjadi Modul yang dapat digunakan dan dapat digunakan kembali adalah jenis pemrograman Holy Grail.

EDIT: "Kode modifikasi diri" juga merupakan pola yang digunakan terutama pada Doom asli. Di situlah program akan benar-benar menimpa instruksinya dengan instruksi yang lebih cepat berdasarkan kondisinya. Ketika saya masih kecil, mengambil kursus pemrograman di Science Museum, instruktur saya memperingatkan kami dengan tegas, "Jangan menulis kode modifikasi diri!"

EDIT EDIT: Namun, sebelum Internet, kata berjalan jauh lebih lambat. Gagasan untuk mengimplementasikan Algoritma dan Struktur Data dulu merupakan kesepakatan yang jauh lebih besar. Hari ini saya melakukan sortir setiap saat tanpa mengetahui jenis apa yang saya gunakan. Tetapi saat itu Anda harus membuat kode sendiri. Saya ingat satu artikel berbicara tentang tantangan pemrograman yang biasanya memakan waktu berhari-hari yang kita habiskan dalam setengah jam, atau kurang. Jadi pemrograman "algoritmik" dan "data stuktur" yang benar-benar mungkin ada dalam daftar, jauh lebih banyak daripada hari ini.