Pedoman Pengkodean: Metode tidak boleh mengandung lebih dari 7 pernyataan?

Saya sedang mencari di AvSol Coding Guidelines untuk C # dan saya setuju dengan hampir semuanya tetapi saya benar-benar ingin tahu apa pendapat orang lain tentang satu aturan spesifik.

AV1500

Metode tidak boleh melebihi 7 pernyataan. Metode yang membutuhkan lebih dari 7 pernyataan adalah melakukan terlalu banyak, atau memiliki terlalu banyak tanggung jawab. Itu juga membutuhkan pikiran manusia untuk menganalisis pernyataan yang tepat untuk memahami apa yang dilakukan kode. Hancurkan dalam beberapa metode kecil dan fokus dengan nama yang menjelaskan sendiri.

Apakah sebagian besar dari Anda mengikuti aturan ini? Sekalipun ada sedikit yang bisa diselamatkan dari membuat metode baru (Kode Anda masih KERING ) selain sangat mudah dibaca? Dan apakah nomor Anda masih serendah 7? Saya akan cenderung lebih ke 10.

Saya tidak mengatakan saya melanggar aturan ini di semua tempat - sebaliknya, metode saya 95% kecil dan fokus tetapi mengatakan Anda tidak boleh melanggar aturan ini benar-benar membuat saya terkejut.

Saya benar-benar hanya ingin tahu apa yang orang pikirkan tentang TIDAK PERNAH melanggar aturan ini (ini adalah '1' pada standar pengkodean - artinya TIDAK PERNAH melakukan ini). Tapi saya pikir Anda akan kesulitan menemukan basis kode yang tidak.

Ini adalah "bau standar" bagi saya. Setiap kali saya melihat standar pengkodean dengan batasan spesifik di dalamnya, saya khawatir. Anda hampir selalu mengalami kasus di mana metode harus lebih besar dari yang dibolehkan standar (apakah itu panjang / jumlah garis, jumlah variabel, jumlah titik keluar, dll). Standar harus lebih seperti pedoman, dan memungkinkan kelonggaran yang cukup untuk melakukan penilaian yang baik. Jangan salah paham, ada baiknya memiliki standar, tetapi seharusnya tidak menjadi "manajemen mikro dengan proxy".

Biasanya merupakan ide yang baik untuk membagi barang menjadi metode kecil. Tetapi yang penting adalah untuk membagi hal-hal yang masuk akal.

Jika tidak masuk akal untuk dibagi, maka jangan dibagi. Ini sering terjadi pada beberapa prosedur atau kode GUI.

Steve McConnell menyatakan dalam Code Complete bahwa Anda tidak selalu lebih produktif ketika menggunakan metode singkat. Jika Anda membagi ketika itu tidak masuk akal, Anda menambahkan kompleksitas ke kode tanpa manfaat.

Seperti biasa dengan pedoman, ada baiknya untuk mengingat mengapa kendala ada, sehingga Anda bisa belajar ketika itu tidak berlaku. Dalam sebagian besar kode metode akan pendek, atau Anda mungkin memiliki masalah dengan KERING atau pemisahan masalah . Tetapi jika tidak demikian, maka baiklah.

Itu harus dianggap sebagai aturan praktis.

Hal-hal seperti "Tidak lebih dari 80 (100.120) kolom teks", "satu titik keluar per metode", "tidak lebih dari 2 tingkat bersarang", adalah apa yang saya sebut ambang batas untuk indikator bau kode. Jika Anda melanggar mereka kadang-kadang, itu tidak berarti kode itu buruk. Jika Anda mendapati diri Anda melanggar mereka secara konsisten maka ada sesuatu yang berbau dalam kode dan Anda mungkin ingin berhenti sejenak dan memikirkan kembali pendekatan Anda.

Bagi saya, kriteria yang paling penting adalah, "Apakah kode ini dapat dimengerti?", "Apakah ini berulang?", "Apakah dipecah di tempat-tempat yang logis?", "Apakah dipasangkan secara longgar?" Ada beberapa lagi, tetapi saya pikir ide dasar dapat disimpulkan dengan mengingat nasihat Donald Knuth: "Program dimaksudkan untuk dibaca oleh manusia dan hanya secara kebetulan untuk komputer untuk dieksekusi."

Saya tidak pernah meluangkan waktu untuk benar-benar menghitung jumlah pernyataan dalam metode saya, tetapi saya berusaha keras untuk menulis metode yang secara bersih melakukan satu tujuan yang jelas. Selama kode Anda bersih, dapat dibaca, dan mengikuti prinsip KERING dan Tanggung Jawab Tunggal , Anda mungkin telah melakukan pekerjaan Anda. Saya pikir bahwa memisahkan metode secara terpisah hanya untuk menegakkan batas tujuh pernyataan dapat membuat kode Anda kurang dapat dibaca / dipelihara.

Ini perkiraan

Aturan seperti ini seharusnya tidak dianggap terlalu harfiah. Mereka bisa mengatakan " metode harus pendek ". Namun, beberapa orang akan menafsirkannya sebagai "kurang dari 1 halaman" dan yang lain sebagai "paling banyak 2 baris."

Saya akan berasumsi bahwa mereka mengatakan "7 pernyataan" untuk memberi Anda ide kasar (meskipun saya pikir mereka seharusnya mengatakan "sekitar 7"). Jika Anda membutuhkan 9 sesekali, jangan berkeringat. Tetapi jika Anda mencapai 20, Anda akan tahu Anda tidak berada di stadion baseball yang tepat untuk aturan ini.

7 adalah angka yang sepenuhnya arbitrer dengan sama sekali tidak penting.

Kompleksitas siklomatik adalah masalah yang lebih besar daripada jumlah pernyataan. Saya telah melihat kode yang memiliki 100 pernyataan dalam satu metode (yang saya pikir mengerikan), tetapi memiliki kompleksitas siklomatik 1 dan hanya benar-benar melakukan 1 hal. Hanya ada banyak langkah. Kami membahas memecahnya menjadi metode yang lebih kecil, tetapi metode itu hanya akan dipanggil dengan metode yang satu ini.

Sementara itu adalah kasus yang cukup ekstrim, intinya adalah Anda harus menjaga kode KERING dan kompleksitas siklomatik yang rendah. Itu lebih penting daripada jumlah garis dalam suatu metode.

Ambil pernyataan switch / case misalnya. Jika Anda memiliki lebih dari 7 nilai yang memungkinkan, apakah Anda perlu memecah evaluasi menjadi beberapa metode? Tentu saja tidak, itu konyol.

Memecah kode secara artifisial menjadi lebih banyak metode hanya untuk menjaga jumlah pernyataan di bawah 7 hanya membuat kode Anda lebih buruk.

Pedoman harus: Setiap metode harus melakukan 1 hal dan menjaga kode Anda KERING.

Yah, itu tergantung sedikit. Saya menulis banyak kode yang mengakses database. Kode pelat ketel untuk penanganan pengecualian lebih dari tujuh pernyataan dalam banyak kasus. Saya akan mengatakan pedoman terbaik adalah memastikan fungsi Anda memiliki satu tujuan

Semuanya adalah trade-off. Masalah dengan pendekatan yang diusulkan - refactoring ke dalam beberapa metode dan kelas sehingga masing-masing metode pendek - adalah bahwa meskipun karena alasan yang berbeda, itu mengarah pada kode yang tidak dapat dibaca ketika dibawa ke ekstremnya.

Bayangkan sebuah metode foo()yang melakukan 7 hal. Anda mungkin berpendapat bahwa 7 hal terlalu banyak. Mungkin dalam banyak kasus Anda benar. Di sisi lain, 7 hal ini mungkin terkait erat; Logikanya dapat mengalir dengan lancar dan membaca seperti prosa; Anda mungkin tidak kesulitan memahaminya saat Anda benar-benar perlu. Yang mungkin berakhir jauh lebih buruk adalah memiliki 7 hal itu didistribusikan di pohon sumber yang besar, sehingga jika Anda melihat foo()Anda tidak tahu apa yang dilakukannya tanpa melihat di 7 tempat yang berbeda.

Banyak orang mendapatkan aturan seperti ini di kepala mereka, dan hasilnya adalah apa yang saya anggap sebagai spaghetti OO. Semuanya rapi, dikemas dalam metode atau kelas kecilnya sendiri, dengan sedikit transaksi mikro yang terjadi di setiap tempat. Tetapi tidak mungkin untuk mengetahui basis kode seperti itu dan tahu apa yang dilakukannya. Anda menjadi tersesat.

itu bukan pedoman yang buruk. Saya tidak pernah menyesal membagi metode dan kelas (saya tidak pernah menemukan saya memiliki terlalu banyak) selama mereka dikelompokkan dan saling terkait dengan cukup baik.

Kuncinya adalah untuk TIDAK membaginya secara vertikal (Hanya mencubit metode pada satu titik dan memulai yang baru). Triknya, seperti halnya dengan pengujian unit, adalah dengan mengingat aturan seperti itu sejak awal sehingga Anda benar-benar mendesain lebih baik, meneruskan 3 atau 4 pernyataan di tengah metode ke metode lain karena memiliki pemanggilan metode menggambarkan apa yang Anda lakukan lebih baik daripada 3 atau 4 pernyataan di tengah-tengah kode Anda.

Pemecahan seperti ini, bahkan jika itu sewenang-wenang dan hanya digunakan sekali, dapat mengarah pada perbaikan yang lebih baik nantinya karena kejelasan kode yang baru, ini berlaku untuk kelas yang lebih kecil juga.

Pikirkan itu seperti Anda akan menguji unit. Jika Anda mencoba menambahkan pengujian unit setelah fakta itu sulit dan kadang-kadang tampaknya mustahil tetapi jika Anda mendesainnya dari awal itu sebenarnya membuat semua kode Anda lebih baik.

Ringkasan? Jika membandingkan aroma desain "Gunakan kurang dari 7 pernyataan" dengan aroma kode "Saya menggunakan lebih dari 7 pernyataan", saya lebih suka menghilangkan bau kode.

Wow! Saya tidak pernah berharap menemukan diskusi yang begitu intens tentang pedoman sederhana yang secara kasar mengatakan bahwa metode Anda harus sangat kecil. Karena mereka selalu pengembang yang ingin pedoman mereka menjadi eksplisit, saya memilih 7 karena itu terdengar seperti ambang batas yang bagus.

Beberapa dari Anda telah mengutip penafian di awal dokumen. Tetapi untuk memperjelas, dokumen ini mewakili kumpulan pedoman yang mencoba membantu Anda menulis kode yang lebih baik dan merancang sistem yang lebih baik. Saya tidak pernah menyatakan bahwa apa pun harus menjadi aturan, meskipun pedoman ditandai sebagai level 1. Level tersebut hanyalah pendapat kolektif dari banyak orang yang telah menggunakan dokumen ini untuk sementara waktu.

Saya juga tidak pernah mengaku sebagai ahli. Tapi saya sudah berkecimpung di profesi ini selama 15 tahun sekarang, dengan sekitar 4 tahun pengalaman C ++ dan 11 tahun pengalaman C #. Awalnya didasarkan pada Kekuatan Industri C ++, tapi saya telah memperbaikinya sejak itu dengan masukan dari komunitas.

Apapun, poin yang saya coba sampaikan adalah bahwa Anda harus terus berpikir untuk diri sendiri. Jika menurut Anda pedoman 7 pernyataan itu tidak berguna, daripada hanya membuatnya lebih lama. Heck, saya bahkan melanggar pedoman itu sesekali. Saya hanya melanggarnya dan menerima konsekuensinya.

Pertama: itu adalah pedoman, bukan aturan. Itu disebut pedoman, jadi tolong perlakukan itu seperti itu. Ini menyiratkan bahwa penilaian Anda sendiri juga diperlukan (seperti biasa)

Selain itu, saya dapat memikirkan banyak contoh kode yang baik yang tidak mematuhi batasan ini. Meskipun itu hanya panduan, ini adalah pedoman yang buruk.

Saya setuju dengan pernyataan di atas saya. Ini hanya panduan dan di dunia yang sempurna semuanya akan menjadi objek, digunakan kembali dalam setiap program, dan dunia akan menjadi tempat yang indah. Itu tidak selalu benar dan kadang-kadang itu akan menyebabkan banyak overhead atau sumber daya yang terbuang. Anda perlu mengingatnya juga.

Cukup konyol ketika Anda menambahkan penanganan pengecualian ke dalam campuran.

Setelah "coba, tangkap, akhirnya" Anda dibiarkan dengan empat pernyataan per metode!

Juga pertimbangkan metode "validateForm" untuk formulir 20 bidang, bahkan jika Anda menangani semua validasi individu dalam metode terpisah Anda masih memiliki 20 metode validasi bidang untuk dipanggil. Menurut pedoman ini, Anda akan berakhir dengan beberapa split pointless seperti "validateTopOfScreen", "validateMiddleOfScreen" dan "validateBottomOfScreen".

Pertanyaannya adalah menggabungkan "aturan" dengan "pedoman". Aturan dimaksudkan untuk dipatuhi - pedoman adalah saran yang dimaksudkan untuk membuat Anda mempertimbangkan apa yang Anda lakukan dan jika itu benar-benar dapat dilakukan dengan cara yang lebih baik.

Saya akan mengatakan, rata-rata, sebagian besar pemrograman mungkin ditingkatkan dengan mengikuti pedoman, tetapi akan selalu ada kasus-kasus di mana mengikuti pedoman ini secara dogmatis akan menyebabkan lebih banyak masalah daripada yang seharusnya mereka selesaikan. Itu sebabnya mereka tidak disajikan sebagai aturan, tetapi pedoman.

Penjawab sebelumnya telah menunjukkan bahwa para penulis pedoman tidak pernah bermaksud agar mereka diterapkan secara dogmatis dan memasukkan pernyataan tentang dampak itu dalam dokumen mereka.

Saya setuju dengan komentar di atas. 7 bagi saya adalah arbiter dan mungkin berguna dalam beberapa bahasa di mana ruby, tetapi untuk bahasa seperti C #, Java, C ++ Saya ragu dengan konvensi "7 baris" ini. Biarkan saya memberi Anda contoh. Aplikasi saya saat ini memiliki 22 bidang teks dan saya melakukan validasi sisi server. Metode ini disebut validateInput () dan preferensi saya memvalidasi semua bidang dalam satu metode itu sendiri kecuali saya telah memvalidasi sesuatu yang kompleks seperti checkEmailFormat (). Jadi pada dasarnya kode metode validateInput saya adalah 108 baris dengan panggilan sesekali ke validasi kompleks.

Sekarang bayangkan jika saya memanggil 25 metode untuk memvalidasi setiap bidang. Jika pengembang baru masuk, ia harus masuk dan keluar dari metode utama untuk melompat melalui 25 metode yang pada gilirannya mungkin memanggil beberapa lainnya. Dia pasti akan tersesat dalam proyek-proyek besar.

Apa yang sebenarnya saya lakukan untuk membuat kode saya jelas adalah memberikan komentar bersih yang pada dasarnya mengatakan apa yang dilakukan 4 baris ini ex -

validateInput (UserObj user) {

// Validasi nama depan ....... ......

// validasi Nama belakang ...... ......

// validasi email ..... // terlalu rumit untuk memeriksa format email expresion regular checkEmailFormat (); .... .....

dan seterusnya.. }

Aturan yang salah. Dengan kode untuk penanganan pengecualian, pengaturan bidang basis data, validasi, bagaimana sebagian besar metode berada di bawah tujuh pernyataan? Haruskah kita melakukan fungsi lambda sebaris?

Baris kode adalah hitungan kompleksitas yang berubah-ubah. Dengan metode ekstensi saya dapat membuat kode seperti

                Parallel.ForEach(regions, region => {   Console.Write(region.Resorts.Where(x => x.name == "Four Seasons").OrderBy(x => x.RegionId).ThenBy(x => x.ResortId).ThenBy(x => x.name).ToList());   });

Semua programmer junior harus dipaksa untuk mematuhi prinsip ini. Itu akan memaksa mereka untuk berpikir tentang struktur dari apa yang sibuk dengan mereka, alih-alih hanya menambahkan lebih banyak kode baris.

Saat ini saya sedang mencari metode 550 baris kode dengan banyak pernyataan if else dan berlanjut dan mengembalikannya. Ini omong kosong. Seandainya programmer hanya dipaksa untuk berpikir tentang apa yang dia lakukan ...