Bagaimana cara meyakinkan rekan tim saya bahwa kita tidak boleh mengabaikan peringatan kompiler?

Saya mengerjakan proyek besar (lebih seperti kombinasi puluhan proyek mini yang tidak dapat dipisahkan dengan mudah karena manajemen ketergantungan yang buruk, tapi itu diskusi yang berbeda) di Jawa menggunakan gerhana. Kami telah mematikan sejumlah peringatan dari pengaturan kompiler dan proyek masih memiliki lebih dari 10.000 peringatan.

Saya seorang pendukung besar untuk mencoba mengatasi semua peringatan, memperbaikinya semua jika mungkin, dan bagi mereka yang melihat ke dalam dan dianggap aman, tekan mereka. (Hal yang sama berlaku untuk obsesi keagamaan saya dengan menandai semua metode yang diimplementasikan / diganti sebagai @Override). Argumen terbesar saya adalah bahwa secara umum peringatan membantu Anda menemukan bug potensial selama waktu kompilasi. Mungkin dari 99 dari 100 kali, peringatannya tidak signifikan, tapi saya pikir kepala yang menggaruk itu menghemat satu kali mencegah bug besar, itu semua sepadan. (Alasan saya yang lain adalah OCD saya yang jelas dengan kode bersih).

Namun, banyak rekan tim saya tampaknya tidak peduli. Saya sesekali memperbaiki peringatan ketika saya menemukan mereka (tapi Anda tahu itu sulit ketika Anda menyentuh kode yang ditulis oleh rekan kerja). Sekarang dengan lebih banyak peringatan daripada kelas, keuntungan dari peringatan sangat diminimalkan, karena ketika peringatan adalah hal yang biasa, tidak ada yang akan repot-repot melihat semuanya.

Bagaimana saya bisa meyakinkan rekan tim saya (atau kekuatan yang ada) bahwa peringatan perlu ditangani (atau ditekan ketika diselidiki sepenuhnya)? Atau haruskah saya meyakinkan diri sendiri bahwa saya gila?

Terima kasih

(PS Saya lupa menyebutkan apa yang akhirnya mendorong saya untuk mengirim pertanyaan ini adalah saya sedih melihat bahwa saya memperbaiki peringatan lebih lambat daripada yang dihasilkan)

Anda dapat melakukan dua hal.

1. Tekankan bahwa peringatan ada karena suatu alasan. Penulis kompiler tidak memasukkan mereka karena mereka kejam. Orang-orang di industri kami umumnya sangat membantu. Banyak peringatan sangat membantu.

2. Kumpulkan riwayat kegagalan spektakuler yang muncul dari peringatan yang diabaikan. Pencarian web untuk "Perhatikan peringatan kompiler" mengembalikan beberapa anekdot.

Obsesi Anda @Overridebukanlah "obsesi". Itu adalah hal yang baik. Pernah salah mengeja nama metode?

Bacaan yang relevan di sini . C ++, tetapi masih relevan. Saya terutama menyukai contoh ini (komentar kode adalah milik saya):

int searchArray(int to_search[], int len, int to_find)
{
    int i;
    for( i = 0; i < len; ++i )
    {       
        if ( to_search[i] == to_find )
        {
            return i;
        }
    }
    // should be returning designated 'not found' value (0, -1, etc)
}

Sering kali, peringatan akan berarti perbedaan antara aplikasi mogok dengan kesalahan yang sebenarnya akan membantu Anda melacak cacat desain dan memperbaikinya (seperti pengindeksan yang aman ) atau aplikasi membuat asumsi dan kemudian benar-benar berperilaku salah atau cara yang salah (yang akan terjadi dengan typecasting tidak aman ). Demikian pula, mereka juga menunjukkan kode cacat atau mati yang dapat dihapus (blok kode tidak dapat dijangkau, variabel yang tidak digunakan), yang dapat dianggap optimasi kode, atau tidak diperhitungkan - untuk kasus yang akan muncul dalam pengujian, seperti contoh di atas untuk C ++. Perhatikan bahwa contoh ini menghasilkan kesalahan waktu kompilasi di Jawa.

Jadi, memperbaiki peringatan memiliki (setidaknya) beberapa keuntungan bagi manajemen:

1. Lebih sedikit peluang kode berperilaku tidak semestinya dengan data yang dimasukkan pengguna yang, bagi atasan yang peduli tentang citra perusahaan dan bagaimana menangani data kliennya, harus menjadi Masalah Besar (tm). Menabrak untuk mencegah pengguna melakukan sesuatu yang konyol lebih baik daripada tidak menabrak dan membiarkan mereka melakukannya.
2. Jika mereka ingin merombak personel, orang bisa masuk ke basis kode bebas-peringatan (dan tidak terlalu panik atau banyak mengeluh ..). Mungkin ini akan mengurangi jumlah gerutuan yang terjadi, atau pendapat tentang kelestarian atau kualitas kontribusi Tim X untuk Proyek Y.
3. Mengoptimalkan kode dengan menghapus peringatan kompiler, meskipun tidak memberikan peningkatan signifikan pada waktu berjalan, akan meningkatkan banyak skor saat melakukan pengujian:
   • Setiap skor cakupan kode kemungkinan akan meningkat.
   • Pengujian batas dan kasus uji yang tidak valid kemungkinan akan lebih sering berhasil (karena typecasting aman yang disebutkan di atas , antara lain).
   • Ketika sebuah test case gagal, Anda tidak perlu memikirkan apakah itu karena salah satu peringatan kompiler di file sumber itu.
   • Mudah diperdebatkan bahwa nol peringatan kompiler lebih baik daripada ribuan. Tidak ada peringatan atau kesalahan yang berbicara tentang kualitas kode, sehingga Anda dapat berargumen bahwa kualitas kode meningkatkan lebih sedikit peringatan yang ada.
4. Jika Anda tidak memiliki peringatan kompiler, dan satu atau lebih diperkenalkan, jauh lebih mudah untuk mengetahui siapa yang menyebabkan mereka muncul dalam basis kode. Jika Anda memiliki kebijakan "tidak ada peringatan", itu akan membantu mereka mengidentifikasi orang yang tidak melakukan pekerjaan dengan baik, mungkin? Menulis kode bukan hanya tentang membuat sesuatu bekerja, ini tentang membuatnya bekerja dengan baik .

Perhatikan bahwa saya masih seorang junior dev yang hanya tahu sedikit tentang manajemen proyek, jadi jika saya telah mengatakan sesuatu yang salah tolong perbaiki pemikiran saya dan beri saya kesempatan untuk mengedit sebelum Anda menurunkan saya dari keberadaan :)

Saya pernah mengerjakan proyek dengan karakteristik serupa di masa lalu. Yang satu ini pada mulanya ditulis di Jawa 1.4. Setelah Java 5 dengan obat generik keluar, orang dapat membayangkan jumlah peringatan yang dilemparkan oleh kompiler untuk setiap penggunaan API Koleksi.

Mungkin perlu beberapa waktu untuk menghilangkan semua peringatan, dengan mulai menggunakan obat generik. Itu adalah faktor yang harus diperhitungkan, tetapi ketika Anda harus meyakinkan seseorang (terutama manajer Anda) bahwa itu perlu diperbaiki, Anda akan memerlukan data yang sulit, seperti

waktu yang dihabiskan untuk bug dalam legacy atau kode yang tidak sesuai standar (standar adalah standar pengkodean proyek Anda) yang bisa dihindari.

Anda bisa terus menyajikan tagihan yang menunjukkan bagaimana Anda kehilangan waktu dan uang dengan mengabaikan peringatan "tertentu", dan seseorang akan mendapatkan ide. Bagian kuncinya adalah bahwa tidak semua peringatan layak dilihat, setidaknya tidak segera; dengan kata-kata yang lebih sederhana, Anda perlu menetapkan prioritas peringatan yang perlu ditangani segera. Untuk mulai dengan, pertimbangkan yang berkaitan dengan bug yang Anda lihat di proyek Anda.

Anda juga dapat membuat catatan di pelacak bug, ketika Anda memperbaiki bug, bahwa bug tersebut bisa dihindari dengan tidak mengabaikan peringatan (atau mungkin dengan menjalankan PMD atau FindBugs jika Anda memiliki CI atau membangun sistem). Selama ada cukup banyak bug yang dapat diperbaiki dengan mengindahkan peringatan kompiler, poin Anda tentang melihat peringatan kompiler akan valid. Kalau tidak, itu adalah keputusan bisnis, dan biasanya tidak sepadan dengan waktu yang dihabiskan untuk melawan pertempuran ini.

Jika Anda berhasil dan tim Anda memutuskan untuk mematuhi peringatan, Anda harus mengambil pendekatan langkah-bijaksana. Tidak ada yang bisa dan akan 10000 peringatan dalam satu waktu. Jadi, Anda dapat memilih yang paling penting (bug yang memiliki probabilitas tinggi) dan menonaktifkan yang kurang penting. Jika sudah diperbaiki, tambah lagi tingkat peringatan. Selain itu, Anda bisa mulai dengan FindBugs, yang memperingatkan kode yang hampir selalu berupa bug.

Saya sepenuhnya setuju dengan Anda, itu adalah praktik terbaik untuk membersihkan peringatan kompilasi sebanyak mungkin. Anda menyebutkan bahwa tim Anda menggunakan Eclipse sebagai alat pengembangan. Eclipse adalah alat yang sangat baik untuk membantu Anda membersihkan kode dan membuat konsistensi gaya kode.

1. tentukan 'Simpan tindakan' untuk setiap proyek Java Anda, seperti memformat kode, variabel lokal yang tidak digunakan, mengatur impor (saya pikir tidak ada yang keberatan dengan pembersihan semacam itu).
2. mendefinisikan opsi kompilasi spesifik proyek untuk setiap proyek. Misalnya, kompilasi level (jika kode Anda harus kompatibel dengan 1.4 untuk membersihkan peringatan yang terkait dengan generik), tugas tidak memiliki efek (misalnya 'x = x') dan sebagainya. Anda dan rekan satu tim Anda dapat membuat kesepakatan untuk item-item itu, dan Eclipse akan melaporkannya sebagai 'Kesalahan' dalam fase pengembangan Anda setelah Anda memiliki kesepakatan untuk kesalahan kompilasi.

Eclipse akan membuat beberapa file properti untuk preferensi tersebut di bawah folder .settings, Anda dapat menyalinnya ke proyek Java lainnya dan memeriksanya di SCM sebagai bagian dari kode sumber.

Anda dapat memeriksa kode Eclipse untuk melihat bagaimana pengembang Eclipse melakukannya.

Anda memiliki dua cara untuk menghilangkan semua peringatan (dan saya setuju itu dapat menyembunyikan bug halus):

1. Yakinkan seluruh tim bahwa ini adalah hal terbaik untuk dilakukan, dan minta mereka memperbaikinya.
2. Yakinkan bos Anda bahwa ini adalah hal terbaik untuk dilakukan, dan buatlah itu wajib. Maka mereka perlu memperbaikinya.

Saya percaya bahwa 1 tidak layak dalam kasus Anda lagi. Mungkin ini juga akan memakan waktu lama karena banyaknya peringatan yang akan ditampilkan dalam output produktivitas sehingga manajemen perlu mengetahui pula.

Jadi, saran saya adalah: Angkat dengan bos, yakinkan dia ini bom yang berdetak, dan minta dibuatkan kebijakan resmi.

Saya hanya akan mengatakan kepada mereka bahwa sebagian besar dari ini adalah peringatan yang tidak penting dan sangat penting bagi kita untuk menghapusnya dari daftar. Sehingga kita tidak akan melewatkan peringatan signifikan nyata di tengah orang banyak, seperti yang terjadi!

Anda akan membutuhkan banyak kesabaran dalam mencoba meyakinkan mereka, menghapus peringatan ketika melakukan pemrograman pasangan akan membantu orang lain mengambil kebiasaan itu. Sarankan mereka untuk membaca Java Efektif 'Item 24: Menghilangkan peringatan yang tidak dicentang' (untuk koleksi umum). Dan mungkin mengabaikan banyak contoh ketika orang tidak mengikuti saran Anda;)

Pendekatan yang efektif di sini adalah dengan menyiapkan server Integrasi Berkelanjutan yang secara otomatis membangun proyek dan menjalankan tes setiap kali ada orang yang memeriksa kode. Jika Anda belum menggunakan ini, Anda harus melakukannya, dan tidak terlalu sulit untuk meyakinkan orang lain tentang manfaat melakukannya.

1. Meyakinkan manajemen / tim tentang manfaat melakukan hal ini (mencegah pembangunan yang buruk dari penyebaran, menemukan bug lebih awal, terutama yang secara tidak sengaja memengaruhi bagian lain dari perangkat lunak, mempertahankan pengujian regresi, pengujian awal dan sering, dll.)

2. Instal server CI dengan semua tes lulus (jika Anda tidak memiliki tes, tulis tes cepat yang lulus, sehingga semua orang melihat bahwa itu hijau).

3. Siapkan email atau pemberitahuan lain tentang status setiap bangunan. Penting di sini untuk memasukkan siapa yang memeriksa dalam kode, apa perubahannya (atau tautan ke komit), dan status + output dari build. Ini adalah langkah penting, karena menyebabkan visibilitas di seluruh tim baik untuk kesuksesan maupun untuk kegagalan.

4. Perbarui server CI untuk membuat tes gagal jika ada peringatan. Ini akan dilihat oleh pimpinan dan pimpinan tim sebagai peningkatan disiplin tim secara sistematis, dan tidak ada yang mau bertanggung jawab atas semua kegagalan email yang keluar.

5. (opsional) dapatkan baik dan culun dengan ini, dengan menambahkan beberapa dashboard terlihat, lampu lava, lampu berkedip, dll untuk menunjukkan status membangun dan siapa yang merusak / memperbaikinya.