Bagaimana cara mengatasi kelumpuhan dengan analisis saat pengkodean?

Ketika saya memulai proyek baru, saya sering kali segera mulai memikirkan detail implementasi. "Di mana saya akan meletakkan DataBaseHandler? Bagaimana saya harus menggunakannya? Haruskah kelas yang ingin menggunakannya meluas dari beberapa superclass abstrak ..? Haruskah saya menggunakan antarmuka? Tingkat abstraksi apa yang akan saya gunakan di kelas saya yang berisi metode untuk mengirim permintaan dan mem-parsing data? "

Saya akhirnya mengulur waktu yang lama karena saya ingin kode untuk diperpanjang dan dapat digunakan kembali. Tetapi saya merasa hampir tidak mungkin untuk melewati pemikiran tentang bagaimana menerapkan dengan sempurna.

Dan kemudian, jika saya mencoba untuk hanya mengatakan "sekrup, selesaikan saja!", Saya menabrak dinding bata dengan cepat karena kode saya tidak terorganisir, saya mencampur tingkat abstraksi, dll.

Apa beberapa teknik / metode yang Anda miliki untuk meluncurkan ke proyek baru sambil juga menyiapkan struktur logis / modular yang akan skala dengan baik?

- - EDIT - -

Yah, ini sudah jenis pertanyaan yang sulit diterima jawabannya, tetapi ingin mendapatkan umpan balik lagi, lihat apakah ada beberapa konsensus. TDD kedengarannya sangat keren dan, sejujurnya, saya bermaksud meningkatkan kecepatan menggunakan JUnit, dll. Pada saat yang sama, apa yang dipikirkan oleh para penggemar TDD tentang fakta bahwa satu titik yang sah berkaitan dengan TDD menyelesaikan masalah saya masalah khusus, adalah bahwa TDD tampaknya tidak benar-benar menjawab pertanyaan tentang desain. Tentu, saya setuju TDD akan membantu saya mendefinisikan apa yang ingin saya lakukan dan kemudian saya bisa secara bertahap bekerja melalui caranya, tetapi ada banyak pola / struktur desain keseluruhan yang berbeda yang semuanya bisa melewati pengujian unit. Itu hanya itu: ia menguji UNIT tunggal. Saya kira saya agak bingung ... Saya tidak tahu. Mungkin saya'

Terima kasih!

Saya merekomendasikan menggunakan Test-Driven-Development , perlu membiasakan diri terutama ketika bekerja dengan IDE yang baik seperti gerhana, tetapi keuntungannya besar.

Pada dasarnya yang Anda lakukan adalah menulis tes ke kode Anda sebelum Anda menulis kode itu sendiri. Jadi Anda dipaksa untuk melihat kode Anda dari sudut pandang bagaimana itu akan digunakan, yang berarti antarmuka Anda berevolusi semakin banyak skenario yang Anda terapkan.

Karakteristik lain adalah bahwa Anda menerapkan dalam potongan yang sangat kecil (mereka tumbuh lebih besar semakin Anda berpengalaman pada teknik dan pemrograman) sehingga memaksa Anda untuk fokus pada masalah yang sangat kecil dan didefinisikan dengan baik setiap kali.

Dan juga sejak Anda pertama kali menulis tes dan baru kemudian menerapkan, Anda memiliki tes gagal di depan Anda. Jadi, jika Anda seperti kebanyakan programmer, Anda tidak akan terbawa oleh analisis gila karena Anda akan berpikir: "Saya perlu membuat tes ini bekerja".

Contoh java pendek:
Katakanlah saya ingin mengembangkan program yang membaca dan menulis pesan dari db.

Jadi saya mulai dengan tindakan pertama yang didefinisikan dengan baik, saya membutuhkan DB:

@Test
public void testDB() {
  DB db = DbConnector.getDB(address);
  assertNotNull(db);
}

ok, jadi di sini saya melihat bahwa saya perlu mengimplementasikan kelas DbConnector.getDB sehingga mengembalikan DB, sampai kemudian tes ini gagal. Saya pergi dan melakukan itu ...

Bukan saya menambahkan hal berikutnya yang ingin saya lakukan, memuat pesan dari DB:

@Test
public void testDB() {
  DB db = DbConnector.getDB(address);
  assertNotNull(db);
  String message = db.fetchMessage(key);
  assertEquals("hello world", message);
}

Sekarang saya telah menambahkan fitur kecil lainnya ke DB yaitu untuk mengambil pesan, saya pergi dan mengimplementasikannya, setelah selesai saya teruskan satu fitur pada satu waktu sampai saya mencapai sesuatu seperti ini:

@Test
public void testDB() {
  DB db = DbConnector.getDB(address);
  assertNotNull(db);
  String message = db.fetchMessage(key);
  assertEquals("hello world", message);
  message = "foo bar";
  db.storeMessage(message);
  message = db.fetchMessage();
  assertEquals("foo bar", message);
}

Ini mungkin tampak seperti contoh yang sangat sederhana, tetapi ini berfungsi untuk tugas yang lebih kompleks juga. Saya tahu ini sangat memakan waktu pada awalnya, tetapi ketika Anda terbiasa, Anda melihat bahwa itu sebenarnya jauh lebih efisien. Untuk satu Anda menghindari kelumpuhan oleh analisis dan untuk yang lain Anda mendapatkan kode yang lebih kuat yang biasanya memiliki lebih sedikit bug dan melewati iterasi yang lebih sedikit.

Ini terjadi pada saya, jadi saya sudah terbiasa menerima (dan merangkul) pola pikir refactoring berkelanjutan. Saya membuat hal paling sederhana yang mungkin bisa berhasil, kemudian saya membersihkannya, mengaturnya, memisahkannya, mengujinya dan melanjutkan.

Itu bukan untuk mengatakan bahwa tidak banyak perencanaan yang terjadi, tetapi itu terjadi sangat cepat dan lebih sering seperti coretan pada memo atau di kepala saya. Semua dalam semua, saya kadang-kadang menyebut proses kecil ini mikro-iterasi karena mereka mengambil masing-masing 5-20 menit dan dari pengalaman dibutuhkan 2-3 untuk menyelesaikan apa yang saya kerjakan (tergantung pada apa yang saya buat, jelas).

Sebagai catatan: Saya telah mengajari sejumlah orang dalam berbagai bentuk penulisan (laporan, esai, dan penulisan teknis pada umumnya) dan ini adalah cara yang sama dengan cara saya membuat mereka menulis hal-hal untuk mengatasi hambatan penulis. "Katakan saja tentang topikmu yang muncul di pikiranmu ke halaman. Lalu kita akan masuk akal dan pisahkan semuanya menjadi paragraf dan periksa alurnya. Jika perlu, kita bahkan akan menulisnya kembali."

Beberapa hal yang mungkin berhasil:

• Identifikasi masalah inti yang Anda coba selesaikan - apa inti dari hal yang ingin Anda lakukan? Terapkan hanya itu, dan kode dukungan minimum untuk membuatnya berjalan. Setelah itu berhasil untuk kepuasan Anda, bangunlah secara iteratif, lakukan refactoring tanpa ampun di setiap langkah.
• Lihat apakah paradigma pemrograman lain cocok untuk Anda. Terlepas dari semua kelebihannya, pemrograman berorientasi objek bukanlah jawaban untuk semua masalah, dan tidak semua otak programmer bekerja seperti itu. Ambil bahasa fungsional (murni); menulis beberapa kode prosedural; menyelam ke tingkat perangkat keras dan melakukan beberapa C atau bahkan assembler; dll. Beberapa bahasa yang mungkin mengguncang pikiran Anda (dengan asumsi Anda sedang menggunakan sesuatu seperti C ++ / Java / C # / VB / ...): Haskell, ML, Lisp (berbagai dialek untuk dipilih), Erlang, Prolog, Smalltalk, Javascript (jika Anda melepaskan mencoba membuatnya berperilaku seperti Java dan merangkul sifat penutupannya sebagai gantinya), C, Pascal, awk, dan mungkin selusin lagi. Fitur utamanya adalah mereka harus sangat berbeda dari apa yang Anda gunakan sekarang. Ini bukan sesuatu yang ingin Anda lakukan pada proyek besar dengan banyak yang dipertaruhkan,
• Gunakan metode desain yang sangat berbeda. Lihat apakah Anda dapat mengambil desain dari sudut yang berbeda. Saya berasumsi Anda biasanya mulai merancang dengan meletakkan kelas Anda; bagaimana kalau Anda mulai dengan struktur data untuk perubahan? Atau bagaimana Anda mendesain UI terlebih dahulu, menggambar form input secara harfiah sebelum mendesain fungsionalitas apa pun?

Untuk banyak keputusan desain, Anda dapat melakukan "lonjakan" yang merupakan upaya penelitian pendek dan terbatas waktu di mana Anda dapat menjelajahi beberapa arsitektur atau opsi desain dengan mengkodekan ke prototipe yang dibuang. Misalnya Anda dapat menjelajahi penggunaan beberapa pustaka sumber terbuka atau bagaimana Anda akan mengatur kelas dan antarmuka Anda. Kuncinya adalah membuatnya singkat sehingga Anda dapat mencoba pendekatan lain jika yang pertama tidak memuaskan dan mudah-mudahan Anda akan memperoleh pengetahuan yang cukup dalam latihan untuk membuat keputusan arsitektur yang lebih baik atau untuk membuktikan konsep. Latihan itu sendiri melibatkan pengkodean langsung yang membantu untuk keluar dari "blok penulis" tanpa harus melakukan "git 'er done" terlalu dini.

Setelah itu bermanfaat untuk menggunakan pendekatan TDD atau BDD yang disebutkan Asaf untuk terus maju dengan implementasi proyek.

Anda tidak akan membutuhkannya , jadi jangan terlalu banyak berpikir di awal.

Investasikan lebih banyak waktu untuk mendefinisikan, untuk memahami tujuan dan masalahnya.

"Extensibility and reusability" adalah hasil alami dari siklus hidup program perangkat lunak yang ditulis dengan baik.

Saya akan berasumsi bahwa kita sedang melihat proyek ukuran sedang.
Saya akan mulai dengan masuk ke papan gambar. Anda harus menyiapkan persyaratan fungsional dan non-fungsional Anda sebelum melakukan ini. Anda pertama kali akan datang dengan perangkat lunak archtiecture yaitu melihat pola arsitektur yang sesuai dengan kebutuhan Anda.
Setelah Anda memutuskan bagaimana tampilan archtiecture Anda, Anda harus masuk ke desain tingkat rendah, lihat semua entitas, kelas, dan fungsionalitas. . Di sini, Anda akan lagi mencoba dan mengidentifikasi pola desain yang cocok. Dalam prosesnya, Anda akan tahu apa kelas dasar Anda dan antarmuka yang Anda butuhkan.
Anda kemudian dapat membangun kerangka kerja dan menjalankan beberapa tes cepat untuk melihat apakah ini memenuhi semua persyaratan non-fungsional Anda
Saya kemudian akan pergi dengan Test Driven Development seperti yang disarankan oleh Asaf.

Ingat, Terlepas dari menghabiskan waktu yang baik untuk desain dan arsitektur, selalu bersedia untuk meninjau kembali arsitektur jika diperlukan.

Saya pikir ini adalah pertanyaan yang bagus, dan tidak ada yang akan berhasil untuk semua orang. Saya pikir kelumpuhan seperti itu adalah produk sampingan alami untuk menjadi semakin kompeten di bidang Anda. Yang mengatakan, inilah beberapa hal yang saya lakukan yang membantu, tetapi tidak menyelesaikan masalah:

• Singkirkan proyek murni Anda dan garap versi yang jelek. Ini adalah versi di mana Anda memberi tahu diri sendiri: a. Kode tidak seharusnya cantik. Bahkan, katakan pada diri Anda sendiri, refactoring dan pemformatan ulang utama tidak diperbolehkan. Biarkan benar-benar tidak terorganisir dan bebaskan diri Anda dari ikatan pengkodean yang baik. b. Itu hanya harus bekerja. c. Selalu mengejutkan bagi saya apa yang saya pelajari tentang ruang masalah ketika saya membuang semua masalah lainnya. Saya juga berakhir dengan berita kecil yang sering membantu saya sampai pada desain yang tepat dengan cara yang lebih tercerahkan.

• Sisihkan blok waktu yang layak di mana Anda berada di proyek, hanya tanpa komputer. Cobalah untuk membuat konsep apa yang benar-benar ingin Anda capai dan mencari zen ajaib yang melampaui kegilaan Pola OO / Desain.

Berikan ekspresi konkret ke pikiran Anda: tulis / ketik, turunkan atau apalah. Ini akan membantu Anda meninjau kembali pemikiran Anda saat dibutuhkan; itu akan menghentikan Anda dari berputar-putar; membantu Anda berpikir lebih jernih.

Setiap kali saya melihat diri saya pergi ke mana-mana memikirkan sesuatu, saya mengetiknya dan itu membantu saya berpikir jernih.

Saya biasanya mulai dari bawah ke atas, membuat prototipe sesederhana mungkin dan membuat sesuatu berjalan. Gunakan prototipe untuk merekayasa balik kasus uji jalur bahagia, kasus uji untuk mendorong antarmuka dan kemudian berpikir tentang kontrak pra / pasca untuk membantu membangun cakupan pengujian.

Jangan khawatir tentang abstraksi, optimisasi, atau verifikasi hingga masalahnya dipahami sepenuhnya.