Berapa banyak usaha yang harus saya investasikan dalam menciptakan desain yang digabungkan secara longgar?

Saat ini saya sedang belajar tentang pola desain.

Saya pikir sebagian besar orang akan setuju bahwa pola-pola ini adalah alat yang hebat, tetapi harus digunakan dengan tidak berlebihan dan bukan sebagai jawaban untuk semuanya. Menggunakannya terlalu banyak akan menyulitkan aplikasi dengan sedikit manfaat. Pola harus digunakan hanya di mana mereka bisa menjadi solusi terbaik atau bantuan dalam penciptaan solusi yang baik (apakah Anda setuju?).

Dengan mengingat hal ini:

Buku yang saya baca (Head First Design Patterns) sering menekankan pentingnya pelepasan longgar . Kopling longgar ini dicapai dengan prinsip-prinsip berikut seperti 'program ke antarmuka, bukan implementasi' dan 'merangkum apa yang bervariasi'.

Pada dasarnya, sebagian besar pola yang saya pelajari sejauh ini sebagian besar ada untuk memungkinkan desain untuk digabungkan secara longgar, dan dengan demikian lebih fleksibel.

Saya memahami pentingnya dan manfaat kopling longgar.

Tetapi pertanyaan saya adalah, berapa banyak usaha yang harus diinvestasikan untuk membuat desain yang longgar dan fleksibel?

Mereka yang menentang pola desain mengatakan bahwa biaya untuk menggunakan pola-pola ini sering melebihi manfaatnya. Anda menginvestasikan banyak waktu dalam menciptakan desain yang digabungkan secara longgar menggunakan beberapa pola, di mana dalam kenyataannya - sambungan longgar, 'pemrograman ke antarmuka, bukan implementasi', dan semua prinsip ini - mungkin sebenarnya tidak begitu penting.

Apa yang ingin saya ketahui adalah berapa banyak upaya yang harus saya lakukan dalam menciptakan level tambahan abstraksi dan desain, hanya untuk memungkinkan aplikasi saya mengikuti prinsip-prinsip OO seperti kopling longgar, programmign ke antarmuka, dll. Apakah itu benar-benar layak Itu? Berapa banyak usaha yang harus saya lakukan dalam hal ini?

Jawaban bodoh: semakin banyak Anda melakukannya, semakin sedikit usaha itu.

Pada dasarnya, membangun kode yang digabungkan secara longgar tidak terlalu sulit. Sebaliknya, latihlah pikiran Anda untuk berpikir tentang kaitan longgar. Dan, yah, saya percaya itu sangat berharga.

Misalkan Anda mengambil pekerjaan yang menggunakan pendekatan berulang untuk pengembangan perangkat lunak, seperti yang telah direkomendasikan oleh kebanyakan orang selama 20 tahun terakhir. Anda membangun sesuatu yang bekerja dengan indah dalam iterasi 1. Dalam iterasi 2 Anda membangun di atasnya, menambahkan beberapa fitur baru, dan agak menekuk satu atau dua hal sedikit ketika mereka tidak cocok dengan iterasi Anda 1 konsep tentang bagaimana hal-hal seharusnya bekerja . Sekarang hadir iterasi 3, dan Anda mengetahui persyaratan yang menuntut Anda memikirkan kembali arsitektur dasar Anda. Bagaimana Anda merobek kode Anda dan membangunnya kembali tanpa kembali ke titik awal?

Ini terjadi. Banyak. Entah itu membuat proyek terlambat, atau membuat semua orang terlalu takut untuk melakukan apa yang perlu dilakukan dalam iterasi selanjutnya. Dalam kasus terbaik, Anda mendapatkan Bola Besar Lumpur. Hal-hal seperti kopling longgar dan prinsip tanggung jawab tunggal meringankan masalah ini secara besar-besaran. Itu sebabnya prinsip-prinsip SOLID disebut-sebut - mereka benar-benar membantu.

Dan Anda akan menemukan bahwa setelah Anda memiliki beberapa desain yang digabungkan secara longgar di bawah ikat pinggang Anda, mulai muncul secara alami. Pola adalah hal-hal yang ditemukan orang yang bekerja untuk mereka, jadi mereka mendokumentasikannya. Mereka adalah alat yang berguna yang juga datang secara alami seiring waktu.

Jumlah upaya yang diperlukan tidak selalu cukup untuk memberi tahu Anda; Saya pikir ukuran yang lebih baik adalah upaya untuk rasio hasil. Tetapi mencari tahu apa imbalannya mungkin tidak selalu mudah dan bebas dari kesalahan.

Hal yang perlu diingat dengan pola-pola yang meningkatkan kelenturan adalah bahwa perlu beberapa upaya untuk membuatnya, dan kecuali Anda dapat melihat dengan tepat mengapa Anda membutuhkannya, Anda mungkin akhirnya memiliki komplikasi dalam kode, tetapi tidak pernah menggunakannya. Jika fleksibilitas tidak pernah tertekuk, itu mungkin juga tidak ada.

Ada satu hal yang harus Anda lakukan selalu (atau sedekat mungkin dengan yang Anda bisa dapatkan): membuat komponen individu dari perangkat lunak Anda (objek untuk OOP, fungsi untuk pemrograman fungsional atau prosedural) menjadi kotak hitam. Kotak hitam adalah sesuatu yang bagian dalamnya (implementasinya) tidak kita ketahui atau pedulikan.

Jika kita tidak tahu atau peduli tentang cara kerjanya, maka kita tidak akan mencoba menggunakan apa pun kecuali antarmuka, jadi jika implementasinya berubah tanpa mengubah antarmuka, itu hanya masalah di dalam kotak hitam - tidak ada yang di luarnya dapat terpengaruh. Ini juga membuat memikirkan program lebih mudah, karena Anda tidak harus menyimpan setiap detail dari keseluruhan program di kepala Anda. Semakin banyak detail yang bisa Anda lupakan secara sah, semakin banyak ruang di kepala Anda untuk detail yang penting.

Saya pikir Anda telah salah mengerti keberatan untuk pola desain; Saya bukan penggemar mereka, tapi saya sangat suka prinsip kopling longgar dan pemrograman ke antarmuka. Keberatan saya yang paling kuat terhadap mereka adalah bahwa mereka disajikan sebagai solusi pra-paket yang tidak mendorong pemahaman prinsip-prinsip di belakang mereka, melainkan mendorong menghafal detail. Saya tidak akan merekomendasikan agar Anda tidak mempelajarinya, tetapi ketika Anda melakukannya, ingatlah bahwa memahami prinsip-prinsip di baliknya lebih penting daripada spesifik dari pola tertentu.

Salah satu keberatan untuk mendesain pola adalah bahwa pola-pola itu 'jelas' atau 'saya telah menggunakannya sebelum saya mendengarnya, hanya tidak dengan nama itu'. Alasan orang dapat membuat keberatan itu, atau pencetus pola desain bisa muncul dengan mereka, adalah bahwa mereka memahami prinsip-prinsip di belakang mereka.

Menggunakan kotak hitam mengatur kode Anda dengan cara yang waras dan biasanya tidak memerlukan biaya banyak (jika ada); gunakan di mana-mana. Menggunakan pola desain atau teknik lain yang menambahkan lapisan abstraksi atau menyulitkan hal-hal memiliki biaya; jangan pernah menggunakannya hanya karena mereka cantik atau rapi atau pintar; menggunakannya ketika mereka sesuai dengan masalah dan biayanya layak dibayar untuk mendapatkan manfaat.

Pertanyaan Anda tampaknya menyamakan sambungan longgar dengan Pola Desain, tetapi mereka benar-benar terpisah, tetapi hal-hal terkait.

Longgar kopling merupakan perhatian mendasar dalam pemrograman. Segera setelah kami pindah dari kode mesin dan ke bahasa simbolik, program menjadi longgar ditambah dengan eksekusi mereka. Dll

OO sendiri pada dasarnya adalah model untuk membuat komponen yang digabungkan secara longgar. Enkapsulasi membuat internal objek longgar ditambah dengan objek lain. Pemrograman fungsional mungkin bahkan lebih, karena eksekusi fungsi secara longgar digabungkan dengan eksekusi fungsi-fungsi lain secara ekstrim.

Hampir secara definisi, setiap desain yang Anda lakukan akan melibatkan kopling longgar. Ada beberapa cara yang dapat Anda lakukan untuk mengatur hal-hal yang digabungkan secara tidak sengaja, tetapi saya hanya melihat beberapa kasus di mana seseorang benar-benar merancang suatu sistem untuk menjadi lebih rapat.

(Kadang-kadang saya bekerja dengan seseorang yang ingin mencegah pengembang masa depan membuat pilihan desain dengan menanamkan referensi statis ke artefak kerangka tertentu, memaksakan penggunaannya - dengan sengaja. Tapi itu benar-benar pengecualian. Sebagian besar desain berputar pada pemecahan hal-hal untuk modularitas dan menggunakan kembali dalam banyak konteks.)

Pola harus digunakan hanya di mana mereka bisa menjadi solusi terbaik atau bantuan dalam penciptaan solusi yang baik (apakah Anda setuju?).

Saya melihat pola desain secara ketat sebagai detail implementasi. Jika Anda mendokumentasikan API dan program publik Anda untuk dokumentasi itu, secara umum tidak masalah (atau banyak mempengaruhi Anda) di mana Anda memiliki pola desain. Artinya, Anda tidak pergi "Saya punya pola jembatan di sini, dan saya akan menerapkan pengunjung di atasnya". Sebaliknya, ini adalah "kelas ini akan memiliki implementasi yang berbeda pada berbagai sistem operasi sehingga akan diimplementasikan menggunakan pola jembatan". Kemudian, ketika Anda menggunakannya, Anda tidak peduli dengan penerapannya sebagai jembatan - karena Anda melihat API publik, bukan pola jembatan.

berapa banyak usaha yang harus diinvestasikan dalam menciptakan desain yang longgar dan fleksibel?

Kopling longgar dapat dicapai dengan mengikuti serangkaian aturan sederhana. Jika Anda menghormati ini, kode Anda akan (lebih) digabungkan secara longgar, saat Anda menulisnya (yaitu segala upaya sudah menjadi bagian dari proses pengembangan).

Di antara aturan (bukan daftar lengkap):

• tentukan antarmuka Anda dengan memikirkan (atau menulis) kode klien (bagaimana kelas akan digunakan), bukan apa yang akan dilakukan kelas (mis. menginginkan antarmuka, bukan implementasi)
• "katakan, jangan tanya"
• membangun objek dari bagian yang sudah dibuat
• masukkan ke konstruktor objek aktual yang akan Anda gunakan (bukan pabrik untuk anggota, parameter untuk pabrik parameter, atau semacamnya).
• KERING (jika Anda memiliki dua baris yang muncul dalam urutan yang sama di dua tempat, ekstrak menjadi fungsi yang terpisah dan seterusnya).
• Jika penciptaan objek adalah operasi yang lebih kompleks, terapkan penciptaan bagian perantara sebagai metode / kelas pabrik (yaitu tidak di badan konstruktor).
• YAGNI (buat sesuatu sesuai kebutuhan Anda, bukan sebelumnya).

Aturan-aturan ini diikuti secara berbeda, tergantung pada bahasa, metodologi pengembangan yang diikuti oleh tim Anda (misalnya TDD), batasan anggaran waktu, dan sebagainya.

Sebagai contoh, di Jawa, itu adalah praktik yang baik untuk mendefinisikan antarmuka Anda sebagai interfacedan menulis kode klien pada itu (kemudian, instantiate antarmuka dengan kelas implementasi).

Di C ++ di sisi lain, Anda tidak memiliki antarmuka, jadi Anda hanya bisa menulis antarmuka sebagai kelas dasar abstrak; Karena di C ++ Anda hanya menggunakan warisan ketika Anda memiliki persyaratan yang kuat untuk itu (dan karena itu menghindari overhead fungsi virtual yang tidak perlu), Anda mungkin tidak akan mendefinisikan antarmuka secara terpisah, hanya header kelas).

Mereka yang menentang pola desain mengatakan bahwa biaya untuk menggunakan pola-pola ini sering melebihi manfaatnya.

Saya pikir mereka salah melakukannya. Jika Anda menulis kode yang digabungkan secara longgar (dan KERING), mengintegrasikan pola desain ke dalamnya dilengkapi dengan upaya ekstra minimal. Jika tidak, Anda harus menyesuaikan kode Anda untuk menerapkan pola desain.

Jika Anda harus melakukan banyak perubahan untuk menerapkan pola desain, masalah Anda bukan pola desain - itu adalah basis kode Anda yang monolitik, dan digabungkan secara ketat. Ini adalah masalah desain yang buruk / kurang optimal, bukan masalah pola desain.

Apa yang ingin saya ketahui adalah berapa banyak upaya yang harus saya lakukan dalam menciptakan level tambahan abstraksi dan desain, hanya untuk memungkinkan aplikasi saya mengikuti prinsip-prinsip OO seperti kopling longgar, programmign ke antarmuka, dll. Apakah itu benar-benar layak Itu? Berapa banyak usaha yang harus saya lakukan dalam hal ini?

Pertanyaan Anda membuat asumsi (tidak dinyatakan) bahwa satu-satunya manfaat dari kopling longgar adalah kemampuan untuk dengan mudah menerapkan pola desain. Bukan itu.

Di antara manfaat lepas kopling adalah:

• fleksibilitas refactoring dan desain ulang
• usaha yang kurang sia-sia
• testabilitas
• peningkatan kemungkinan untuk menggunakan kembali kode
• kesederhanaan desain
• lebih sedikit waktu yang dihabiskan dalam debugger

... dan beberapa lainnya yang tidak muncul di benak saya saat ini.