Apa yang buruk tentang pengkodean kreatif? [Tutup]

Saya menonton Bob Ross melukis beberapa "pohon bahagia" malam ini, dan saya telah menemukan apa yang membuat saya stres tentang kode saya belakangan ini.

Komunitas orang-orang di sini dan di Stack Overflow tampaknya menolak segala ketidaksempurnaan. Tujuan saya adalah menulis kode yang terhormat (dan karenanya dapat dipertahankan dan berfungsi), dengan meningkatkan keterampilan saya. Namun, saya membuat kode secara kreatif.

Izinkan saya menjelaskan apa yang saya maksud dengan "pengkodean kreatif":

• Langkah pertama saya dalam sebuah proyek adalah sering duduk dan menghapus beberapa kode. Untuk hal-hal yang lebih besar, saya berencana sedikit di sana-sini, tetapi kebanyakan saya hanya menyelam.
• Saya tidak membuat diagram kelas saya, kecuali saya bekerja dengan orang lain yang membuat karya lain di proyek. Meski begitu, tentu saja itu bukan hal pertama yang saya lakukan. Saya biasanya tidak bekerja pada proyek besar, dan saya tidak menemukan visual yang sangat berguna.
• Babak pertama kode yang saya tulis akan ditulis ulang berkali-kali, saat saya menguji, menyederhanakan, mengulang, dan mengubah hack asli menjadi sesuatu yang dapat digunakan kembali, logis, dan efisien.

Selama proses ini, saya selalu membersihkan. Saya menghapus kode yang tidak digunakan, dan berkomentar apa pun yang tidak jelas. Saya menguji terus-menerus.

Proses saya tampaknya bertentangan dengan apa yang dapat diterima di komunitas pengembang profesional, dan saya ingin memahami alasannya.

Saya tahu bahwa sebagian besar keluhan tentang kode buruk adalah bahwa seseorang terjebak dengan kekacauan mantan karyawan, dan menghabiskan banyak waktu dan uang untuk memperbaikinya. Itu saya mengerti. Yang tidak saya mengerti adalah bagaimana proses saya salah, mengingat hasil akhirnya mirip dengan apa yang akan Anda dapatkan dengan merencanakan semuanya dari awal. (Atau setidaknya, itulah yang saya temukan.)

Kecemasan saya atas masalah ini sangat buruk belakangan ini sehingga saya berhenti menulis kode sampai saya tahu semua yang ada tentang setiap metode untuk memecahkan masalah tertentu yang sedang saya kerjakan. Dengan kata lain, saya sebagian besar telah berhenti coding sama sekali.

Saya sangat menghargai masukan Anda, tidak peduli apa pendapat Anda tentang masalah ini.

Sunting: Terima kasih semua atas jawaban Anda. Saya telah belajar sesuatu dari mereka masing-masing. Anda semua sangat membantu.

Tidak ada yang salah dengan kode-tes-refactor-ulangi, katakan saja kepada orang-orang bahwa Anda membuat prototipe.

Di sisi lain, untuk proyek yang lebih besar Anda akan menemukan bahwa beberapa pemikiran yang diberikan untuk desain di muka akan menghemat banyak waktu dalam lingkaran oh-omong kosong-sekarang-apa!

PS: Teknik diagram membantu Anda mempelajari keterampilan berpikir visual, yang sangat berharga bahkan jika tidak ada seorang pun kecuali Anda pernah melihat diagram Anda.

Saya selalu lebih suka kode yang jelas, dapat dibaca, sederhana daripada kode yang disajikan secara visual, UMLed, pola-desain, di mana kelas / antarmuka menyertakan nama pola seperti "ItemVisitor" (?!). Pola desain, teknik OO, dan yang lainnya adalah memformalkan aturan. Aturan itu datang dari akal sehat.

Tidak mungkin untuk bekerja tanpa formalisasi itu (kecuali jika Anda bekerja sendiri pada proyek Anda sendiri) dan formalisasi berlebihan meningkatkan biaya proyek. Jangan pernah mengabaikan kebutuhan orang lain untuk memahami kode Anda. Kode terbaik adalah yang paling sederhana.

Jangan pernah ragu untuk menulis ulang kode Anda. Saya akan mendapatkan X downvotes (X> = 10) untuk ini, tapi saya akan membuatnya tebal: penggunaan kembali kode bukanlah hal yang paling penting .

Sebelum menatap kode, Anda harus mempertimbangkan kasus penggunaan yang akan diterapkan oleh kode. Karena perangkat lunak itu digunakan, dan bukan untuk dikembangkan. Kegunaan, kegunaan adalah dua target paling penting dan tidak masalah siapa yang akan menggunakan perangkat lunak itu - pengembang lain dari bagian proyek yang bergantung, atau pengguna akhir.

Aku juga sama. Dengarkan ketika orang lain memberi tahu Anda tentang hal-hal yang berhasil bagi mereka, tetapi abaikan siapa saja yang memberi tahu Anda apa yang "harus" Anda lakukan seolah-olah ada beberapa kewajiban moral untuk itu. Jika Anda menemukan sesuatu yang sesuai untuk Anda, ikuti saja. Maksud saya, hasil akhirnya adalah yang penting bukan? Siapa yang benar-benar peduli dengan jalan yang Anda ambil untuk sampai ke sana?

Ingat: orang berbeda . Itu hal yang baik. Jangan dengarkan orang yang mencoba membuat Anda menyukai mereka, dan tahan keinginan untuk membuat orang lain menyukai Anda dan Anda akan baik-baik saja.

Tampaknya Anda adalah:

1. Mencoba berbagai hal untuk menemukan pendekatan terbaik (bereksperimen, desain tambahan)
2. Menulis ulang kode untuk membuatnya lebih bersih (refactoring)
3. Secara konstan menulis tes (pengembangan yang digerakkan oleh tes)

Apa yang Anda lakukan itu luar biasa! Sepertinya Anda melakukannya dengan benar, terutama jika Anda sudah menemukannya sendiri dan tidak mempelajarinya dari buku pemrograman (lincah). Jelas ada lebih dari ini, tetapi Anda punya nilai dipaku. Hanya ingat untuk refactor dan meningkatkan desain saat Anda menambahkan kode dan seharusnya tidak perlu untuk BDUF .

Sudahkah Anda mempertimbangkan untuk berfokus pada satu fitur kecil pada satu waktu , dan dirilis setelah setiap fitur selesai? Itu mungkin membantu Anda melepaskan diri dari masalah analisis apa pun yang Anda hadapi dan menunjukkan kemajuan nyata bagi Anda sebagai atasan.

Juga, saya tidak tahu apa "komunitas pengembangan profesional" yang Anda bicarakan, tetapi jika Anda, saya akan memberitahu mereka untuk kembali ke menara gading mereka sehingga Anda dapat melanjutkan pekerjaan Anda!

Brad, kamu tidak sendirian. Saya kenal programmer yang sangat baik yang bekerja dengan cara yang persis sama seperti yang Anda gambarkan. :)

Jika Anda membersihkan kode Anda dan tahu bagaimana membuatnya efisien dan mudah dibaca, maka Anda tentu telah mengembangkan rasa bagaimana menulis kode yang bersih dan efisien di muka juga.

Selain itu, tidak ada yang dapat sepenuhnya direncanakan sebelumnya, dan rute terpendek untuk menemukan seluk-beluk adalah sering menjalankan kode dan memahami detail yang diabaikan.

Saya pikir Anda baik-baik saja, dan gaya pemrograman yang Anda jelaskan benar-benar valid.

Saya pikir itu layak untuk melengkapi jawaban di atas dengan kutipan dari Alan J. Perlis, dari kata pengantar buku MIT yang terkenal "Struktur dan Interpretasi Program Komputer", yang biasa disebut "SICP":

Setiap program komputer adalah model, yang ditetaskan dalam pikiran, dari proses nyata atau mental. Proses-proses ini, yang timbul dari pengalaman dan pemikiran manusia, jumlahnya sangat banyak, rumit secara terperinci, dan setiap saat hanya sebagian yang dipahami. Mereka dimodelkan untuk kepuasan permanen kita jarang oleh program komputer kita. Jadi, meskipun program kami secara hati-hati mengoleksi koleksi simbol, mosaik fungsi yang saling terkait, mereka terus berevolusi: kita mengubahnya sebagai persepsi kita tentang model yang semakin dalam, membesar, menggeneralisasi sampai model akhirnya mencapai tempat metastable di dalam model lain yang dengannya kami berjuang. "

Ada Pintar Bagus dan Buruk Pintar.

Good Clever - rasio tinggi antara baris kode yang pandai vs baris dalam alternatif yang tidak pintar. 20 baris kode yang menyelamatkan Anda dari penulisan 20000 adalah Extremely Good Clever. Good Clever adalah tentang menyelamatkan diri Anda dari pekerjaan.

Bad Clever - rasio rendah antara baris kode yang ditulis tertulis vs baris kode yang disimpan. Satu baris kode pintar yang menyelamatkan Anda dari penulisan lima baris kode adalah Bad Clever. Pintar pintar adalah tentang "masturbasi sintaksis".

Sebagai catatan: Bad Clever hampir tidak pernah disebut "Bad Clever"; sering bepergian dengan alias "cantik", "anggun", "ringkas", atau "singkat".

Saya pasti bisa mengenali diri saya dengan cara Anda menggambarkan alur kerja Anda. Begini masalahnya: ketika saya mulai bekerja di lingkungan kelompok, hampir semua hal itu HARUS berubah.

Pekerjaan saya selama sekitar 8 bulan sekarang benar-benar pengalaman pertama saya bekerja di tim pengembang pada satu proyek. Sampai sekarang, secara harfiah seluruh karier saya adalah sebagai pembuat kode sendirian yang tidak harus berurusan dengan semua yang datang dengan kerja tim. Bahkan ketika saya bekerja dalam sebuah kelompok, itu selalu merupakan pekerjaan yang cukup sunyi - saya memiliki proyek saya yang adalah MILIKKU, atau bagian saya itu adalah MILIKKU, dll. Itu adalah kurva pembelajaran yang menarik ketika saya membawa diri saya sendiri untuk mempercepat dengan suatu lingkungan kerja tim yang benar-benar kolaboratif.

Inilah hal utama yang saya sadari: jika tidak jelas apa yang Anda lakukan, Anda mungkin sedang menulis sakit kepala rekan kerja berikutnya. Sebagian besar kerewelan "berorientasi proses" yang Anda lihat di sini berkaitan dengan fakta bahwa banyak dari kita telah menjadi rekan kerja dengan sakit kepala. Dan kebanyakan teori manajemen proses perangkat lunak berkaitan dengan meminimalkan sakit kepala itu.

Jadi hal-hal seperti merencanakan rencana yang telah disepakati sebelumnya, dll. Itu adalah tentang memiliki tim di papan dan sinkron. Jika Anda adalah tim, Anda sudah sinkron dengan diri Anda sendiri, dan itu tidak terlalu penting.

Tidak ada yang salah dengan pendekatan Anda sebagai bentuk seni kreatif. Jika Anda berkembang untuk keuntungan pribadi, dan apa yang Anda lakukan bermanfaat bagi Anda, dan Anda merasa menyenangkan mungkin sama pentingnya dengan hasil akhir seperti produk itu sendiri.

Dalam lingkungan kerja profesional, jika skala waktu proyek Anda pendek, mungkin sekitar 2 - 3 minggu atau kurang, maka pendekatan Anda disebut prototyping cepat dan cukup sesuai dengan tugas-tugas di depan.

Namun pada proyek yang lebih lama, bahkan ketika Anda sedang mengerjakan sendiri, pendekatan seperti itu mungkin merupakan kemewahan yang mahal bagi majikan Anda. Menghabiskan beberapa hari dari anggaran proyek pada desain arsitektur dimuka dan kemudian menguji arsitektur terhadap bagaimana jika manajemen memutuskan untuk mengubah spesifikasi dengan ... biasanya menghabiskan waktu dengan baik dan akan mengembangkan keterampilan Anda untuk menjadi programmer / arsitek yang lebih bernilai lebih jauh di dalam karir Anda.

Dua perspektif:

1. Tidak ada yang harus memelihara lukisan.

2. Siapa pun yang pernah menonton Bob Ross melukis lukisan tahu bahwa lukisan memiliki struktur. Jika Anda akan mengambil satu pelajaran dari Bob Ross, perencanaan sebelumnya dan bekerja secara terorganisir membuat proses berjalan lancar dan terlihat sederhana.

Kode saya cukup banyak dengan cara yang sama. Saya hanya akan mulai menulis dan ketika saya melihat pola muncul, saya refactor. Anda bisa melukis diri sendiri ke sudut itu, Anda harus tahu kapan harus duduk dan memikirkan masalah, tetapi kadang-kadang Anda hanya menusuknya untuk benar-benar memahami masalahnya.

Tapi saya ingin tahu tentang ini:

Komunitas orang-orang di sini dan di Stack Overflow tampaknya menolak segala ketidaksempurnaan. [..] Proses saya tampaknya bertentangan dengan apa yang dapat diterima di komunitas pengembang profesional, dan saya ingin memahami alasannya.

Bagaimana orang di Stack Overflow mengetahui proses Anda? Dan apa yang Anda maksud dengan "tolak"? Secara alami, kode yang diposting ke komunitas pemrograman akan diperiksa secara kritis. Tetapi jika seseorang melihat area di mana kode Anda dapat ditingkatkan, itu hanya bisa menjadi hal yang baik, bukan?

Mudah-mudahan, ketika memposting pertanyaan ke Stackframe, Anda membersihkan kode Anda dan mencoba menguranginya ke bentuk sesederhana mungkin, karena rasa hormat kepada pembaca Anda (Anda kadang-kadang memecahkan masalah Anda sendiri hanya berusaha membuatnya layak untuk orang lain), di mana jika ada umpan balik yang baik. Jika Anda memposting kode yang Anda tahu buruk, dan Anda tahu mengapa itu buruk sebelum Anda mempostingnya, Anda tidak boleh mengambilnya secara pribadi jika orang melihat bahwa itu buruk.

Saya juga menggunakan pendekatan Anda. Ini bekerja lebih baik untuk saya, karena mengurangi risiko overengineering.

Apa yang sering saya lakukan adalah menyelesaikan masalah dengan kode seminimal mungkin, yang biasanya mengarah pada ketergantungan yang jelas tidak perlu atau masalah desain lainnya. Lalu saya refactor kode yang berfungsi menjadi kode yang indah.
Sebagai contoh, saya mengurangi ketergantungan antara modul yang berbeda untuk antarmuka yang ringkas dan memikirkan pertanyaan data mana yang harus disimpan di mana, sampai setiap modul hanya bergantung pada abstraksi yang sangat minimalis dari modul lainnya. Bisa dibilang, saya menunda keputusan akhir, modul mana yang harus memiliki tanggung jawab. Saya menunda abstraksi.
Menempatkan terlalu banyak pemikiran untuk memisahkan masalah ke dalam tanggung jawab yang berbeda, menjadi abstraksi yang berbeda, tidak baik. Ini akan memaksa Anda untuk menekuk implementasi Anda agar sesuai dengan abstraksi yang Anda buat. Kode berfungsi, jika menghasilkan hasil yang Anda inginkan dan jika dapat dipertahankan. Sebuah desain berfungsi, jika Anda dapat mengimplementasikannya melalui kode yang baik. Jika kode tidak berfungsi, Anda mengubahnya. Ergo, jika suatu desain tidak berfungsi, Anda harus mengubahnya juga. Anda hanya dapat melihat apakah suatu desain berfungsi, setelah Anda mengimplementasikannya.

Jadi memiliki sketsa sederhana dalam pikiran sudah cukup sebagai desain, sebelum Anda mulai menghidupkannya. Desain ulang, abstrak, dan refactor sesuai kebutuhan .

Saya pikir jika Anda akan pandai pemrograman, setidaknya kadang-kadang harus menyenangkan, dan itu berarti menjadi kreatif.

Tentunya ketika pemrograman dalam kelompok setidaknya ada standar minimal yang harus diikuti, bukan karena alasan "moral", tetapi untuk yang praktis, ketika mereka berlaku.

Di luar itu, menarik dan menyenangkan untuk menyelidiki batas untuk melihat apa yang dapat ditemukan di sana. Suatu ketika ketika bekerja pada Mini dalam bahasa assembly, saya menemukan bahwa Anda dapat membuat co-rutin yang dapat beralih dari satu ke yang lain dengan 1 instruksi. Kemudian saya menemukan cara membuat rutinitas mandiri yang bisa maju dua langkah, satu langkah mundur, dll. Apakah itu berguna? Aku meragukan itu. Itu bukan intinya.

Suatu ketika saya mendengar ceramah oleh Edsger Dijkstra, berbicara tentang kreativitas dalam pemrograman. Dia menyebutkan bagaimana seorang siswa menemukan cara untuk melakukan rotasi n-bit dari kata n + m-bit. Itu dilakukan dengan 3 bitswaps. Pertama Anda menukar bit n, kemudian Anda menukar bit m, kemudian Anda menukar seluruh bit n + m. Berguna? Tidak. Pintar? Iya nih.

Adalah baik untuk merasa bebas untuk mencoba hal-hal yang tidak akan dilakukan oleh orang yang waras.

Ini mungkin merupakan kasus "satu ukuran tidak cocok untuk semua". Anda telah membuat gaya bekerja untuk proyek-proyek yang telah Anda ikuti, jadi siapa yang akan berdebat dengan itu? Namun, kritik yang Anda baca di sini dan di SO mungkin bekerja pada proyek yang lebih besar, atau pada proyek yang membutuhkan koordinasi yang kompleks antara anggota tim.

Gaya pengembangan Anda bisa menjadi masalah jika Anda pernah terlibat dalam proyek-proyek besar yang melibatkan kerja sama antara banyak pengembang. Sulit untuk menjadwalkannya, sulit untuk melacak kemajuan Anda, dan tidak ada cara bagi Anda sesama programmer untuk merencanakan sedikit pekerjaan mereka yang bergantung pada mengetahui apa yang sedang Anda lakukan.

Anda mungkin tertarik membaca Dreaming in Code untuk melihat apa yang bisa terjadi ketika sebuah proyek besar mengadopsi gaya pengembangan yang mirip dengan Anda.

Banyak jaminan bahwa metode Anda tidak salah, tetapi izinkan saya menambahkan beberapa pengalaman pribadi. Saya memulai dengan cara Anda, tetapi sementara itu saya belajar manfaat dari perencanaan sebelumnya setidaknya bagian dari struktur umum, dan ini karena sejumlah alasan:

• Ekstra terbesar adalah lebih mudah untuk melihat kode mana yang dapat digunakan kembali jika bekerja sedikit. Saya sering menulis sepotong kode yang, ketika menulis, tiba-tiba terasa berguna untuk bagian lain dalam skema umum yang saya gantung di samping layar saya (digambar di atas kertas dengan gaya yang hanya dapat diatur untuk saya).

• Memiliki skema memungkinkan Anda untuk memperbaiki tidak hanya kode, tetapi juga skema. Kadang-kadang saya sibuk menulis kelas yang tiba-tiba muncul berguna untuk bagian lain dalam skema juga. Akibatnya skema menjadi lebih sederhana ketika proyek berjalan

• Setiap kali saya memperbarui skema itu juga dengan input yang diperlukan dan keluaran fungsi / metode, dan slot yang tersedia di kelas. Ini lebih cepat untuk menggunakan kembali bit: Saya tidak harus menyelam dalam kode setiap kali untuk memeriksa apa yang sebenarnya masuk dan keluar. Meskipun ada di komentar, saya masih harus menelusuri untuk mendapatkan komentar

Jadi sebenarnya, saya menggunakan metode Anda juga. Saya baru saja memulai, mencoba, refactor, mencoba lagi, mengubah sedikit lagi dan seterusnya, tetapi siklus saya juga termasuk skema. Dan ketika itu selesai, saya menambahkan informasi untuk yang berikutnya yang berfungsi pada kode itu.

Pikiran Anda, ini untuk proyek-proyek tempat saya bekerja sendirian. Jika Anda bekerja dengan lebih banyak orang pada kode yang sama, perencanaan ke depan bukan hanya logika, itu penting. Tapi saya kira Anda sudah tahu itu.

Dan seperti yang orang lain katakan: ini cara saya , jarak tempuh Anda mungkin berbeda.