Bagaimana saya bisa menghindari selalu merasa seperti jika saya benar-benar membangun kembali program saya dari awal saya akan melakukannya lebih baik? [Tutup]

Saya telah belajar sejumlah besar pengkodean, namun, selalu dalam lingkungan ilmiah (bukan ilmu komputer), sepenuhnya otodidak tanpa ada orang yang membimbing saya ke arah yang benar. Dengan demikian, perjalanan coding saya telah ... berantakan. Saya perhatikan sekarang bahwa setiap kali saya membangun beberapa jenis program, pada akhirnya, saya menyadari bagaimana saya bisa melakukannya dengan jauh lebih elegan, jauh lebih efisien, dan dengan cara yang jauh lebih fleksibel dan mudah dikelola di masa depan. Dalam beberapa keadaan, saya benar-benar telah kembali dan membangun kembali barang-barang dari bawah ke atas, tetapi biasanya ini secara praktis tidak layak. Meskipun sebagian besar program saya sejauh ini relatif kecil, tampaknya cukup sulit untuk sepenuhnya menulis ulang program besar setiap kali Anda membuat sesuatu.

Saya hanya ingin tahu, apakah ini pengalaman biasa? Jika tidak, bagaimana Anda mencegah hal ini terjadi? Saya sudah mencoba merencanakan hal-hal sebelumnya, tetapi saya tidak bisa benar-benar meramalkan semuanya sampai saya mulai memalu beberapa kode.

Perasaan ini sepenuhnya normal, dan diharapkan. Itu berarti Anda sedang belajar. Hampir setiap kali saya memulai proyek baru, saya mulai dalam satu arah, dan akhirnya mendesainnya secara berbeda pada akhirnya.

Ini adalah praktik umum untuk pertama mengembangkan prototipe sebelum memulai hal yang nyata. Ini juga umum untuk meninjau kembali kode lama dan refactor itu. Ini lebih mudah jika desain Anda modular - Anda dapat dengan mudah mendesain ulang potongan-potongan pada satu waktu tanpa harus benar-benar membuang desain lama Anda.

Bagi sebagian orang, lebih baik menulis pseudo-code terlebih dahulu. Orang lain merasa terbantu untuk memulai dengan menulis komentar yang menggambarkan apa yang akan dilakukan kode, kemudian menulis kode begitu struktur umum ada. Dua hal ini akan membantu Anda merencanakan desain Anda dengan lebih baik, dan mungkin menghindari keharusan penulisan ulang.

Jika Anda adalah bagian dari tim, memiliki proses peninjauan sangat penting untuk proses desain. Minta seseorang meninjau kode Anda sehingga Anda dapat mempelajari cara meningkatkan desain Anda.

Ini adalah pengalaman yang sangat umum

Kebanyakan orang yang berinteraksi dengan saya, dan saya sendiri juga, merasa seperti ini. Dari apa yang saya dapat katakan satu alasan untuk ini adalah Anda belajar lebih banyak tentang domain dan alat yang Anda gunakan saat menulis kode, yang membuat Anda mengenali banyak peluang untuk perbaikan setelah Anda menulis program.

Alasan lainnya adalah bahwa Anda mungkin punya ide di kepala Anda tentang solusi kode bersih yang ideal dan kemudian dunia nyata dan batasannya yang berantakan menghalangi Anda, memaksa Anda untuk menulis cara kerja yang tidak sempurna dan peretasan yang mungkin membuat Anda tidak puas.

"Semua orang punya rencana sampai mereka dipukul wajahnya."

Apa yang harus dilakukan tentang hal itu

Pada tingkat tertentu Anda harus belajar menerima bahwa kode Anda tidak akan pernah sempurna. Satu hal yang membantu saya dengan itu adalah pola pikir "Jika saya benci kode yang saya tulis sebulan yang lalu, itu berarti saya telah belajar dan menjadi programmer yang lebih baik".

Cara untuk mengatasi masalah ini adalah terus-menerus mencari kemungkinan peningkatan saat Anda bekerja dan terus-menerus memperbaiki. Pastikan untuk mencapai keseimbangan yang baik antara refactoring dan menambahkan fitur baru / memperbaiki bug. Ini tidak akan membantu dengan masalah desain besar, tetapi umumnya akan meninggalkan Anda dengan basis kode yang lebih halus yang bisa Anda banggakan.

Pelajari refactoring - seni memperbaiki kode secara bertahap . Kita semua belajar sepanjang waktu, jadi sangat umum untuk menyadari bahwa kode yang Anda tulis sendiri dapat ditulis dengan cara yang lebih baik.

Tetapi Anda harus dapat mengubah kode yang ada untuk menerapkan perbaikan ini tanpa harus mulai dari awal.

Jika Anda memiliki persyaratan statis yang sangat baik dan memahaminya dengan baik dan punya waktu untuk analisis terperinci, Anda memiliki peluang untuk menghasilkan desain yang bagus yang masih akan Anda senangi setelah selesai.

Bahkan dalam kasus yang membahagiakan itu, Anda dapat mempelajari fitur bahasa baru yang akan membantu membuat desain yang lebih baik.

Namun, biasanya, Anda tidak akan seberuntung itu: persyaratannya akan kurang dari bintang dan tidak lengkap dan meskipun Anda pikir Anda memahaminya, ternyata ada area yang Anda anggap tidak valid.

Kemudian, persyaratan akan berubah saat pengguna melihat kiriman awal Anda. Maka sesuatu yang tidak dikontrol pengguna akan berubah misalnya undang-undang pajak.

Yang dapat Anda lakukan adalah merancang, dengan asumsi bahwa segala sesuatu akan berubah. Refactor kapan saja Anda bisa, tetapi sadari bahwa waktu dan anggaran sering kali berarti bahwa hasil akhir Anda tidak seanggun jika Anda tahu pada awalnya apa yang Anda ketahui sekarang.

Seiring waktu, Anda akan menjadi lebih baik dalam menggali persyaratan yang Anda terima dan mendapatkan hidung yang bagian dari desain Anda cenderung membutuhkan fleksibilitas untuk menyerap perubahan.

Pada akhirnya, terima bahwa perubahan itu konstan dan abaikan kata-kata yang berbunyi "Aku bisa melakukannya dengan lebih baik". Banggalah dan senang bahwa Anda memberikan solusi sama sekali.

Bagaimana saya bisa menghindari selalu merasa seperti jika saya benar-benar membangun kembali program saya dari awal saya akan melakukannya lebih baik?

Yang bisa Anda lakukan adalah membuat prototipe sekali pakai, sebelum mulai melakukan proyek "nyata". Cepat dan kotor. Kemudian, ketika Anda mendapatkan prototipe untuk membuktikan konsep, Anda mengenal sistem, dan bagaimana melakukan sesuatu dengan benar.

Tetapi jangan heran, jika setelah N tahun Anda kembali ke kode ini, dan berpikir "sungguh berantakan".

Ingat mantra ini:

Yang sempurna adalah musuh yang baik .

The sempurna solusi adalah tidak selalu yang ideal solusi. The yang ideal solusi adalah salah satu yang mencapai status "cukup baik" dengan sedikitnya jumlah pekerjaan.

• Apakah memenuhi semua persyaratan terkait fungsionalitas dan kinerja?
• Apakah bebas dari bug kritis yang tidak dapat Anda perbaiki dalam arsitektur saat ini?
• Perkirakan berapa banyak pekerjaan yang akan Anda investasikan untuk mempertahankan aplikasi ini di masa mendatang. Apakah upaya untuk menulis ulang lebih dari upaya jangka panjang yang akan disimpannya?
• Apakah ada kemungkinan bahwa desain baru Anda benar-benar dapat memperburuk keadaan?

Jika Anda menjawab ya untuk semua pertanyaan ini, maka perangkat lunak Anda "cukup baik" dan tidak ada alasan yang baik untuk menulis ulang dari awal. Terapkan pelajaran desain yang telah Anda pelajari ke proyek berikutnya.

Sangat normal bagi setiap programmer untuk memiliki beberapa program yang berantakan di masa lalu mereka. Itu terjadi beberapa kali selama karir saya sebagai pengembang perangkat lunak sehingga saya melihat beberapa kode, bertanya-tanya, "Orang bodoh apa yang menulis kekacauan ini?", Memeriksa riwayat versi, dan memperhatikan bahwa itu adalah saya dari beberapa tahun yang lalu.

Saya sudah mencoba merencanakan hal-hal sebelumnya, tetapi saya tidak bisa benar-benar meramalkan semuanya sampai saya mulai memalu beberapa kode.

Sangat menggoda untuk berpikir bahwa perencanaan yang sempurna akan memberikan Anda desain / arsitektur perangkat lunak yang sempurna, namun ternyata itu salah. Ada dua masalah besar dengan ini. Pertama, "di atas kertas" dan "kode" jarang cocok, dan alasannya adalah karena mudah untuk mengatakan bagaimana itu harus dilakukan sebagai lawan untuk benar-benar melakukannya . Kedua, perubahan persyaratan yang tak terduga menjadi jelas terlambat dalam proses pengembangan yang tidak dapat dipikirkan sejak awal.

Pernahkah Anda mendengar tentang gerakan Agile? Ini adalah cara berpikir di mana kita menghargai "bereaksi terhadap perubahan" sebagai lawan dari "mengikuti rencana" (antara lain). Inilah manifestonya (ini bacaan cepat). Anda juga dapat membaca tentang Big Design Up Front (BDUF) dan apa perangkapnya.

Sayangnya, versi perusahaan "Agile" adalah sekelompok palsu (master scrum bersertifikat, proses berat atas nama "Agile", memaksa scrum, memaksa cakupan kode 100%, dll), dan biasanya menghasilkan perubahan proses asinin karena manajer berpikir Agile adalah proses dan peluru perak (yang mana keduanya bukan). Baca manifesto tangkas, dengarkan orang - orang yang memulai gerakan ini seperti Paman Bob dan Martin Fowler, dan jangan terjebak dalam versi omong kosong "Agile perusahaan".

Secara khusus, Anda biasanya bisa lolos dengan hanya melakukan TDD (Test Driven Development) pada kode ilmiah , dan ada kemungkinan besar proyek perangkat lunak Anda akan berubah dengan sangat baik. Ini karena kode ilmiah yang berhasil sebagian besar memiliki antarmuka yang dapat digunakan, dengan kinerja sebagai masalah sekunder (dan terkadang bersaing), sehingga Anda dapat lolos dengan desain yang lebih "serakah". Jenis TDD memaksa perangkat lunak Anda menjadi sangat berguna , karena Anda menulis bagaimana Anda ingin sesuatu dipanggil (idealnya) sebelum Anda benar-benar mengimplementasikannya. Ini juga memaksa fungsi-fungsi kecil dengan antarmuka kecil yang dapat dengan cepat dipanggil dengan cara "input" / "output" yang sederhana, dan menempatkan Anda pada posisi yang baik untuk melakukan refactor. dalam hal persyaratan berubah.

Saya pikir kita semua bisa sepakat bahwa numpyperangkat lunak komputasi ilmiah berhasil. Antarmuka mereka kecil, dapat digunakan super, dan semuanya bermain dengan baik bersama. Perhatikan bahwa numpypanduan referensi secara eksplisit merekomendasikan TDD: https://docs.scipy.org/doc/numpy-1.15.1/reference/testing.html . Saya telah menggunakan TDD di masa lalu untuk perangkat lunak pencitraan SAR (Synthetic Aperature Radar): dan saya juga dapat menyatakan bahwa itu bekerja sangat baik untuk domain tertentu.

Peringatan: Bagian desain TDD bekerja kurang baik dalam sistem di mana refactoring mendasar (seperti memutuskan bahwa Anda memerlukan perangkat lunak Anda menjadi sangat bersamaan) akan sulit, seperti dalam sistem terdistribusi. Misalnya, jika Anda harus mendesain sesuatu seperti Facebook di mana Anda memiliki jutaan pengguna secara bersamaan, melakukan TDD (untuk menggerakkan desain Anda) akan menjadi kesalahan (masih oke untuk digunakan setelah Anda memiliki desain awal , dan lakukan saja "uji pengembangan pertama "). Penting untuk memikirkan sumber daya dan struktur aplikasi Anda sebelum memasukkan kode. TDD tidak akan pernah menuntun Anda ke sistem terdistribusi yang sangat tersedia.

Bagaimana saya bisa menghindari selalu merasa seperti jika saya benar-benar membangun kembali program saya dari awal saya akan melakukannya lebih baik?

Mengingat hal di atas, harus agak jelas bahwa desain yang sempurna sebenarnya tidak mungkin dicapai, jadi mengejar desain yang sempurna adalah permainan yang bodoh. Anda benar-benar hanya bisa dekat. Bahkan jika Anda berpikir Anda dapat mendesain ulang dari awal, mungkin masih ada persyaratan tersembunyi yang belum ditampilkan sendiri. Selain itu, penulisan ulang memakan waktu setidaknya selama yang dibutuhkan untuk mengembangkan kode asli. Hampir pasti tidak akan lebih pendek, karena kemungkinan bahwa desain baru akan memiliki masalah yang tak terduga, ditambah Anda harus mengimplementasikan kembali semua fitur dari sistem lama.

Hal lain yang perlu dipertimbangkan adalah bahwa desain Anda hanya penting ketika persyaratan berubah .Tidak masalah seberapa buruk desainnya jika tidak ada yang berubah (dengan asumsi itu berfungsi penuh untuk kasus penggunaan saat ini). Saya bekerja pada garis dasar yang memiliki 22.000 baris pernyataan switch (fungsinya bahkan lebih lama). Apakah itu desain yang mengerikan? Heck ya, itu mengerikan. Apakah kita memperbaikinya? Tidak. Ini berfungsi dengan baik seperti dulu, dan bagian dari sistem itu tidak pernah benar-benar menyebabkan crash atau bug. Itu hanya tersentuh sekali dalam dua tahun saya di proyek, dan seseorang, Anda dapat menebaknya, memasukkan kasus lain ke sakelar. Tapi tidak ada gunanya meluangkan waktu untuk memperbaiki sesuatu yang sangat jarang disentuh, hanya saja tidak. Biarkan desain yang tidak sempurna seperti apa adanya, dan jika tidak rusak (atau terus-menerus rusak) maka jangan memperbaikinya. Jadi mungkin Anda bisa melakukan yang lebih baik ... tetapi apakah itu layak ditulis ulang? Apa yang akan kamu dapatkan?

HTH.

Saya sepenuhnya setuju dengan jawaban yang diberikan oleh Andreas Kammerloher namun saya terkejut belum ada yang menyarankan untuk belajar dan menerapkan beberapa praktik pengkodean terbaik. Tentu saja ini bukan peluru perak, tetapi menggunakan pendekatan berorientasi terbuka, pola desain, pemahaman ketika kode Anda berbau dan sebagainya akan membuat Anda seorang programmer yang lebih baik. Selidiki apa penggunaan terbaik dari perpustakaan, kerangka kerja dll. Ada banyak lagi yang pasti, saya hanya menggaruk permukaan.

Itu tidak berarti Anda tidak akan melihat kode lama Anda sebagai sampah total (Anda benar-benar akan melihat program tertua bahkan lebih banyak sampah daripada yang Anda tidak ketahui) tetapi dengan setiap perangkat lunak baru yang Anda tulis, Anda akan melihat Anda meningkat. Perhatikan juga bahwa jumlah praktik terbaik pengkodean meningkat seiring waktu, beberapa hanya berubah sehingga Anda benar-benar tidak akan pernah mencapai kesempurnaan. Terima ini atau cukup jalannya.

Satu hal lagi yang baik adalah memiliki revisi kode. Ketika Anda bekerja sendirian, mudah untuk mengambil jalan pintas. Jika Anda memiliki orang kedua yang meninjau kode Anda, mereka akan dapat menunjukkan di mana Anda tidak mengikuti praktik terbaik itu. Dengan cara ini Anda akan menghasilkan kode yang lebih baik dan Anda akan belajar sesuatu.

Untuk menambah jawaban luar biasa lainnya di sini, satu hal yang menurut saya bermanfaat adalah mengetahui ke mana Anda ingin pergi .

Jarang diberikan lampu hijau untuk sedikit refactoring sendiri. Tetapi Anda sering dapat melakukan sedikit refactoring saat Anda melakukannya, 'di bawah radar', saat Anda bekerja pada setiap area basis kode. Dan jika Anda memiliki tujuan dalam pikiran, Anda dapat mengambil kesempatan ini untuk bergerak, langkah demi langkah, ke arah yang benar.

Mungkin butuh waktu lama, tetapi sebagian besar langkah akan meningkatkan kode, dan hasil akhirnya akan sia-sia.

Juga, merasa seperti Anda bisa melakukan lebih baik adalah pertanda baik ! Ini menunjukkan bahwa Anda peduli dengan kualitas pekerjaan Anda, dan Anda menilainya secara kritis; jadi Anda mungkin belajar dan meningkat. Jangan biarkan hal-hal ini membuat Anda khawatir - tetapi jangan berhenti melakukannya!

Anda telah secara tidak sengaja menemukan salah satu tantangan terbesar (petualangan) umat manusia, jembatan antara manusia dan mesin. Jembatan antara manusia dan struktur fisik, Teknik Sipil misalnya, telah berlangsung selama sekitar 200 tahun atau lebih.

Karena pengembangan perangkat lunak benar-benar hanya menjadi arus utama di tahun 90-an, usianya sekitar 30 tahun. Kami telah belajar bahwa itu bukan disiplin teknik sebagai ilmu sosial, dan kami baru saja memulai.

Ya, Anda akan mencoba TDD, Refactoring, Pemrograman Fungsional, Pola Repositori, Event Sourcing, MV something, Java Script (<- Lakukan ini, ini gila), Binding Model, No Sql, Kontainer, Agile, SQL (<- lakukan ini ini kuat).

Tidak ada yang diperbaiki. Bahkan para ahli masih menggenggam sedotan.

Selamat datang, dan diperingatkan, ini adalah tempat yang sepi; tapi benar-benar menarik.

Saya akan sedikit menentangnya. Ini sangat umum , tetapi itu tidak dapat diterima . Apa ini menunjukkan bahwa Anda tidak mengenali cara yang baik untuk mengatur kode Anda saat Anda menulisnya. Perasaan itu berasal dari kode Anda yang tidak langsung .

Pengalaman Anda adalah pengalaman saya sejak lama, tetapi baru-baru ini (beberapa tahun terakhir), saya telah menghasilkan lebih banyak kode yang tidak membuat saya merasa harus membuang semuanya. Berikut kira-kira apa yang saya lakukan:

1. Perjelas tentang asumsi apa yang dibuat oleh blok kode tertentu. Lempar kesalahan jika tidak terpenuhi. Pikirkan tentang hal ini secara terpisah , tanpa bergantung pada perincian tentang apa yang dilakukan perangkat lunak lainnya. (Apa yang dilakukan perangkat lunak lainnya memengaruhi asumsi apa yang Anda tegakkan dan kasus penggunaan apa yang Anda dukung, tetapi tidak memengaruhi apakah Anda melempar kesalahan saat asumsi dilanggar.)
2. Berhentilah memercayai aturan dan pola serta praktik berikut ini akan menghasilkan kode yang baik. Buang pola pikir dan praktik yang tidak jelas dan jelas. Yang ini sangat besar. OO dan TDD biasanya diajarkan dengan cara yang tidak didasarkan pada pertimbangan praktis, sebagai seperangkat prinsip abstrak yang harus Anda ikuti saat menulis kode. Tapi ini sama sekali tidak membantu untuk benar-benar mengembangkan kode yang baik. Jika Anda menggunakan OO atau TDD sama sekali, itu harus digunakan sebagai solusi untuk masalah yang Anda mengerti Anda miliki . Dengan kata lain, mereka seharusnya hanya digunakan ketika Anda melihat masalah dan berpikir, "Oke, ini masuk akal dan sangat jelas sebagai solusi yang baik." Tidak sebelum.
3. Saat saya menulis kode, fokuslah pada dua pertanyaan:
   • Apakah saya menggunakan fitur dan perpustakaan dalam cara mereka dirancang untuk digunakan ? Ini termasuk menggunakannya untuk jenis masalah yang ingin diselesaikan, atau setidaknya yang sangat mirip.
   • Apakah ini sederhana ? Akankah rekan kerja saya dan saya dapat mengikuti logika dengan mudah nanti? Apakah ada hal-hal yang tidak langsung terlihat dari kode?

Kode saya sekarang lebih "prosedural," yang saya maksud itu diatur oleh tindakan apa yang diperlukan daripada struktur data apa yang digunakannya. Saya menggunakan objek dalam bahasa di mana fungsi mandiri tidak dapat diganti dengan cepat (C # dan Java tidak dapat mengganti fungsi dengan cepat, Python dapat). Saya memiliki kecenderungan untuk membuat lebih banyak fungsi utilitas sekarang, yang hanya mendorong beberapa boilerplate yang mengganggu sehingga saya benar-benar dapat membaca logika kode saya. (Misalnya, ketika saya perlu memproses semua kombinasi item dalam daftar, saya mendorong pengulangan indeks ke metode ekstensi yang mengembalikanTuples sehingga fungsi asli tidak akan berantakan dengan rincian implementasi tersebut.) Saya melewati lebih banyak hal sebagai parameter untuk fungsi sekarang, alih-alih memiliki fungsi menjangkau beberapa objek lain untuk mengambilnya. (Penelepon mengambil atau membuatnya sebagai gantinya dan meneruskannya.) Sekarang saya meninggalkan lebih banyak komentar yang menjelaskan hal-hal yang tidak jelas hanya dari melihat kode , yang membuat mengikuti logika metode lebih mudah. Saya hanya menulis tes dalam kasus terbatas di mana saya khawatir tentang logika dari sesuatu yang baru saja saya buat, dan saya menghindari menggunakan ejekan. (Saya melakukan lebih banyak input / output pengujian pada potongan-potongan logika yang terisolasi.) Hasilnya adalah kode yang tidak sempurna , tetapi sebenarnya tampak oke, bahkan 2 atau 3 tahun kemudian. Kode yang merespons perubahan dengan cukup baik; hal-hal kecil dapat ditambahkan atau dihapus atau diubah tanpa seluruh sistem berantakan.

Untuk tingkat tertentu, Anda harus melalui periode di mana segala sesuatu berantakan sehingga Anda memiliki beberapa pengalaman untuk pergi. Tetapi jika segala sesuatunya masih kacau sehingga Anda ingin membuang semuanya dan memulai dari awal, ada sesuatu yang salah; kamu tidak belajar.

Dengan mengingat bahwa waktu Anda terbatas. Dan waktu masa depan Anda juga terbatas. Baik untuk pekerjaan atau sekolah atau proyek pribadi, ketika datang ke kode kerja , Anda harus bertanya pada diri sendiri "adalah menulis ulang ini penggunaan terbaik dari waktu saya yang terbatas dan berharga?". Atau mungkin, "apakah ini penggunaan waktu terbatas saya yang paling bertanggung jawab "?

Terkadang jawabannya akan benar-benar ya . Biasanya tidak. Terkadang ada di pagar, dan Anda harus menggunakan kebijaksanaan Anda. Kadang-kadang itu adalah penggunaan waktu Anda yang baik hanya karena hal-hal yang akan Anda pelajari dengan melakukannya.

Saya memiliki banyak proyek, baik pekerjaan maupun pribadi, yang akan mendapat manfaat dari port / penulisan ulang. Saya juga memiliki hal-hal lain untuk dilakukan.

Ini adalah bagian yang sepenuhnya normal dari pembelajaran. Anda menyadari kesalahan saat melangkah.

Itulah cara Anda menjadi lebih baik dan itu bukan sesuatu yang harus Anda hindari.

Anda dapat memberikan diri Anda pengalaman untuk mengetahui bahwa keinginan untuk menulis ulang biasanya tidak produktif. Temukan beberapa proyek open source yang tua, berbulu, tidak elegan dengan kompleksitas sedang. Cobalah untuk menulis ulang dari awal dan lihat bagaimana Anda melakukannya.

• Apakah desain dari awal Anda menjadi elegan seperti yang Anda harapkan?
• Apakah solusi Anda benar-benar untuk masalah yang sama persis? Fitur apa yang Anda tinggalkan? Kasus tepi apa yang Anda lewatkan?
• Pelajaran apa yang didapat dengan susah payah dalam proyek asli yang Anda hapus dalam mengejar keanggunan?
• Setelah Anda menambahkan potongan-potongan yang hilang kembali ke desain Anda, apakah sebersih itu tanpa mereka?

Pada akhirnya, naluri Anda akan beralih dari berpikir, "Saya bisa menulis ulang sistem ini jauh lebih baik" menjadi berpikir "kekasaran sistem ini mungkin mengindikasikan beberapa kompleksitas yang tidak segera terlihat."