Bagaimana saya bisa mendefinisikan dan mengukur kesederhanaan dalam kode?

Ada banyak jawaban dalam pertanyaan saya sebelumnya tentang kesederhanaan yang berkaitan dengan keterbacaan yang membantu saya melihat definisi dan pemahaman saya tentang kesederhanaan dalam kode, sangat mungkin, salah.

Bagaimana saya bisa mendefinisikan kesederhanaan dalam kode? Pengukuran dan metrik perangkat lunak apa yang tersedia untuk mengukur kesederhanaan kode?

Metrik yang paling umum untuk mengukur kompleksitas (atau kesederhanaan, jika Anda menganggap kesederhanaan sebagai kebalikan dari kompleksitas) adalah Kompleksitas Sikomatik McCabe dan Metrik Kompleksitas Halstead .

Kompleksitas siklus mengukur jumlah jalur yang berbeda melalui unit yang diberikan, biasanya metode atau fungsi, meskipun juga dapat dihitung pada kelas. Dengan meningkatnya jumlah jalur, menjadi lebih sulit untuk mengingat aliran data melalui modul yang diberikan, yang terkait dengan konsep memori kerja . Kompleksitas siklomatik yang tinggi cenderung mengindikasikan kesulitan dalam kemampuan untuk menguji suatu modul - dibutuhkan lebih banyak kasus uji untuk mencakup berbagai jalur melalui sistem. Ada juga penelitian yang mengaitkan kompleksitas siklomatik yang tinggi dengan tingkat cacat yang tinggi. Biasanya, kerumitan siklomatik 10 menunjukkan bahwa suatu unit harus ditinjau dan mungkin dire-reforasi.

Langkah-langkah kompleksitas Halstead menggunakan input dari operator dan operan total dan berbeda untuk menghitung volume, kesulitan, dan upaya sepotong kode. Kesulitan, yang merupakan (jumlah operator unik / 2) * (jumlah total operan / jumlah operan unik), terkait dengan kemampuan membaca dan memahami kode untuk tugas-tugas seperti mempelajari sistem atau melakukan tinjauan kode. Sekali lagi, Anda dapat menghitung ini pada level sistem, level kelas, atau level metode / fungsi. Ada beberapa posting tentang menghitung pengukuran ini di sini dan sini .

Hanya dengan menghitung baris kode juga dapat memberi Anda gambaran tentang kompleksitas. Semakin banyak baris kode berarti ada lebih banyak untuk dibaca dan dipahami dalam modul. Saya akan ragu untuk menggunakan ini sebagai ukuran yang berdiri sendiri. Sebagai gantinya, saya akan menggunakannya dengan pengukuran lain, seperti jumlah cacat dalam modul yang diberikan untuk mendapatkan kepadatan cacat. Kerapatan cacat yang tinggi dapat mengindikasikan masalah dalam penulisan tes dan pelaksanaan tinjauan kode, yang mungkin atau mungkin tidak disebabkan oleh kode kompleks.

Fan-in dan fan-out adalah dua metrik lainnya, terkait dengan aliran data. Seperti yang didefinisikan di sini , fan in adalah jumlah dari prosedur yang disebut, pembacaan parameter, dan variabel global read and fan out adalah jumlah dari prosedur yang memanggil prosedur yang diberikan, parameter yang ditulis (diekspos ke pengguna luar, diteruskan dengan referensi), dan variabel global yang ditulis untuk. Sekali lagi, fan-in dan fan-out yang tinggi mungkin mengindikasikan modul yang mungkin sulit untuk dipahami.

Dalam paradigma tertentu, mungkin ada tindakan atau metrik lain yang juga berguna. Sebagai contoh, di dunia berorientasi objek, pemantauan kopling (keinginan rendah), kohesi (keinginan tinggi), dan kedalaman warisan (keinginan rendah) dapat digunakan untuk menilai seberapa sederhana atau rumit suatu sistem.

Tentu saja, penting untuk menyadari bahwa banyak tindakan dan metrik hanyalah indikator. Anda perlu menggunakan penilaian Anda untuk menentukan apakah perlu refactor untuk meningkatkan kesederhanaan atau jika itu tidak sepadan dengan upaya untuk melakukannya. Anda dapat melakukan pengukuran, menghitung metrik, dan mempelajari kode Anda, tetapi Anda tidak ingin mendesain sistem Anda dengan angka. Pada akhirnya, lakukan apa yang masuk akal.

Alih-alih melihat mode formal mendefinisikan kesederhanaan, saya lebih suka mendefinisikan kesederhanaan sebagai atribut kualitas penulisan kode.

Saya tidak menaruh sedikit kesederhanaan tetapi kapan Anda menyebut sesuatu yang sederhana atau tidak.

1. Kode Traversal:
Seberapa mudah untuk menavigasi kode? Apakah mudah dikenali dari mana fungsi API ditulis? Apakah mudah untuk memahami aliran panggilan, misalnya metode mana yang memanggil orang lain (dan mengapa) - apakah ada mesin negara yang baik diimplementasikan atau algoritma yang diidentifikasi dengan bersih?

Ketika traversal kode mudah, kode mudah diikuti.

2. Penamaan
Sementara standar pengkodean lainnya membantu membuat kode terlihat lebih bersih - yang paling penting adalah penamaan kelas / objek-instance / Variabel / metode. The Penggunaan nama jelas dan tidak ambigu jelas memiliki dampak yang besar pada Kesederhanaan kode. Ketika sulit untuk mengidentifikasi nama yang sederhana, itu adalah tanda bahwa Anda mungkin ingin memikirkan kembali idenya sebagai variabel / metode tersebut.

3. Interpretasi dan referensi
Apakah setiap metode Anda memiliki peran yang jelas untuk dimainkan. Apakah setiap variabel / atribut mudah untuk menentukan peran yang mereka mainkan? Ketika sepotong kode melakukan sesuatu yang menyiratkan asumsi atau mempengaruhi set variabel yang tidak terkait, bisa menjadi mimpi buruk pemeliharaan.

4. Ketergantungan atau penggabungan
Ini sulit untuk dinilai hanya dengan melihat kode, tetapi menjadi sangat jelas jika seseorang mencoba untuk memperbaiki bug Anda. Ketika beberapa hal lain berubah di beberapa objek lain, apakah operasi di sini berubah? Apakah perubahan itu jelas? Apakah Anda perlu mengubah API begitu sering untuk mengakomodasi hal-hal. Ini menunjukkan bahwa hubungan antar moda tidak sederhana

5. Input Pengguna atau Aplikasi
Akhirnya seberapa sederhana input atau aplikasi pengguna diterima di API / UI? Ketika beberapa kemungkinan Pengguna / Aplikasi (untuk tujuan yang berbeda) perlu memberi Anda - apakah sudah jelas? Apakah ada status / detail yang tidak terkait dengan abstraksi yang lebih tinggi tetapi masih berjalan mundur antarmuka?

Pertanyaan sederhana yang biasanya saya tanyakan adalah sebagai berikut: Jika alih-alih sebuah program, jika saya akan meminta fungsi yang sama dilakukan oleh manusia, akankah saya mengisi informasi ini pada formulir kertas ? Jika tidak, saya tidak cukup sederhana di sini.

Saya tidak akan mengatakan daftar ini lengkap, tetapi saya tetapi saya kira kriteria adalah seberapa mudah atau sulit untuk menggunakan dan memodifikasi perangkat lunak. Itu sederhana.

Saya tidak mengetahui adanya metrik yang ada untuk kesederhanaan kode (itu tidak berarti mereka tidak ada - hanya saja saya tidak tahu tentang mereka). Saya bisa mengusulkan beberapa, mungkin beberapa akan membantu:

• Kesederhanaan fitur bahasa yang digunakan: jika bahasa tersebut memiliki fitur yang mungkin dianggap "canggih" dan "sederhana" Anda dapat menghitung jumlah kemunculan fitur-fitur canggih. Bagaimana Anda mendefinisikan "lanjutan" mungkin sedikit lebih subjektif. Saya kira beberapa orang mungkin mengatakan ini juga seperti mengukur "kepintaran" suatu program. Contoh umum: beberapa mungkin mengatakan bahwa ?:operator harus menjadi fitur "lanjutan", yang lain mungkin tidak setuju. Saya tidak tahu betapa mudahnya menulis alat yang bisa menguji ini.

• Kesederhanaan konstruk dalam program: Anda bisa mengukur jumlah parameter yang akan diterima fungsi. Jika Anda memiliki> n % dari semua fungsi dengan> parameter m , Anda dapat memilih untuk menghitungnya sebagai tidak sederhana, tergantung pada bagaimana Anda mendefinisikan n dan m (mungkin n = 3 dan m = 6?). Saya pikir ada beberapa alat analisis statis yang dapat mengukur ini - saya pikir JTest hanya mengukur fungsi dengan parameter > m .

• Anda bisa mencoba menghitung jumlah loop bersarang atau struktur kontrol. Ini saya pikir sebenarnya bukan metrik yang buruk dan saya pikir ada nama untuk itu (tidak dapat mengingat bagian atas kepala saya). Sekali lagi, saya pikir ada alat (sekali lagi, seperti JTest) yang dapat mengukur ini, sampai taraf tertentu.

• Anda bisa mencoba mengukur "refactorability". Jika kode Anda mengandung banyak potongan kode yang bisa dire-refored tetapi tidak , mungkin itu bisa tidak sederhana. Saya juga ingat dari waktu saya bekerja dengan JTest yang mencoba mengukur ini juga, tapi saya ingat saya tidak sering setuju dengan itu dalam kasus ini, jadi YMMV.

• Anda dapat mencoba mengukur jumlah lapisan di antara berbagai bagian sistem Anda. Sebagai contoh: berapa banyak potongan kode yang akan menyentuh data yang berasal dari formulir web sebelum disimpan dalam database? Ini bisa menjadi rumit untuk mengukur dengan benar ...