Bagaimana cara mundur dan melihat kode dengan mata segar? [Tutup]

Saya telah menghabiskan tahun lalu sebagai tim satu orang yang mengembangkan aplikasi klien kaya (35.000+ LoC, untuk apa nilainya). Saat ini stabil dan dalam produksi. Namun, saya tahu bahwa keterampilan saya berkarat pada awal proyek, jadi tanpa ragu ada masalah besar dalam kode. Pada titik ini, sebagian besar masalah adalah dalam arsitektur, struktur, dan interaksi - masalah mudah, bahkan masalah arsitektur / desain, telah disingkirkan.

Sayangnya, saya telah menghabiskan begitu banyak waktu dengan proyek ini sehingga saya mengalami kesulitan berpikir di luarnya - mendekati dari perspektif baru untuk melihat kelemahan yang terkubur atau melekat dalam desain.

Bagaimana saya melangkah keluar dari kepala saya dan di luar kode saya sehingga saya bisa mendapatkan tampilan yang segar dan membuatnya lebih baik?

Cara untuk mendekati ini:

• Temukan seseorang yang akrab dengan masalah teknologi dan bisnis dan bicarakan. Ini mungkin sulit dalam tim satu orang tetapi umumnya merupakan pilihan terbaik.
• Kerjakan proyek yang berbeda untuk sementara waktu. Ini juga mungkin sulit, tetapi bahkan istirahat seminggu dapat memberi Anda perspektif baru.
• Lihatlah proyek atau produk serupa, seperti produk sumber terbuka jika ada. Berhati-hatilah untuk tidak menyalin kode tetapi mereka mungkin telah mendekati ide yang sama sekali berbeda.
• Pelajari bahasa, perpustakaan, atau kerangka kerja baru. Teknik-teknik yang terlibat mungkin memberi Anda wawasan bagaimana mendekati masalah yang sama yang Anda miliki secara berbeda.
• Baca buku / blog / majalah yang bagus tentang desain atau bahasa / kerangka kerja. Saya tidak yakin tingkat keahlian Anda, tetapi ada banyak alternatif dalam jawaban lain di situs ini.

Jika Anda memiliki contoh spesifik yang ingin Anda tangani, mungkin kirimkan di sini.

Debugging bebek karet : Duduk dengan sepotong kode atau modul atau fitur dan menjelaskannya, dengan keras. Ketika Anda mendapati diri Anda mengatakan sesuatu yang terdengar salah, bodoh, atau sekadar tidak tepat, tuliskan itu sebagai masalah untuk diselidiki.

Teruslah belajar dan kembangkan keterampilan Anda. Sulit untuk mengetahui apa yang tidak Anda ketahui, tetapi ketika Anda melihatnya, momen "aha" itu akan memukul Anda. Itu bisa berasal dari belajar bahasa lain atau pola desain.

Anda akan diminta untuk melakukan perubahan. Anda mungkin menemukan bagian dari kode Anda yang tidak begitu fleksibel dan akan membutuhkan banyak pengerjaan ulang. Ini tidak selalu gagal karena Anda tidak bisa memikirkan semuanya pada awalnya.

Pengguna akan mulai mengeluh. Hanya ketika Anda berpikir semuanya hebat ...

Memori pendek membantu. Saya diketahui mengeluh tentang "idiot" yang mengubah sesuatu seminggu yang lalu, hanya untuk menemukan dari sumber kontrol itu saya.

Langkah pertama yang baik adalah mengidentifikasi kode yang dapat ditingkatkan. Lihat di kontrol sumber Anda untuk file yang paling sering berubah. Kode mana yang paling sulit untuk dikerjakan? Kode mana yang menghasilkan bug paling banyak? Jenis perubahan apa yang menyebabkan efek riak di seluruh kode? Pada tahap ini, Anda tidak perlu tahu mengapa kode ini merepotkan, hanya bahwa itu merepotkan.

Setelah Anda mengidentifikasi area yang akan dikerjakan, cobalah untuk mencari tahu apa masalahnya sebenarnya. Ada buku yang mengambil pendekatan sistematis untuk mengelompokkan masalah desain. Lihatlah Refactoring Martin Fowler , Standar Pengodean C ++ Herb Sutter , Robert Clean Code , dll. Mereka memiliki banyak "aturan" yang memungkinkan Anda melihat kode Anda dengan cara yang objektif.

Setelah Anda mengidentifikasi kemungkinan masalahnya, cobalah berbagai cara untuk memperbaikinya. Misalnya, jika aturan yang Anda langgar adalah "lebih suka komposisi daripada warisan," kemudian ubah ke komposisi dan lihat bagaimana rasanya.

Jelas, akan sangat membantu jika orang lain melihat kode tersebut, tetapi itu tidak selalu membantu seperti yang Anda pikirkan, karena Anda jauh lebih terbiasa dengan jenis masalah yang disebabkan oleh kode daripada orang lain, dan alasan di balik desain . Mempelajari beberapa cara untuk mengevaluasi secara objektif desain Anda sendiri akan menghasilkan banyak keuntungan.

Mintalah orang lain melihat kode Anda. Jika Anda tidak dapat menemukan orang lain untuk melihatnya, tulis deskripsi lengkap tentang interaksi seperti Anda akan menunjukkannya kepada orang lain. Proses mencoba menjelaskan keputusan Anda kepada orang lain (bahkan jika itu hanya untuk latihan) dapat membantu Anda benar-benar memikirkan MENGAPA Anda melakukan sesuatu dengan cara tertentu dan membantu Anda melihat adanya lubang dalam logika Anda.

Saya tahu situasi ini dengan sangat baik. Ketika saya terjebak dengan cara itu saya mencoba untuk mengambil sudut pandang yang berbeda pada proyek.

1.) sudut pandang Pengguna / pelanggan - gunakan umpan balik

Sayangnya kami terperangkap dalam kode kami sehingga kami tidak dapat melihat kekurangan kami sendiri karena kami menggunakan aplikasi kami dengan cara kami mengkodekannya. Lihatlah bagaimana orang menggunakannya dan mencoba mencari tahu apa yang akan menjadi panduan pengguna paling intuitif. Bermain-main dengan prototipe UI. Ini tampaknya menyenangkan, tetapi jika Anda mengetahui bahwa Anda akan dipaksa untuk mengkode ulang sebagian besar kode Anda hanya dengan mengubah logika penggunaan daripada saatnya untuk memulai siklus desain ulang.

2.) Lakukan analisis fungsional kode Anda dan visualisasikan

Beberapa IDE dan kerangka kerja mendorong Anda untuk, misalnya, mencampur UI dan kode backend. Jika Anda membiarkan ini terjadi, suatu hari Anda akan menghadapi situasi bahwa basis kode Anda sulit dipertahankan karena samar-samar dan sulit untuk memutuskan ketergantungan. Terutama pencampuran kode UI dengan kode lain dapat menyebabkan kode spaghetti dan fungsi yang berlebihan. Bagilah kode Anda dalam blok fungsional seperti misalnya kelas basis data, kelas komunikasi, kelas UI, kelas inti dll. Kemudian visualisasikan fungsionalitas dengan alat grafis (saya menggunakan alat pemetaan pikiran) untuk mengetahui apakah struktur Anda cukup logis dan modular sehingga Anda dapat menggunakan kembali blok kode besar untuk proyek yang berbeda dan Anda dapat menggantinya dengan versi yang lebih baru tanpa sakit besar.

Cara terbaik untuk melakukan ini dalam pengalaman saya adalah membuat dokumen yang memvisualisasikan semua dependensi antara kelas Anda dan panggilan mereka dari kode Anda. Hasilnya adalah visualisasi desain antarmuka Anda. Jika kode peta ini terlihat seperti *** clusterf lengkap daripada saatnya untuk bertindak. Jika belum terjadi, Anda harus memikirkan konvensi penamaan yang sesuai yang mewakili struktur kode Anda sehingga Anda tidak perlu memikirkan bagaimana memanggilnya dan apa fungsinya.

3.) Gunakan pendekatan umum untuk jaminan kualitas

Favorit saya adalah FMEA. Dalam hal pengkodean, ini berarti tidak hanya menganalisis apa yang salah di masa lalu, tetapi juga memikirkan apa yang bisa salah. Contoh yang cukup umum adalah koneksi jaringan yang tiba-tiba terputus. Setelah Anda melakukan ini, Anda dapat mengklasifikasikan kondisi kesalahan dengan konsekuensi seperti kehilangan data, kerusakan, perhitungan yang salah dan menilai dampaknya pada pengguna. Jika belum selesai, definisikan kesalahan efisien dan kelas pengecualian serta rutinitas dapat membantu Anda menjaga kode Anda tetap bersih dan lurus. Cara terbaik adalah menerapkannya dalam setiap ketenangan kode baru sebelum bahkan mulai menulis hal lain. (Yah, aku bersalah tidak selalu mengikuti saran ini sendiri.)

Selain itu membantu saya untuk menghasilkan dan sering memperbarui "daftar proposal perbaikan" untuk kode saya sendiri. (Sejujurnya masih ada banyak kode dalam proyek saya, saya pasti tidak bangga.) Saya juga mencoba meluangkan waktu untuk mengumpulkan dan melihat kode praktik terbaik dari dokumentasi API, konferensi pengembang atau majalah pengembang.

Hingga saat ini, Anda tidak perlu menyentuh kode Anda. Ini hanya tentang mengetahui apa yang salah dan menemukan cara untuk menentukan cara meningkatkan kode Anda.

Akhirnya beberapa tips untuk pekerjaan sehari-hari dari kentut tua. Cobalah untuk menghindari menggigit lebih banyak daripada yang bisa Anda makan. Ini menyebabkan terlalu banyak tekanan untuk pengkodean yang bersih. Anda jarang mendapatkan waktu untuk melakukannya dengan benar, tetapi Anda harus meluangkan waktu untuk memperbaiki kekurangan setelahnya.

Tidak ada yang tahan lama seperti solusi sementara, tetapi ketika rusak sering terlambat untuk memperbaikinya tepat waktu. Contohnya adalah peretasan yang tidak baik atau pengecualian aneh yang saya gunakan untuk mendapatkan sesuatu untuk bekerja walaupun misalnya cacat pada kerangka dasar atau OS. Dan kemudian cacat diperbaiki atau versi baru hanya menjatuhkan API ...

Jika Anda terjebak dan dipaksa untuk menemukan solusi daripada membuat komentar dan mencatat yang harus ditinjau dari waktu ke waktu. Biasanya kita menjadi lebih baik dan lebih baik karena mempelajari sesuatu yang baru. Jika Anda menemukan cara yang lebih baik mengimplementasikannya secepat mungkin. Kalau tidak, Anda mungkin akan menemukan diri Anda sedang mengkodekan solusi untuk solusi dan pengecualian pengecualian suatu hari. (Dia yang tanpa dosa di antara kamu, biarkan dia melemparkan byte pertama kepadaku.)

Jangan memusingkan hal-hal kecil.

Semua orang bisa kode lebih baik. Kami melakukan banyak hal dengan cepat dan kemudian menyadari beberapa minggu setelah itu bisa dilakukan dengan lebih efisien. Intinya adalah bahwa 90% dari kode Anda mungkin cukup baik.

Lihat log bug Anda dan temukan rutinitas yang mungkin menyebabkan masalah. Ketika Anda menemukan bug, Anda juga dapat meninjau kode dan memikirkan apa yang membuat kode lebih efisien. Sebagian besar waktu, Anda akan menyadari bahwa selain memperbaiki bug itu sendiri, Anda tidak akan dapat membuat peningkatan yang nyata, tetapi kadang-kadang, Anda akan menyadari bahwa ada cara yang lebih baik untuk melakukan sesuatu.

Berbicara dengan pengguna dan melihat di mana mereka memperhatikan masalah, baik masalah UX atau kecepatan. Perbaiki masalah ini, dengan perhatian untuk mencoba memperbaiki kode Anda.

Pada titik tertentu, Anda akan menemukan bahwa kode Anda menjadi terlalu rapuh dan tidak ada cara untuk melakukan perubahan yang perlu Anda lakukan. Kemudian pikirkan tentang bagaimana Anda bisa membuat sistem lebih fleksibel, baik melalui API atau pengembangan berbasis pengujian. Dalam banyak kasus, Anda akan menemukan bahwa Anda bisa mulai memasukkan API ini ke dalam kode, tanpa banyak perubahan. Dalam kasus lain, Anda akan menyadari bahwa upaya meningkatkan kode tidak sepadan.

Perubahan tambahan bisa sulit. Tujuannya adalah untuk tidak sepenuhnya menulis ulang basis kode jika Anda tidak perlu. Tentu, Anda seorang programmer yang lebih baik sekarang daripada setahun yang lalu, tetapi apa yang Anda miliki harus berfungsi sekarang. 5 tahun dari sekarang, ketika seorang programmer junior mengeluh kepada Anda tentang kode warisan yang harus mereka coba perbaiki, hanya tersenyum dan mengangguk, dan jangan mengakui bahwa Anda yang menulisnya.

Sudahkah Anda mempertimbangkan untuk pergi dan menemukan perusahaan di mana Anda bisa berada dalam tim? Saya merasa sangat kuat bahwa terisolasi atau dalam tim stagnan, pengembang kehilangan banyak profesi yang ditawarkan.

Peer reviews membiarkan seseorang yang sudah berada di luar kepala Anda memberikan saran Anda. Peninjauan Kode Stack Exchange mungkin tempat yang baik untuk mengeluarkan beberapa kode yang tidak khusus dimiliki perusahaan Anda untuk ditinjau. Mungkin tidak dapat menangani blok besar, tetapi banyak program dibuat dari banyak kode sederhana dan beberapa kode lain yang tidak sederhana dan menciptakan banyak masalah. Jika Anda memiliki contoh beberapa kode yang tipikal, tetapi diulang dan diubah di banyak tempat, itu mungkin juga kandidat peninjau yang baik. Misalnya, jika Anda memformat pesan, jangan minta semua pesan yang lewat ditinjau, cukup satu pesan contoh yang cukup kompleks.

Jika Anda ingin lebih objektif tentang kode Anda sendiri, saya kira Anda bisa membandingkannya dengan standar pengkodean, menjalankan pemeriksa kode statis atau dinamis di atasnya, atau jika Anda jarang didokumentasikan, menambahkan komentar mungkin membantu.

Ada psikologi pengujian yang membuatnya sulit untuk menguji kode Anda sendiri, tetapi kami tentu saja berusaha sebaik mungkin untuk melakukannya selama unit test. Membaca kode Anda sendiri bisa menjadi masalah yang serupa atau lebih buruk. Banyak bidang menggunakan mentor, penilaian kompetitif, pelatih, dll. Kami juga melakukannya jika Anda menghitung arsitek, insinyur sistem, dan penguji. Pelanggan dengan akses ke alat pelaporan bug atau departemen dukungan pelanggan akan memberi Anda umpan balik dari luar kepala Anda begitu produk dikirimkan. Ini adalah alasan bagus lainnya untuk pendekatan Agile dalam melepaskan lebih awal dan sering. Anda mungkin satu-satunya pengembang di perusahaan Anda, tetapi ada orang-orang yang terpengaruh oleh kode Anda yang dapat memberi Anda umpan balik tentang hal itu dari beberapa sudut.

"Apakah ini masalah yang lebih kecil daripada yang kupikirkan, atau apakah ini masalah yang dialami oleh orang lain juga?"

Sheesh. Sudah cukup. Jika kode dalam produksi, bebas bug dan melakukan apa yang seharusnya dilakukan, arsitektur tidak penting. Setidaknya untuk sekarang.

Semoga kita semua belajar sambil jalan. Saya telah menulis banyak kode yang saya banggakan pada saat saya menulisnya, hanya untuk memutuskan itu mengerikan satu atau dua tahun kemudian. Saat ini saya sedang mengerjakan proyek multiyear yang diisi dengan kode sangat luar biasa, tetapi kodenya berfungsi. Saya mengambil pendekatan yang sangat konservatif untuk menyentuh semua itu.

Dan seharusnya Anda juga. Jika Anda tidak melihat masalah arsitektur utama saat ini, setelah satu tahun bekerja, saya pikir mungkin aman bagi Anda untuk berasumsi, untuk saat ini, bahwa tidak ada yang penting. Ini bukan keahlian yang buruk. Ini bergerak maju.

Selain jawaban lain, saya akan merekomendasikan pergi ke konferensi pengembang.

Ini akan memaparkan Anda pada banyak topik dan orang-orang yang akan membuat Anda memikirkan aplikasi dan tempat kerja Anda sendiri. Terutama karena mereka akan berbicara tentang apa yang berhasil dan tidak untuk saat itu, dan masalah yang muncul. Ada kemungkinan besar bahwa ada beberapa tumpang tindih dengan aplikasi Anda.

Lebih disukai, butuh 3 hari untuk ini. Saya telah menemukan bahwa menjadi cukup lama untuk mendapatkan jarak mental yang diperlukan untuk pekerjaan saya sendiri dan melihatnya melalui mata komunitas yang lebih besar (sehingga untuk berbicara), daripada saya sendiri.

Kebetulan, ini juga berlaku untuk tim orang juga, karena groupthink dapat terjadi di mana saja.

Akhirnya, jika Anda tidak mendapatkan persetujuan untuk ini, katakan sekali setahun, ganti pekerjaan.

• Praktekkan pola desain dan praktik terbaik
• Pilih kerangka kerja, alat, paket dll berdasarkan kebutuhan dan kebutuhan aplikasi Anda - untuk ini Anda perlu membaca banyak blog etsa dan menemukan solusi untuk setiap masalah teknologi individu
• Buat rancangan / rancangan arsitektur dan diskusikan dengan seseorang yang ahli dalam hal teknis / arsitektur. Perbaiki draf ini menggunakan umpan balik dan komentar. terus lakukan ini sampai Anda mencapai kondisi stabil.

• Terapkan kode sedemikian rupa sehingga semua yang dibutuhkan aplikasi dapat dikonfigurasi dan dipelihara

  merancang ulang arsitektur dan mengimplementasikan proyek Anda pasti akan menghasilkan aplikasi yang memiliki konsistensi, kinerja, dll. yang lebih baik

Saya percaya bahwa 'menendang' kekhawatiran dengan beberapa orang pintar membantu. Perlu ada informasi spesifik. Apakah ini situs web 24x7x365? Aplikasi LoB? Di mana itu berjalan atau dihosting?

Setelah Anda mencapai tujuan inti dan hasil yang diinginkan, orang lain dapat membantu untuk memfokuskan dan mengarahkan perhatian Anda. Kode Anda mungkin merupakan kode terbaik yang pernah ditulis untuk satu tugas tertentu - atau yang terburuk. Tidak masalah - bagaimana hal itu memengaruhi tujuan yang diinginkan?