Pada titik tertentu program sedang dalam pengembangan. Fitur sedang ditambahkan atau dihapus atau diubah sepanjang waktu. Setiap versi hanyalah prototipe. Jadi saya tidak membuang banyak waktu untuk menulis kode super bersih pada saat itu karena saya tidak pernah tahu berapa lama sesuatu berlangsung. Tentu saja saya mencoba untuk menjaga kualitas kode ke standar tertentu, tetapi waktu selalu menjadi masalah.
Kemudian tibalah titik di mana program selesai dan pembuat keputusan mengatakan "itu saja". Saya memang memiliki prototipe yang berfungsi pada saat ini, tetapi kode di dalamnya agak berantakan dari semua bolak-balik selama fase pengembangan. Saya diharapkan untuk memulai pengujian / debugging akhir tetapi nyali saya mengatakan bahwa saya sekarang harus entah bagaimana membersihkan dan atau menulis ulang hal-hal untuk memberikan arsitektur yang tepat yang membuat pemeliharaan dll lebih mudah.
Setelah barang diuji dan disetujui, tidak masuk akal untuk menulis ulang. Secara teratur saya berdiri di sana dengan prototipe 'selesai' yang berfungsi dan saya mendapatkan bug selama pengujian dan saya melihat bahwa itu adalah hasil dari pengkodean yang tidak cerdas yang merupakan hasil dari seluruh proses pengembangan. Saya di tengah pengujian dan perbaikan bug akan menjadi penulisan ulang ... itu berantakan!
Ada cara yang lebih baik / buku teks, saya yakin. Tetapi saya harus bekerja di lingkungan kerja nyata di mana tidak semua buku teks.
Jadi bagaimana cara mentransisikan prototipe kerja saya ke versi rilis dengan basis kode yang stabil? Mungkin saya seharusnya tidak menganggap pengembangan selesai begitu saya lakukan dan benar-benar melihatnya sebagai fase pembersihan ... Saya tidak tahu, saya butuh bantuan di sini.
SUNTING
Saya ingin mengklarifikasi beberapa hal.
Saya 100% di sisi melakukannya tepat sebelum dan tidak setelah, kode bersih dan mudah dibaca. Tetapi saya juga harus menyelesaikan sesuatu dan tidak bisa bermimpi tentang keindahan kode semua bersih dan mengkilap. Saya harus mencari kompromi.
Seringkali fitur baru benar-benar hanya sesuatu yang ingin kita coba dan lihat apakah masuk akal untuk mengimplementasikan sesuatu seperti ini. (khususnya dalam aplikasi seluler, untuk mendapatkan tampilan dan rasa yang nyata pada perangkat yang sebenarnya) Jadi itu adalah sesuatu yang kecil yang (imho) tidak membenarkan terlalu banyak pekerjaan dalam iterasi "mari kita lihat" pertama. Namun terkadang muncul pertanyaan KAPAN saya membayar tech.debt ini? Itulah pertanyaan tentang ini.
Jika saya tahu bahwa setengah dari fitur-fiturnya akan hilang satu hari kemudian (cukup pengalaman di perusahaan kami sekarang), saya benar-benar merasa sulit untuk percaya bahwa cara terbaik untuk mendekati masalah saya adalah dengan menginvestasikan waktu ekstra untuk menulis semuanya dengan bersih bahkan jika sebagian besar akan jatuh segera setelahnya. Rasanya bagi saya bahwa saya akan menghemat waktu jika saya melakukan satu pembersihan besar setelah semuanya padat, maka pertanyaan saya.
sumber
Jawaban:
Tidak tahu berapa lama sesuatu berlangsung seharusnya tidak menjadi alasan untuk kecerobohan - justru sebaliknya. Kode terbersih adalah IMHO yang tidak menghalangi Anda ketika Anda harus mengubah sesuatu. Jadi rekomendasi saya adalah: selalu mencoba untuk menulis kode terbersih yang Anda bisa - terutama ketika pengkodean prototipe. Karena akan jauh lebih mudah untuk mengadaptasinya ketika sesuatu harus diubah (yang pasti akan terjadi).
Jangan salah paham - pemahaman saya tentang "kode terbersih" tidak ada hubungannya dengan menjadikan kode cantik demi kecantikan. Itu memang sesuatu yang bisa memperlambat Anda. Dalam pandangan saya, kode bersih adalah kode yang sebagian besar menjelaskan sendiri (tidak perlu menulis begitu banyak dokumen - menyebabkan percepatan), mudah dimengerti (lebih sedikit kesalahan, sehingga lebih sedikit diperlukan debugging - percepatan, lebih sedikit waktu yang diperlukan untuk menemukan yang benar tempat untuk mengubah - speedup), memecahkan masalah yang diberikan dengan jumlah paling sedikit kode yang diperlukan (kode kurang untuk debug - speedup jelas), adalah KERING (hanya satu tempat untuk mengubah ketika sesuatu harus diubah - speedup - dan lebih sedikit risiko untuk memperkenalkan bug baru dengan lupa mengubah tempat kedua), mengikuti standar pengkodean (hal-hal yang kurang rumit untuk dipikirkan - speedup), menggunakan yang kecil,
Melakukan "pembersihan" sesudahnya tidak pernah berhasil. Pertimbangkan Anda membersihkan sebelum menerapkan fitur baru, atau ketika mulai mengimplementasikannya, tetapi tidak setelahnya. Misalnya, setiap kali Anda mulai menyentuh metode untuk suatu fitur, dan Anda melihatnya lebih lama dari 10 baris, pertimbangkan untuk mengubahnya menjadi metode yang lebih kecil - segera , sebelum mendapatkan fitur lengkap. Setiap kali Anda mendeteksi variabel atau nama fungsi yang ada, Anda tidak tahu persis apa artinya, cari tahu apa yang baik untuk dan ganti nama benda itu sebelum melakukan hal lain. Jika Anda melakukan ini secara teratur, Anda menyimpan kode Anda setidaknya dalam keadaan "cukup bersih". Dan Anda mulai menghemat waktu - karena Anda membutuhkan lebih sedikit waktu untuk debugging.
... yang merupakan bukti aktual untuk apa yang saya tulis di atas: menjadi "kotor" menghantui Anda segera ketika Anda mulai men-debug kode Anda dan akan membuat Anda lebih lambat.
Anda dapat menghindari ini hampir sepenuhnya jika Anda segera melakukan pembersihan. Maka perbaikan bug sebagian besar akan berarti perubahan kecil pada kode, tetapi tidak pernah merupakan perubahan arsitektur utama. Jika Anda benar-benar mendeteksi bukti untuk perbaikan arsitektur selama pengujian, tunda, masukkan ke dalam sistem pelacakan masalah Anda, dan terapkan saat Anda harus mengimplementasikan fitur yang mendapat manfaat dari perubahan itu ( sebelum Anda mulai dengan fitur itu).
Ini membutuhkan beberapa disiplin, dan beberapa pengalaman pengkodean, tentu saja. Ini adalah ide yang mirip seperti ide di balik "pengembangan yang didorong oleh pengujian", melakukan hal-hal ini sebelumnya alih-alih melakukannya setelah itu (TDD dapat membantu juga, tetapi apa yang saya tulis bekerja bahkan ketika Anda tidak menggunakan TDD). Ketika Anda melakukan ini secara konsekuen, Anda tidak akan memerlukan "fase pembersihan" khusus sebelum melepaskan.
sumber
Anda memiliki dua masalah terpisah, keduanya dengan gejala yang sama (kode ceroboh):
Masalah # 1: Kontrol persyaratan yang tidak mencukupi Saya tidak bermaksud bahwa pemangku kepentingan Anda terlalu sering mengubah persyaratan Anda, maksud saya bahwa Anda mengizinkan perubahan persyaratan selama siklus perbaikan / pengujian bug. Bahkan metodologi gesit tidak mendukung itu; Anda membangun, Anda menguji, Anda memberikan, Anda menyuntikkan persyaratan baru.
Masalah # 2: Anda yakin bahwa hal-hal yang Anda tulis adalah "hanya untuk saat ini" Dalam pengembangan perangkat lunak "hanya untuk saat ini" kode sangat jarang. Anda telah memperhatikan diri sendiri bahwa sekali Anda telah memenuhi persyaratan pengguna, kerasnya penawaran dan permintaan membuatnya sangat sulit untuk dibenarkan untuk kembali dan menerapkan kembali fitur "selesai". Jadi, apa yang harus dilakukan? Selalu tulis kode produksi. Secara fungsional untuk Anda, itu berarti estimasi Anda untuk pemangku kepentingan Anda harus jauh lebih besar sehingga Anda punya waktu untuk melakukannya dengan benar.
Selain itu, harap dipahami bahwa Anda bekerja di posisi yang paling sulit sebagai pengembang: Baca pendapat Joel Spolsky tentang kehidupan pengembang in-house . Jadi, Anda harus ekstra waspada jika ingin menjalin kewarasan.
sumber
Ini adalah masalah umum - terutama ketika membuat apa yang pada dasarnya adalah balon percobaan perangkat lunak .
Ada sejumlah pendekatan yang dapat membantu. Pertama TDD pendekatan dapat membantu mengurangi basis kode dengan yang benar-benar diperlukan. Jika tes Anda berjalan seiring dengan kode Anda, maka Anda setidaknya dapat memiliki keyakinan bahwa kode Anda berperilaku sebagaimana mestinya.
Luangkan waktu untuk refactor saat Anda pergi. Setelah Anda memiliki prototipe dan pelanggan sangat bersemangat untuk mendapatkannya, sulit untuk mengatakan bahwa Anda perlu waktu untuk memoles apa (kepada mereka) yang lengkap. Saya suka check-in setiap hari diikuti dengan check-in refactor tapi YMMV.
Pengembang yang menulis kode dengan cepat sering diminta - kami memiliki pengembang seperti itu di departemen terakhir saya. Setiap tim menginginkannya karena dia bekerja sangat cepat. Namun, begitu tiba saatnya untuk menguji dan melepaskan kodenya, roda dengan cepat terlepas. Kode, retasan, dan pintasan berkode keras di mana-mana. Stoknya segera jatuh - secara besar-besaran.
Memotong kode produksi sejak awal bisa terlihat seperti hambatan tetapi tergantung pada lingkungan Anda, ada banyak alat yang dapat menghilangkan perkembangan seperti Ghostdoc dan Stylecop .
Perlu mendapatkan pola pikir pengembangan yang benar sejak awal. Anda akan terkejut betapa banyak sistem back-of-a-fag-paket yang seharusnya hanya solusi stop-gap menjadi aplikasi landasan.
sumber
Terus menerus
Kecepatan pengembangan adalah alasan utama untuk menulis kode yang bersih, mudah dibaca, dan dapat diuji; itu tidak dilakukan untuk kecantikan, atau nilai-nilai abstrak lainnya. Mengapa saya menolak itu untuk diri saya sendiri dan hanya melakukannya setelah itu untuk beberapa programmer di masa depan?
Tentu mungkin ada perubahan yang sebagian besar kosmetik dan karena itu tidak penting; Saya berpendapat bahwa jauh lebih bermanfaat untuk memiliki kode yang cukup bagus saat ini, selama pengembangan, daripada memiliki kekacauan sekarang dan berharap untuk membuatnya sempurna nanti (yang, mari kita hadapi itu, itu tidak akan pernah terjadi, bahkan jika Anda memiliki waktu).
sumber
Anda melakukan ini dengan membedakan antara "Saya hanya mencoba ini untuk melihat cara kerjanya" kode dan "ini menuju ke dalam produk" kode. Ada sejumlah cara untuk melakukannya.
Satu bercabang atau apa pun kata itu dalam sistem kontrol sumber Anda. Anda membuat cabang untuk laporan baru atau tata letak impor baru atau apa pun. Jika orang menyukainya, pekerjaan untuk mengembalikannya ke cabang utama adalah pekerjaan yang terpisah dan dapat dilacak. Itu dapat ditugaskan kepada seseorang dan dilaporkan dan tidak diharapkan terjadi secara ajaib manajemen hari (atau penjualan) setuju bahwa fitur tersebut termasuk dalam produk.
Lainnya adalah paku. Anda tidak melakukan perubahan pada produk. Anda pergi ke beberapa aplikasi terpisah, super sederhana, yang hanya ada bagi Anda untuk memiliki tempat untuk meletakkan kode. Anda bisa berantakan seperti yang Anda inginkan karena Anda hanya menjelajahi API baru atau apa pun. Dan lagi, jika Anda kembali dan melaporkan "ya, kami bisa melakukan itu, saya telah menemukan caranya" ada tugas yang dapat dilacak, dapat dilaporkan, tugas yang dapat ditugasi untuk menulis kode siap-produk dalam produk untuk melakukan apa yang Anda inginkan.
Dalam kedua kasus tersebut, produk-siap berarti dapat dibaca, rapi, mengikuti standar penamaan, dengan tes, dan mengikuti gaya kode dan target kinerja Anda. Dalam kedua kasus, Anda membuat pekerjaan itu terlihat. Saya setuju bahwa Anda tidak ingin melakukan semua itu bekerja setiap kali ketika seseorang sangat mungkin untuk menarik kembali fitur dari produk. Tetapi Anda juga tidak ingin pekerjaan itu tidak terlihat. Bekerja dalam salinan terpisah dari produk atau dalam produk yang tidak terkait yang tidak lebih dari test harness memungkinkan Anda memunculkan pekerjaan untuk membuat kode siap-produk begitu seseorang memutuskan mereka menginginkan sesuatu.
Kelemahannya adalah mereka tidak dapat memutuskan mereka menginginkan sesuatu dan mengirimkannya (artinya setengah-setengah, berantakan, tidak teruji, tidak berdokumen, mungkin setengah versi yang telah Anda laksanakan sebagai bukti konsep) besok. Mereka pertama kali Anda mendapatkan pushback di bagian depan itu, cukup tanyakan apakah Anda harus melakukannya dengan cara panjang (lebih mahal) setiap kali untuk berjaga-jaga, memperlambat jalan menuju fitur yang ditolak. Jika Anda bertanya dengan benar, Anda akan mendapat "tidak".
sumber
Sungguh saya pikir Anda sudah memahami masalahnya. Masalahnya adalah bahwa gaya pengkodean Anda mengharuskan Anda melakukan terlalu banyak pengerjaan ulang. Alasan mengapa diperlukan terlalu banyak pengerjaan ulang adalah karena (a) itu disatukan dengan pandangan ke depan dan perencanaan yang tidak memadai dan (b) tambalan jangka pendek tambahan yang secara teratur dimasukkan selama pengembangan secara bersama-sama meningkatkan kompleksitas setiap pengerjaan ulang yang diperlukan.
Karena itu, jawabannya adalah
(a) ubah gaya pengembangan Anda sedikit lebih ke arah air terjun dan sedikit kurang gesit. Namun jangan pergi jauh-jauh, karena air terjun klasik memiliki jebakannya sendiri. Ada keseimbangan sehat yang bisa didapat. Saya tahu itu bisa mengenai memikirkan hal-hal selama beberapa hari kadang-kadang, seperti tidak ada pengembangan yang dilakukan, tetapi Anda harus memercayai prosesnya. Dalam rekayasa, Anda tidak bisa hanya memakukan hal-hal bersama dan kemudian memaku hal-hal di atas dan berharap untuk keluar dengan solusi yang elegan. Jika tidak ada orang yang melakukan arsitektur dan desain teknis tingkat tinggi, itu adalah pekerjaan Anda. Anda telah membayar harga mengabaikan pekerjaan itu.
(B) mencoba untuk menghindari menambal sesuatu. Jangan berpikir jangka panjang hanya ketika tiba saatnya untuk melakukan QA. Sungguh, Anda harus menguji setiap bagian kecil yang Anda buat, sepanjang waktu, dan mencakup semua kasus masukan, yang tidak berada di jalur bahagia juga. Sebuah tambalan / retasan hampir secara definisi merupakan perbaikan jangka pendek, yang mungkin memiliki biaya jangka panjang, mengenai total Biaya Kepemilikan klien dalam sistem. Sekali lagi, tekanan menyala untuk mengeluarkan kode, jadi harus ada keseimbangan. Tetapi cobalah untuk tidak menempatkan perbaikan jangka pendek di tempat, esp. komponen-komponen yang terikat erat yang harus benar-benar longgar digabungkan Akan ada pekerjaan ulang, jadi lakukan AWAL untuk membuatnya lebih mudah, untuk menghindari peretasan dan tambalan yang akan meningkat dari waktu ke waktu dan menjadi tidak terkelola.
sumber
Anda menulis:
Versi check-in dapat menjadi "prototipe" karena melewatkan fitur atau beberapa fitur tidak disempurnakan, tetapi semua kode yang diperiksa harus berupa kode kualitas produksi yang tidak perlu perlu dibersihkan.
Saya pikir Anda banyak menunda "pembersihan".
Aturan praktis saya adalah:
Pada titik ini, kode yang dikomit mungkin masih mengandung beberapa solusi atau "hutang teknis" yang akan baik untuk dibersihkan, dan mungkin saya akan membersihkannya ketika itu adalah hal yang wajar dilakukan untuk sub-fitur berikut, tetapi akan baik-baik saja jika kode itu dirilis apa adanya.
sumber