Saat membuat aplikasi non-sepele, apakah yang terbaik untuk fokus pada hal-hal yang bekerja dengan cepat, dan mengambil jalan pintas dalam kode seperti mencampur logika model dengan pandangan Anda, memecahkan enkapsulasi - bau kode khas? Atau, apakah Anda lebih baik meluangkan waktu di muka untuk membangun lebih banyak arsitektur, membangunnya dengan benar, tetapi menjalankan risiko bahwa semua kode tambahan ini mungkin tidak digunakan karena desain Anda cukup lancar dan Anda mungkin harus membuangnya jika umpan balik menyebabkan Anda pergi ke arah yang berbeda?

Untuk konteks, saya sedang membangun aplikasi desktop. Saya satu-satunya pengembang, dan saya melakukan ini paruh waktu karena saya memiliki pekerjaan harian. Sekarang, untuk bekerja, saya mencoba melakukan hal-hal dengan cara yang benar, jadwal memungkinkan. Tetapi untuk proyek ini, yang saya harapkan akan berubah ketika saya mendapat umpan balik dari orang-orang, saya tidak yakin itu pendekatan yang tepat. Saya menghabiskan beberapa jam minggu ini memasukkan desain Pengendali Tampilan Model buku teks untuk mengkomunikasikan perubahan dalam model ke tampilan. Ini bagus secara umum, tetapi saya tidak yakin apakah saya perlu banyak tampilan untuk menampilkan data dan saya tahu bahwa saya bisa menampilkan sesuatu lebih cepat tanpa arsitektur tambahan. Dengan mungkin 10-15 jam seminggu untuk dihabiskan untuk proyek ini, saya merasa perlu waktu lama untuk membuat sesuatu yang bisa saya demokan jika saya mengikuti praktik perangkat lunak yang baik. Saya tahu bahwa pengguna saya menang ' t peduli bahwa saya menggunakan MVC secara internal, mereka hanya ingin sesuatu yang menyelesaikan masalah mereka. Tetapi saya juga pernah berada dalam situasi di mana Anda mengeluarkan begitu banyak hutang teknis dari jalan pintas sehingga kode ini sangat sulit dipertahankan dan ditambahkan fitur-fitur baru. Saya ingin mendengar bagaimana orang lain mendekati masalah semacam ini.

Bangun dengan baik .

Membangunnya "cepat" adalah kesalahan yang logis jika Anda melihat gambaran besarnya. Ini akan mencegah Anda membangunnya dengan baik, dan pada akhirnya Anda akan terhambat oleh bug dan cacat arsitektur mendasar yang mencegah refactoring atau bahkan membuat penambahan fitur baru yang hampir mustahil.

Membangunnya dengan baik sebenarnya adalah kebalikannya. Pada awalnya mungkin lebih lambat, tetapi pada akhirnya Anda akan menyadari keuntungan efisiensi dari meluangkan waktu untuk membuat pilihan yang tepat di depan. Selain itu, Anda akan dapat beradaptasi dengan persyaratan di masa depan dengan lebih mudah (refactoring jika diperlukan) dan Anda akan memiliki produk akhir yang lebih baik, paling tidak, lebih sedikit bug.

Dengan kata lain (kecuali ini adalah kontrak satu-dan-dilakukan), bangun dengan cepat = bangun dengan lambat, bangun dengan baik = bangun dengan cepat .

Juga ada sesuatu yang penting untuk disadari tentang "membangunnya dengan baik" dan merancang arsitektur. Kamu bertanya...

... tetapi menjalankan risiko bahwa semua kode tambahan ini mungkin tidak digunakan karena desain Anda cukup lancar dan Anda mungkin harus membuangnya jika umpan balik membuat Anda pergi ke arah yang berbeda?

Itu bukan risiko sebenarnya dari "menghabiskan waktu arsitektur". Desain arsitektur harus organik . Jangan habiskan waktu mendesain arsitektur untuk bagian apa pun sampai dibenarkan. Arsitektur seharusnya hanya berkembang dari pola yang diamati dan dikonfirmasi dalam proyek Anda.

Hukum John Gall dari Systemantics :

Sistem kompleks yang dirancang dari awal tidak pernah berfungsi dan tidak dapat ditambal untuk membuatnya berfungsi. Anda harus memulai dari awal, dimulai dengan sistem sederhana yang berfungsi.

Cepat, lalu baik

Ini dari pengalaman pribadi saya setelah mencoba banyak metode berbeda.

Masalah dengan hanya bekerja cepat (dan melepaskan) pada umumnya bahwa Anda akan menempelkan fitur setelah fitur ke aplikasi Anda dan karena itu dirilis sangat sulit untuk melakukan perubahan mendasar pada program Anda. Anda membayar harga yang curam dalam jangka panjang karena tidak memiliki arsitektur yang mendasarinya, itu seperti membangun sebuah ramshackle dengan pasir isap.

Program dengan melakukannya dengan baik adalah Anda akan membuang banyak waktu dan kode. Ini seperti membangun rumah besar tanpa cetak biru. Aplikasi menulis adalah proses belajar dan hampir (dalam pengalaman saya) tidak mungkin dirancang di muka. Itu berarti Anda akan melakukan banyak refactoring, dan jika Anda menulis semuanya "dengan baik" setiap saat, Anda akan membuang banyak kode.

Karenanya, cepat, lalu yah!

Hal utama ketika Anda memulai adalah hanya untuk mendapatkan semuanya dalam kode sehingga dapat memakukan semua fitur dan melihat apa jenis arsitektur yang Anda butuhkan untuk mendukung. Hal lain yang baik tentang metodologi ini adalah bahwa saya akan membuat Anda tetap termotivasi karena Anda akan segera memiliki sesuatu yang berjalan. Ini juga penting untuk mengimplementasikan beberapa fungsionalitas "tepi-case" karena itu akan berdampak pada arsitektur umum Anda. Jangan repot-repot menulis tes unit atau mengerjakan detail pada tahap ini. Jika Anda pikir Anda perlu mendukung multilanguage di masa mendatang, arsitektur plugin yang lainnya, terapkan, tetapi cepat dan kotor. Lakukan beberapa refactoring untuk menjaga agar aplikasi dapat dikelola tetapi tidak ada yang berlebihan.

Setelah Anda merasa memiliki "prototipe" yang berfungsi, saatnya untuk memulai refactoring. Pada dasarnya Anda ingin mengulang aplikasi seperti yang Anda lakukan jika Anda mulai dari awal mengetahui semua yang Anda tahu. Yang penting adalah untuk mendapatkan arsitektur yang benar, bukan untuk mengimplementasikan kembali semua fitur yang Anda lakukan pada fase satu, tetapi Anda harus memiliki arsitektur di tempat untuk mendukungnya nanti.

Dengan cara ini Anda akan berakhir dengan aplikasi dengan arsitektur suara seefisien mungkin, menurut pengalaman saya :)

Bangun itu

Cepat jika waktu ke pasar lebih penting daripada kualitas

Nah jika kualitas lebih penting daripada waktu ke pasar

Membangunnya dengan cepat akan menghasilkan keuntungan jangka pendek dan kerugian jangka panjang.

Membangunnya dengan baik akan menimbulkan kerugian jangka pendek tetapi manfaat jangka panjang.

Membangunnya dengan baik meminta kesabaran dan kebijaksanaan tetapi Anda akan diberi hadiah.

Membangunnya dengan cepat hanya baik untuk membuat prototipe cepat dan membuang barang-barang. Tujuan jangka panjang hanya dapat dicapai dengan sikap yang benar sejak awal.

Untuk proyek-proyek yang Anda rencanakan untuk didistribusikan agar dapat digunakan oleh orang lain, saya selalu melakukan kesalahan di sisi pekerjaan di muka. Arsitektur yang dipikirkan dengan baik lebih mudah diperluas jika diperlukan. Mengambil jalan pintas hanyalah model untuk mengumpulkan utang teknis.

Kadang-kadang bisa sangat lambat. Hal-hal yang layak dilakukan patut dilakukan dengan benar.

Membangunnya dengan baik = membangunnya dengan cepat

Pintasan cenderung berbalik dan menggigit Anda lebih cepat daripada yang Anda pikirkan. Kadang bahkan sebelum makan siang.

Tentang konteks Anda; jangan langsung abstrak. Tetap berpegang pada YAGNI dan hapus duplikasi. Terapkan pola berdasarkan tampilan itu ketika Anda benar-benar memiliki pandangan kedua bukan karena Anda pikir Anda mungkin memiliki satu di masa depan. Ketika View kedua itu tiba abstraksi yang Anda buat biasanya jauh lebih baik maka yang Anda buat sekitar kejadian tunggal pertama.

Nah, jika Anda sudah tahu apa yang Anda lakukan, cepat jika tidak

Saya seorang ilmuwan riset dan saya menulis banyak kode eksplorasi sebelum saya tahu apa gambaran besarnya atau bagaimana proyek akan berkembang. Dalam kasus ini bahkan sulit untuk melihat seberapa "baik" harus didefinisikan. Juga, biasanya sulit untuk melihat semua detail kecil dan cara hal-hal yang mungkin diperpanjang dimuka. Karena itu, pepatah lama berlaku:

1. Buat itu bekerja.
2. Perbaiki itu. Menjadikannya benar kedua memiliki keuntungan yang lebih baik Anda dapat mendefinisikan "benar" setelah Anda memiliki pengalaman membuatnya bekerja.

Bangun dengan baik .. selalu, tapi berikan ilusi untuk cepat

tetapi untuk membuatnya cepat hanya membuatnya lebih kecil. Buat subset kecil dari keseluruhan yang cukup signifikan untuk mendapatkan umpan balik. Menambahkan secara progresif dalam kecepatan konstan akan menghasilkan banyak manfaat yang sama dengan membangun cepat tanpa menjual jiwa Anda ke reaksi berantai malam tanpa tidur bermain bug-a-bug.

Saya pikir itu harus selalu "dibangun dengan baik". Jika waktu ke pasar adalah masalah besar maka gunakan proses pengembangan tambahan. Skenario terburuk Anda memiliki produk dengan fitur lebih sedikit, tetapi setidaknya Anda memiliki produk berkualitas tinggi untuk dikirim yang dapat diperpanjang dalam rilis fitur di masa mendatang.

Keseimbangan

Tidak praktis untuk merekayasa kode Anda dengan sempurna atau menyatukan beberapa kode secara bersamaan, bukan? Ini benar-benar tentang keseimbangan yang tepat. Yang penting menurut saya adalah apa yang Anda lakukan saat.

Saya pikir hal yang paling penting di sini adalah untuk benar-benar memastikan inti dari aplikasi, struktur dasar, dibangun dengan sangat baik. Kedap udara. Setelah itu tercapai, tergantung pada batasan waktu, jika Anda kekurangan waktu, Anda bisa mendapatkan beberapa kode bersama, dan faktor ulang nanti, dan Anda bisa mendapatkan kemewahan itu karena Anda akan berusaha untuk mendapatkan fondasi benar, dan tidak ada salahnya untuk kode ulang faktor.

Lakukan hal paling sederhana yang mungkin bisa berhasil. Dalam kasus khusus Anda, program Anda tidak akan menjadi sangat besar, dengan Anda menjadi satu-satunya orang yang bekerja paruh waktu. Saya tidak menganjurkan perilaku buruk seperti penyalahgunaan goto, nama variabel yang tidak jelas dll, tetapi Anda tidak harus membuatnya lebih kompleks dari yang seharusnya. Mungkin MVC hanyalah kerja keras untuk proyek khusus Anda.

yang saya harapkan akan berubah ketika saya mendapat umpan balik dari orang-orang

Anda mengatakannya sendiri:

Tetapi saya juga pernah berada dalam situasi di mana Anda telah mengeluarkan begitu banyak hutang teknis dari jalan pintas sehingga kode ini sangat sulit dipertahankan dan ditambahkan fitur-fitur baru.

Jika Anda kekurangan waktu, jangan takut untuk meminta lebih banyak waktu untuk menyelesaikan proyek dari atasan Anda menggunakan alasan yang sama. Saya yakin mereka akan memberikannya kepada Anda. Setelah mengatakan ini, saya mengerti betapa frustrasinya kadang-kadang rasanya bekerja sangat keras pada sesuatu dan tidak dapat menunjukkan hasil yang luar biasa. Tapi jangan khawatir, Anda akan sampai di sana, dan membangunnya dengan baik tentu akan bermanfaat saat Anda melakukannya.

Biasanya saya suka membangun struktur dengan baik, dan menghemat waktu dengan tidak khawatir tentang detail implementasi spesifik. Seperti yang Anda katakan, mereka akan tetap berubah. Ide di balik membangun struktur yang dibuat dengan baik adalah bahwa perubahan dapat terjadi dengan sangat cepat, begitu pangkalan dibangun. Saya mencoba untuk fokus menjadi generik mungkin di kelas saya dan membuat mereka dapat digunakan kembali jika memungkinkan. Saya biasanya memberi pengguna aplikasi yang dibangun dengan baik yang hanya memenuhi persyaratan penggunaan paling dasar. Pengguna mendapatkan semua jenis Idea begitu alat ada di sana, sehingga tidak ada gunanya berpikir jauh ke depan.

Bangun dengan baik . Jika Anda tidak punya waktu, kurangi set fitur.

Desain itu seuniversal yang bisa. Misalnya, mendesain arsitektur plugin, meskipun Anda tahu, hanya satu plugin yang akan digunakan pertama kali. Gunakan skema konfigurasi universal (konfigurasi extensible, bahasa pengorganisasian), bahkan hanya ada satu parameter di awal. Ini investasi yang sangat bagus , dan Anda dapat melakukan investasi ini hanya di awal proyek.

apakah yang terbaik untuk fokus pada hal-hal yang bekerja dengan cepat, dan mengambil jalan pintas dalam kode seperti mencampur logika model dengan pandangan Anda, memecahkan enkapsulasi - bau kode khas? Atau, apakah Anda lebih baik meluangkan waktu di muka untuk membangun lebih banyak arsitektur

Di telinga saya, cara Anda menaruhnya di sana, Anda membuat daftar dua ekstrem. Pilihan pertama, memecahkan enkapsulasi, menempatkan logika model dalam pandangan, itu hanya pemrograman malas yang buruk. IMHO, memecahkan masalah-masalah itu tidak sama dengan memasukkan lebih banyak arsitektur. Mungkin kecuali yang Anda bicarakan adalah kode UI mengeksekusi pernyataan SQL. Tetapi saya tidak akan mengatakan membangun lebih banyak arsitektur, maka saya akan mengatakan bahwa Anda benar-benar kekurangan desain dan arsitektur dan Anda harus mendapatkannya.

Ketika datang ke arsitektur, saya akan memilih yang paling sederhana yang memecahkan masalah Anda sekarang, dan kemudian berkembang ketika masalah muncul.

Contoh: Apa yang Anda butuhkan saat ini adalah fungsi untuk mengembalikan data dari tabel database tunggal, saya tidak akan khawatir tentang masalah seperti bagaimana saya memuat data dari tabel terkait, meskipun saya akan tahu bahwa masalah tersebut pada akhirnya akan muncul. Saya akan mulai mengkhawatirkannya ketika saya bisa mengimplementasikan fungsionalitas itu.

Jadi untuk proyek pengembangan rumah saya sendiri, saya akan mengambil pendekatan berikut: Membangun solusi paling sederhana yang memecahkan masalah yang sedang saya kerjakan saat ini, tetapi membangunnya dengan baik. Saya kemudian akan memperbaiki solusi karena lebih banyak kompleksitas diperlukan. Mengikuti praktik TDD membuat refactoring aman, dan juga membantu menghindari bau kode (sulit untuk membuat tes unit yang baik, jika Anda melanggar enkapsulasi).

Itu kebetulan juga pendekatan yang saya ambil ketika bekerja secara profesional. ;)

Saya akan merekomendasikan bahwa pertama Anda harus berdiri perangkat lunak, mencakup setiap aspek dan berdiri perangkat lunak terlebih dahulu dan secara bertahap kemudian menghias dan meningkatkan kinerjanya

Anda biasanya ingin berada di tengah-tengah kedua tepi ini:

Membangun dengan baik = kritis kehidupan real-time software yang kehidupan masyarakat tergantung pada. yaitu, mengendalikan perangkat lunak: Reaktor nuklir, mesin Dialisis, mesin MRI , dll.

Bangun dengan cepat = perangkat lunak tidak berguna yang tidak digunakan oleh siapa pun.