Saya berencana untuk bekerja / memulai beberapa proyek pribadi yang dapat berakhir sebagai pekerjaan harian saya. Itu membuat saya berpikir, jalan mana yang harus saya mulai?

• Hanya prototipe — tulis saja kode dasar yang berfungsi yang dapat membuat saya menghabiskan banyak waktu untuk mengoptimalkan dan memulihkan kembali untuk perluasan yang mudah.

• Tulis kode yang bersih, optimal, dan terdokumentasi sejak awal, ingatlah bahwa jika setelah beberapa waktu tidak akan hemat biaya, maka akan dihapus.

Update: Menggabungkan YAGNI dengan sunpech dan jawaban M.Sameer sangat masuk akal bagi saya :) terima kasih semuanya atas bantuannya.

Ada opsi ketiga ... tulis kode bersih melalui pengembangan yang digerakkan oleh tes untuk mengimplementasikan persyaratan yang diperlukan hari ini karena YAGNI.

Godaan untuk menulis kode yang tidak perlu saat ini tetapi mungkin di masa depan menderita beberapa kelemahan ... dari Anda tidak akan membutuhkannya :

• Waktu yang dihabiskan diambil dari menambah, menguji atau meningkatkan fungsionalitas yang diperlukan.
• Fitur baru harus didebug, didokumentasikan, dan didukung.
• Setiap fitur baru memberikan batasan pada apa yang dapat dilakukan di masa depan, sehingga fitur yang tidak perlu sekarang dapat mencegah penerapan fitur yang diperlukan nanti.
• Sampai fitur tersebut benar-benar diperlukan, sulit untuk sepenuhnya menentukan apa yang harus dilakukan dan mengujinya. Jika fitur baru tidak didefinisikan dan diuji dengan benar, mungkin tidak berfungsi dengan benar, bahkan jika pada akhirnya diperlukan.
• Ini menyebabkan kode mengasapi; perangkat lunak menjadi lebih besar dan lebih rumit. Kecuali ada spesifikasi dan semacam kontrol revisi, fitur tersebut mungkin tidak diketahui oleh programmer yang dapat memanfaatkannya.
• Menambahkan fitur baru dapat menyarankan fitur baru lainnya. Jika fitur-fitur baru ini diimplementasikan juga, ini dapat mengakibatkan efek bola salju menuju creeping featureism.

Sebagai hasilnya, Anda tidak boleh hanya prototipe ... Anda juga tidak harus menulis kode yang bersih, dioptimalkan dan didokumentasikan sejak awal, mengingat bahwa jika dalam beberapa waktu tidak akan hemat biaya - itu akan dibatalkan.

Tulis kode yang Anda butuhkan sekarang dengan mengetahui bahwa Anda dapat memenuhi kebutuhan hari ini dan besok.

seperti biasa...

Tergantung

Jika Anda membuat prototipe untuk mengurangi risiko atau mengekspos sesuatu yang tidak diketahui, kode saja dan berharap untuk membuangnya setelah selesai

Jika Anda membuat prototipe untuk penyempurnaan berulang, cukup kode saja dan berharap untuk memodifikasi dan sering refactor

Jika Anda mulai menulis produk yang sebenarnya tetapi menyebutnya prototyping sehingga Anda bisa malas , maka jangan malas, dan tulis dengan baik pertama kali

Jika Anda membuat prototipe, mengapa Anda berpikir tentang kode bersih? Ide prototyping adalah bahwa itu dimaksudkan untuk membuktikan konsep atau ide, dan dibuang setelah itu.

Saya akan tidak setuju dengan kebanyakan orang di sini dengan mengatakan bahwa jika Anda sudah memikirkan pilihan antara menulis kode bersih atau menyelesaikan sesuatu dengan cepat untuk membuat prototipe, pilih yang terakhir. Terutama ketika Anda berbicara tentang pengembangan tahap awal. Saya tidak mengatakan jangan pernah menulis kode bersih, saya katakan dapatkan ide itu, lihat bahwa itu adalah arah untuk pergi, lalu kembali bersihkan itu-- refactor.

Sebagai pengembang perangkat lunak, kami begitu sibuk melakukan hal-hal yang benar dan bersih pertama kali, sehingga kami gagal menyadari bahwa itu bukan kode yang kami berikan, ini solusi untuk masalah .

Saya berpikir tentang coding sama seperti menulis makalah:

Saat menulis makalah, kita mulai di suatu tempat, membuat sketsa ide, menguraikan, dll. Itu tidak akan berisi semua detail atau sudah selesai melihat itu - itu pada dasarnya konsep pertama, diikuti oleh yang kedua, dan seterusnya. Banyak yang akan ditulis ulang, diganti, dan / atau bahkan dihapus di sepanjang jalan ke kertas yang lebih halus dan selesai. (Jelas analogi ini tidak lebih jauh dengan mengatakan bahwa kode pernah benar-benar selesai atau final seperti kertas.)

Ada dua jenis pembuatan prototipe:

• Prototipe evolusioner yang terus berevolusi melalui penyempurnaan dan perbaikan untuk menjadi produk akhir.
• Prototipe sekali pakai yang ada hanya untuk membuat pengumpulan persyaratan dan umpan balik pelanggan lebih efektif pada tahap proyek awal dan kemudian sepenuhnya dibatalkan dan pengembangan produk akhir dimulai dari awal.

Menurut Capers Jones, prototipe evolusi menghasilkan produk akhir berkualitas rendah yang akan membutuhkan lebih banyak upaya dan waktu lebih lama untuk mencapai stabilitas.

Jadi jika Anda berpikir tentang membuat prototipe sehingga pelanggan dapat melihat sesuatu secepat mungkin untuk membantu Anda mendapatkan ide yang lebih baik dan rincian lebih lanjut tentang persyaratan, lebih baik menjadi prototipe sekali pakai dan melakukan pengembangan pada kode bersih nanti. Jika Anda tidak mampu melakukannya, tulis kode bersih dari awal dan pertahankan dengan hati-hati, tetapi seperti yang disarankan orang lain jangan terlalu mengoptimalkan dan jangan menambahkan barang sampai Anda membutuhkannya.

Saya enggan memaafkan coding kotor karena alasan apa pun. Dalam pengalaman saya, orang yang mengklaim cepat & kotor sebagai alasan untuk membuat prototipe memiliki sikap terhadap kode apa pun, termasuk produksi. Jika seseorang membuat prototipe yang berantakan, ia menciptakan kekacauan dalam kode apa pun. Prototyping tidak berarti pengkodean yang kotor, itu berarti asumsi yang disederhanakan untuk menguji kasus penggunaan yang paling penting. Kode mungkin tidak diuji secara formal, atau urus semua detail, tetapi kode tersebut harus dirancang dengan baik, dan diimplementasikan dengan baik. Cleanness adalah tanda kompetensi, programmer yang kompeten merasa jijik secara alami terhadap kode yang berantakan, apa pun tujuannya.

Tulis kode yang bersih, optimal, dan terdokumentasi sejak awal. Saya tidak mampu melakukan itu sendiri dan ini adalah masalah nyata. Saya bukan pembuat kode, tetapi saya telah bekerja untuk perusahaan pengembangan perangkat lunak di pelanggan yang menghadapi peran manajemen dalam jumlah yang adil dan karena mereka memberi saya banyak ide bagus, saya kadang-kadang membuat prototipe untuk sesuatu. Hampir setiap kali prototipe itu diserahkan kepada pengembang yang "membersihkannya" dan mengubahnya menjadi produk pengiriman. Ketika saya memeriksa sumbernya, masih akan 80-90% kode jelek saya.

Seorang kolega saya dengan antusias mendukung prototipe berulang, dengan peringatan bahwa seseorang harus memiliki disiplin yang cukup untuk membuang setiap prototipe dan menulis lagi dari awal - dan tidak hanya itu, memastikan bahwa seseorang tidak dipengaruhi oleh rincian implementasi yang diputuskan pada putaran terakhir kali , seperti apa yang akhirnya dilakukan adalah menulis prototipe yang sama dengan gaya yang agak berbeda beberapa kali. Dia setengah-serius menyarankan bahwa jika Anda benar-benar terikat pada beberapa kode brilian yang Anda tidak bisa membuang, bahwa Anda harus mencetaknya, menghapus repositori kontrol sumber, dan memposting cetakan untuk diri Anda sendiri - itu akan hilang cukup lama sehingga tidak bisa menyusup ke iterasi berikutnya.

Anda selalu dapat memulai dengan membuatnya bekerja (sama sekali), kemudian merevisinya untuk membuatnya bersih, dan kemudian membuatnya cepat / kecil jika masuk akal secara ekonomi untuk melakukan itu. Saya akan mulai dengan beberapa percobaan yang Anda buang, kemudian TDD kembali menjadi ada ketika Anda memiliki pegangan tentang apa yang berhasil.

Keduanya bagus. Saya suka keduanya. Mereka tidak saling bertentangan.

Saya suka prototipe. Prototyping mengembangkan keterampilan kreativitas saya. Saya sedang menguji banyak solusi yang mungkin. Melakukannya dengan cepat memberi saya kemungkinan untuk menguji banyak cara yang mungkin untuk menyelesaikan masalah.

Saya suka menulis kode yang bersih dan baik. Ini mengembangkan keterampilan inti saya. Saya biasanya memilih salah satu prototipe, dan memperbaikinya, atau menulis ulang dari awal.

Tetapi Anda tidak boleh salah mengira prototipe dari kode produksi. Prototipe tidak boleh diproduksi. Itu harus selalu ditandai sebagai prototipe. Paling baik lakukan semua prototyping di cabang Anda sendiri.

Saya cenderung mengatakan bahwa ekstrem hampir selalu buruk.

Saya menyarankan untuk menjaga keseimbangan antara bersih, terdokumentasi dengan baik dan membuat prototipe. Ketika Anda mengembangkan untuk perpustakaan atau platform Anda tidak memiliki pengalaman dengan saya pergi lebih ke arah prototyping. Itu terutama benar di awal dan untuk platform, misalnya Android atau wadah, yang menempatkan Anda ke korset mereka. Itu berarti Anda mengimplementasikan antarmuka mereka dan mereka memanggil Anda.

Dari pengalaman saya sendiri sebagian besar kode tidak berumur panjang. Yang mengatakan, cepat pergi dengan menerapkan fitur Anda. Ketika cepat atau lambat (sebagian besar waktu lebih cepat) Anda perlu mengolah / memperbaiki kode Anda yang ada karena fitur berikutnya Anda merapikan terutama bagian-bagian yang rumit untuk dikerjakan. Perhatikan untuk memiliki tes otomatis yang tepat untuk memungkinkan refactoring bebas repot mungkin. Mengenai platform yang disebutkan di atas seperti Android: sering mereka membuat pengujian otomatis tidak semudah kopling dekat dan tidak ada desain untuk testabilitas. Kemudian Anda dapat mengangkat basis pengujian Anda ke tingkat yang lebih tinggi, misalnya pengujian integrasi.

Saya menulis sebuah artikel yang mungkin memberikan beberapa petunjuk tentang memulai: https://medium.com/@ewaldbenes/start-lean-why-its-best-to-split-your-next-coding-project-by-feature-70019290036d