Bagaimana cara melatih diri Anda untuk menghindari penulisan kode "pintar"? [Tutup]

Apakah Anda tahu perasaan itu ketika Anda hanya perlu memamerkan trik baru dengan Expressionatau menggeneralisasi tiga prosedur yang berbeda? Ini tidak harus pada skala Arsitektur Astronaut dan pada kenyataannya mungkin bermanfaat tetapi saya tidak bisa tidak memperhatikan orang lain akan menerapkan kelas atau paket yang sama dengan cara yang lebih jelas, langsung (dan kadang-kadang membosankan).

Saya perhatikan saya sering merancang program dengan mengatasi masalah , kadang-kadang dengan sengaja dan kadang-kadang karena bosan. Dalam kedua kasus, saya biasanya jujur ​​percaya solusi saya jernih dan elegan, sampai saya melihat bukti yang bertentangan tetapi biasanya sudah terlambat. Ada juga bagian dari saya yang lebih suka asumsi tidak berdokumen untuk duplikasi kode, dan kepintaran untuk kesederhanaan.

Apa yang bisa saya lakukan untuk menahan keinginan untuk menulis kode "cerdik" dan kapan bel berbunyi bahwa saya Melakukannya Salah ?

Masalahnya semakin mendesak karena saya sekarang bekerja dengan tim pengembang yang berpengalaman, dan kadang-kadang upaya saya untuk menulis kode cerdas tampak bodoh bahkan bagi diri saya sendiri setelah beberapa waktu menghilangkan ilusi keanggunan.

Masalahnya semakin mendesak karena saya sekarang bekerja dengan tim pengembang yang berpengalaman, dan kadang-kadang upaya saya untuk menulis kode cerdas tampak bodoh bahkan bagi diri saya sendiri setelah beberapa waktu menghilangkan ilusi keanggunan.

Solusi Anda ada di sini. Saya menganggap bahwa "berpengalaman" dalam konteks ini berarti "lebih berpengalaman daripada Anda." Paling tidak, Anda jelas menghormati mereka. Ini adalah kesempatan belajar yang berharga - dengan asumsi ego Anda dapat menerima pukulan. (Hal-hal menjengkelkan, ego. Sayang sekali kita membutuhkannya.)

Apakah Anda memiliki ulasan kode dengan orang-orang ini? Jika demikian, jika mereka belum melakukannya, mintalah secara eksplisit untuk memanggil Anda dengan omong kosong. Sebutkan bahwa Anda telah melihat kecenderungan pada diri Anda sendiri untuk mendesain berlebihan, untuk menggunakan jackhammer pneumatik top-of-the-line yang dirancang cermat (lebih disukai dipegang oleh semacam android pekerja jalan otomatis) ketika palu cakar sederhana akan lebih dari cukup. .

Anda mungkin sering mendapati diri Anda menggeliat di kursi Anda sementara wajah Anda memerah selama ulasan kode. Bertahanlah. Anda sedang belajar.

Kemudian, setelah Anda memiliki beberapa dari ini di bawah ikat pinggang Anda, perhatikan saat-saat di mana Anda curiga Anda mungkin overdesigning. Ketika saat-saat itu datang, tanyakan pada diri sendiri: "Jika seseorang memanggil saya tentang hal ini selama tinjauan kode, dapatkah saya membela solusi saya sebagai yang terbaik yang tersedia? Atau apakah ada solusi yang lebih sederhana yang saya tinggalkan?"

Terkadang, peer review adalah cara terbaik untuk melihat pekerjaan Anda dengan baik.

Hal terbaik yang harus dilakukan adalah mengingat pepatah Brian Kernighan:

“Debugging dua kali lebih sulit daripada menulis kode di tempat pertama. Karena itu, jika Anda menulis kode sepintar mungkin, Anda, menurut definisi, tidak cukup pintar untuk men-debug itu. "

Biasanya ada setidaknya tiga solusi untuk masalah perangkat lunak yang penting: cara yang jelas, cara yang tidak terlalu rumit (pintar), dan cara sederhana yang tidak jelas (elegan). Kutipan tentang penulis berlaku di sini:

Tuliskan semua yang ada di kepala Anda dan kemudian Anda seorang penulis. Tetapi seorang penulis adalah orang yang dapat menilai nilai barang-barangnya sendiri, tanpa belas kasihan, dan menghancurkan sebagian besar dari barang-barang itu. - Colette

Anda tidak akan dapat menulis kode elegan sampai Anda dapat menilai nilai kode Anda sendiri, tanpa belas kasihan, dan menghancurkan sebagian besar kode itu. Jika Anda menilai kode elegan pada hasil akhirnya, itu tampak mudah, tetapi perlu memperlambat, melalui banyak konsep, mencari saran dari orang lain, dan mengeluarkan apa yang tidak tepat di halaman. Itu berarti bahkan jika kode Anda berfungsi dengan baik, Anda bertanya pada diri sendiri atau kolega mengapa ada yang tidak beres, sampai Anda puas dengan jawabannya. Mungkin rasanya terlalu lama, atau berulang, atau Anda merasa kompiler seharusnya bisa menangkap bug jenis tertentu. Kebanyakan pemrogram dengan sedikit pengalaman dapat mengenali kode tidak elegan dengan mudah. Kuncinya adalah mencari tahu mengapa .

Itulah cara metodis untuk menulis kode yang lebih elegan. Ini juga sering membutuhkan kilasan wawasan yang membantu Anda melihat masalah dengan cara baru. Ini lebih sulit untuk dicapai, tetapi membantu untuk memperlambat dan hanya memikirkan masalah sebelum Anda terjun ke pengkodean. Ketika Anda menemukan solusi yang baik, cari solusi yang lebih baik. Membaca kode lain membantu. Mengambil kelas atau membaca buku tentang praktik terbaik membantu. Mempelajari paradigma pemrograman lain membantu. Meminta saran dari kolega yang kode yang Anda kagumi membantu.

Saya akan menambahkan jawaban yang ada, mengembangkan dengan cara TDD, jadi Anda pertama kali menulis tes tentang apa yang harus dilakukan kode Anda, dan kemudian menerapkannya untuk membuat tes Anda menjadi hijau. Dengan cara ini, Anda hanya akan memenuhi persyaratan yang diterapkan oleh tes. Karena Anda akan menulis ujian, ini adalah cara yang baik untuk pendekatan disiplin diri untuk berkembang.

Ketika bekerja untuk tim besar dan dinamis yang membentang di banyak set keterampilan dan tahun yang berbeda, pengembangan memiliki perkembangan alami untuk "dumbed" ke tingkat terendah dari anggota tim yang paling konservatif atau paling kurang intelektual, saat ini atau historis.

Ini mungkin tidak selalu menjadi hal yang buruk karena kode pintar mungkin lebih sulit untuk di-debug, lebih sulit untuk disampaikan dalam spesifikasi teknis, dan membutuhkan waktu lebih lama untuk menulis, memperlambat waktu pengembangan.

Ada kalanya kode pintar penting, seperti ketika kode pintar memberi efisiensi dan peningkatan kinerja di kemudian hari dalam siklus kematangan perangkat lunak saat kinerja menjadi persyaratan.

Kode pintar juga memiliki cara menyampaikan kode yang lebih cepat untuk dikembangkan dan lebih mudah dibaca serta dimengerti oleh tim yang mungkin tidak terpapar dengan fitur bahasa baru atau panggilan perpustakaan. Misalnya, ketika saya pertama kali diperkenalkan ke Linq oleh pengembang junior, saya langsung merasa jijik karena tidak perlu, sulit untuk di-debug, bodoh, dan "pintar". Setelah bermain dengannya sendiri dan menemukan betapa bermanfaat dan kuatnya permintaan Linq, saya menginvestasikan waktu untuk mempelajarinya dan kode DAL saya tidak pernah lebih bersih dan mudah dibaca, serta lebih mudah untuk di-debug dan diperluas.

Saya menyesal tidak memiliki pikiran terbuka sebelumnya dan berharap saya tidak akan begitu keras pada pengembang junior yang "pintar".

Maksud saya adalah bahwa kode "pintar" HARUS dicurigai, tetapi kita tidak harus terus menentangnya karena itu dapat menghambat kreativitas dan inovasi.

EDIT: Saya baru sadar saya tidak sepenuhnya menjawab pertanyaan Anda. Jika Anda memiliki kapasitas dalam proyek Anda untuk dengan mudah menulis kode pintar maka mungkin tim harus mengadopsi standar pengkodean yang lebih ketat untuk mengikuti template dan gaya yang seragam dan berbeda. Ini akan membantu menarik garis kotak pasir Anda sehingga Anda tidak berkeliaran di jalan mengejar bola.

Jika 20% (% Anda dapat bervariasi) atau lebih dari baris Anda yang ditambahkan harus berupa dokumentasi - saatnya untuk mundur dan memikirkan kembali .

Saya benar-benar berpikir Anda harus berusaha untuk menjadi pintar, itu adalah efek samping alami dari semakin mahir. Memberi diri Anda panduan umum seperti% komentar yang diperlukan untuk membuat diri Anda jelas adalah cara yang baik untuk memaksa diri Anda untuk mundur dan mengevaluasi jika menggunakan hal baru yang Anda pelajari adalah pilihan bijak atau hanya cara untuk memamerkan mainan baru Anda.

Saya tidak bisa menahan diri untuk tidak mencoba sesuatu yang pintar.

Jadi saya melakukannya di proyek mainan, di waktu saya sendiri, di rumah.

Ketika hal baru hilang - masalah terpecahkan.

Saya percaya bahwa salah satu cara untuk mengetahui apakah kode Anda terlalu "pintar" adalah dengan mengambil langkah mundur dan bertanya pada diri sendiri hal berikut:

Jika saya memberikan cetakan kode ini kepada seseorang yang belum pernah mengerjakan proyek / kode ini, akankah mereka dapat membacanya dan menjelaskan kembali kepada saya apa fungsinya (setelah memberi mereka konteks singkat)? Jika tidak, berapa banyak penjelasan yang harus saya lakukan? Bagaimana saya menjelaskan hal ini kepada seseorang yang menggunakan CS101?

Jika ternyata Anda harus memandu seseorang melewati setiap baris atau sebagian besar baris dalam suatu metode atau kelas, itu mungkin terlalu pintar. Jika Anda harus menjelaskan konstruksi bahasa (LINQ misalnya) kepada seseorang yang tidak terbiasa dengan itu, itu mungkin OK. Jika Anda harus melihat satu baris dan memikirkannya sebentar sebelum Anda bisa menjelaskannya, kode Anda perlu dire-refored.

1) Terbakar karenanya sebelum Anda tahu itu hal yang buruk. Mencoba men-debug sesuatu dari dulu yang ditulis dengan cerdik sangat menyenangkan. Saya pikir Anda sudah membahasnya.
2) Komentari kode Anda, jelaskan apa yang Anda lakukan sebelum setiap bagian kode.
3) Jika Anda kesulitan menjelaskannya, atau merasa perlu memasukkan diagram, maka apa yang baru saja Anda lakukan terlalu pintar dan mungkin bisa dilakukan dengan lebih bersih.

Solusi cerdas untuk masalah bisa menjadi fantastis, sampai Anda harus men-debug atau memperluasnya. Terkadang itu satu-satunya solusi. Jika Anda dapat menggambarkan secara akurat apa yang dilakukannya, dan bagaimana melakukannya, solusi cerdas dapat diterima.

Saya biasanya menggunakan komentar untuk menggambarkan apa yang saya lakukan dengan bagian kode. Jika sepertinya tidak membingungkan, saya juga menjelaskan bagaimana saya melakukannya. Idealnya, kode harus jelas dan jelas. Tetapi jika saya berjuang untuk menjelaskan bagaimana saya melakukan apa yang baru saja saya lakukan, maka itu pertanda jelas bahwa saya perlu mundur dan mencoba lagi.

Mungkin cara yang baik untuk mulai menulis kode sederhana adalah melepaskan gairah kepintaran pada proyek yang meminta kepintaran . Sisa jawabannya adalah khusus untuk .NET tapi saya yakin orang dapat menemukan proyek tingkat yang serupa dalam bahasa lain.

Ada kerangka kerja injeksi ketergantungan sumber terbuka untuk bekerja yang hanya meminta Expressionpengetahuan trik, ada F # dan berbagai tugas indah yang mungkin ingin dicoba.

Jika Anda menyukai matematika (dan itu agnostik bahasa ), ada Project Euler untuk Anda.

Terakhir, tetapi tidak sedikit, di dunia .NET ada Proyek Mono yang memiliki banyak bidang yang perlu perhatian pengembang , beberapa di antaranya cukup rumit. Bagaimana dengan berkontribusi pada alat analisis kode .NET statis open source ? Ada beberapa analisis IL yang terlibat, serta hal-hal tingkat tinggi. Jb Evain selalu bekerja pada sesuatu yang menarik, apakah itu perpustakaan refleksi Cecil, Expressiondukungan atau dekompiler .NET.

Jika tidak ada yang cocok, mulai saja kerangka mengejek Anda sendiri :-)

Apakah Anda tahu perasaan itu ketika Anda hanya perlu memamerkan trik baru dengan Ekspresi atau menggeneralisasi tiga prosedur yang berbeda?

Tidak

Ini adalah salah satu alasan mengapa saya selalu mengatakan bahwa ini adalah hal yang baik ketika pengembang baru dilemparkan ke dalam kekacauan besar kode speghetti tidak berdokumen untuk dipelihara dan diperbaiki. Ini akan mengajari mereka kenyataan mempertahankan kode yang terlalu 'pintar' yang tidak mereka tulis, dan mudah-mudahan menanamkan empati bagi orang bodoh yang harus men-debug kode mereka 5 tahun dari sekarang.

Saya pikir topiknya dipilih dengan baik. "Keren" untuk menulis satu baris Perl yang melakukan sepuluh ribu hal sekaligus, tetapi kemudian menyebalkan ketika Anda harus memeriksanya kembali.

Pada catatan yang berbeda, pintar atau tidak, kode harus didokumentasikan. Ada ketidakcocokan yang melekat inheren antara bahasa pemrograman yang diterima industri dan konsep tingkat tinggi yang kita sebagai manusia terbiasa dalam pemikiran kita. Kode mendokumentasikan diri sama sekali tidak dapat direalisasikan - sampai menjadi bahasa alami, yaitu. Bahkan kode Prolog perlu didokumentasikan, karena, betapapun tingginya levelnya, masih agak formal.

Kode imperatif berbutir halus berfungsi untuk mengimplementasikan rencana berbutir kasar - yang perlu didokumentasikan. Saya tidak ingin harus membaca seluruh 50 baris metode ketika komentar roadmap 3-line cepat akan dilakukan.

Sunting kemudian: Contoh yang lebih fasih adalah salah satu yang melampaui komputer. Sebuah buku mungkin ditulis dengan sangat baik, tetapi kita sering ingin memprosesnya pada tingkat abstraksi yang berbeda. Seringkali, ringkasan buku akan dilakukan, dan itulah yang dapat ditawarkan komentar pada kode. Tentu saja kode yang diabstraksi dengan baik bisa sangat membantu dokumentasi diri, tetapi tidak bisa memberikan Anda semua level abstraksi.

Dan komentar juga dapat bertindak seperti sidenote dalam sebuah buku, ketika kita perlu menjelaskan proses penalaran di balik klaim dalam teks utama tanpa mengacaukannya.

Dengan konteks ini, saya menemukan bahwa pernyataan saya sebelumnya yang merujuk pada bahasa alami yang melampaui kebutuhan akan komentar tidak benar. Bahkan bahasa alami, seperti dalam sebuah buku, dapat meminjamkan dirinya untuk dokumentasi, untuk menjelaskan dengan cara yang jarang abstraksi yang terkandung dalam teks, atau untuk mengambil jalan memutar tanpa merusak teks utama. Dengan catatan bahwa kode yang diabstraksi dengan baik mungkin sudah berjalan jauh untuk mendokumentasikan diri.

Terakhir, namun tidak kalah pentingnya, komentar dapat membantu pembuat kode tetap pada abstraksi tingkat tinggi. Sering kali saya menyadari bahwa dua komentar berturut-turut yang saya sertakan dalam daftar langkah tidak berbicara pada tingkat abstraksi yang sama, yang segera memberikan pandangan kritis pada apa yang saya lakukan dengan kode itu.

Masalah tertentu melampaui kode dan memengaruhi kode seperti aktivitas lainnya. Komentar dapat memberikan bantuan dalam menjelaskan alasan di balik, dan segi-segi kode kita, dan saya menemukan mereka teman yang menyenangkan yang berbicara bahasa yang lebih lembut untuk memberi manfaat bagi orang tersebut untuk perubahan.

Bagaimana? Terus perlihatkan kode Anda kepada para pengembang berpengalaman tersebut. dan ketika Anda diledakkan karena menjadi mahasiswa dan sok, menghisapnya, dan bertanya kepada mereka bagaimana mereka melakukannya dan mengapa (tentu saja dengan cara yang tidak konfrontatif).

Edit dalam terang -1:

Beberapa bulan yang lalu, saya berada dalam situasi yang sama - saya memiliki satu bos yang akan merasa ngeri setiap kali saya menggunakan pointer di Delphi atau 'dengan konstruk', yang lain mengancam akan memecat saya jika saya tidak berhenti melakukan shortcircuiting semua booleans saya dengan 0-1 dan menggunakan variabel huruf tunggal di mana-mana.

Saya belajar karena saya bertanya mengapa dan mereka kesulitan menjelaskan karena mereka pikir saya mungkin berjumlah sesuatu - LOL ....

Apakah saya merasa perlu untuk pamer? Tidak, tidak lagi. Bagaimana saya bisa melewatinya? Seperti kebanyakan orang melewati kebiasaan buruk lainnya ... praktik sadar dan sengaja teknik yang tepat. Anda cukup melakukannya, Anda akan memahami nilai praktik terbaik dan melalui penggunaannya yang konstan, Anda akan mengembangkan kebiasaan yang baik.

Sadari juga bahwa dengan berfokus pada perangkat lunak fungsional, tepat waktu dan mudah dipelihara, Anda akan mendapatkan pengakuan yang Anda cari. Pengembang yang berpengalaman akan mendatangi Anda dan berkata, "Man, modul yang Anda tulis dirancang dengan baik. Saya hanya perlu menerapkan satu komponen untuk menghubungkannya ke proyek saya." sebagai lawan dari "Saya harus mengerjakan ulang seluruh modul yang Anda tulis hanya untuk menggunakannya dalam komponen lain? Pernahkah Anda mendengar tentang Bob Martin atau Ward Cunningham?"

TLDR: Anda tidak sendirian. Pengakuan keterampilan paling baik dicapai sebagai produk sampingan dari pemecahan masalah dengan cara yang cerdas.

Bagi saya, kode yang terlalu pintar sering berusaha untuk memecahkan persyaratan masa depan imajiner daripada berfokus pada persyaratan saat ini. Jebakan besar!

0% kode terlalu rumit bukanlah tujuan yang dapat dicapai. Mungkin bahkan bukan tujuan terbaik untuk diperjuangkan. Kode yang terlalu rumit itu buruk, tetapi Anda harus mencoba hal-hal baru untuk tumbuh sebagai seorang programmer. Anda tidak boleh mencobanya dengan kode produksi jika Anda bisa menghindarinya. Tidak seperti mesin, manusia membuat kesalahan.

Ulasan kode membantu. Menghabiskan bertahun-tahun memperbaiki kode "pintar" orang lain membantu. Tetap fokus pada apa yang benar-benar dibutuhkan klien saat ini membantu.

Sekolah dan bisnis memiliki kru staf pembersihan dan pemeliharaan. Kode juga membutuhkan pembersihan dan pemeliharaan! Jika memungkinkan, bersihkan kekacauan (terutama milik Anda sendiri)! Saya pikir itu yang terbaik yang bisa dilakukan.

Selain saran bagus yang diberikan sampai sekarang (review kode, debugging, pendekatan TDD) Anda harus (kembali) membaca dari waktu ke waktu (buku terbaik) tentang praktik pengkodean yang baik:

• Programmer pragmatis
• Kode Lengkap
• Kode Bersih

dan lainnya, tergantung pada teknologi yang Anda gunakan.

Hanya ingat YAGNI - Kamu Tidak Akan Membutuhkannya .

programmer tidak boleh menambahkan fungsionalitas sampai dianggap perlu ...

YAGNI adalah prinsip di balik praktik XP "melakukan hal paling sederhana yang mungkin bisa berhasil" (DTSTTCPW). Ini dimaksudkan untuk digunakan dalam kombinasi dengan beberapa praktik lain, seperti refactoring berkelanjutan, pengujian unit otomatis kontinu dan integrasi berkelanjutan. Digunakan tanpa refactoring terus menerus, ini dapat menyebabkan kode berantakan dan pengerjaan ulang besar-besaran ...

Menurut mereka yang menganjurkan pendekatan YAGNI, godaan untuk menulis kode yang tidak perlu saat ini, tetapi mungkin di masa depan, memiliki kelemahan sebagai berikut:

• 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 dapat menghalangi fitur yang diperlukan untuk ditambahkan di masa depan.
• 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 diterapkan juga, ini dapat mengakibatkan efek bola salju ke ...