Kapan Anda Harus Memikirkan Kinerja?

Saat saya sedang membangun aplikasi, saya selalu bertanya apakah ini cara terbaik untuk melakukan atau mengimplementasikan fungsi tertentu. Seringkali, saya akan memposting pertanyaan di stackoverflow atau forum lain yang menginginkan umpan balik hanya untuk menerima komentar tentang bagaimana tidak "meletakkan kereta di depan kuda" mengenai kinerja. Apakah kebanyakan programmer benar-benar tidak memikirkan kinerja sampai aplikasi selesai, atau kinerja benar-benar tidak dapat diterima ?? Maksud saya, saya mengerti bahwa lingkungan pengembangan berbeda dari lingkungan produksi dan bahwa Anda seharusnya tidak sepenuhnya bergantung pada hasil dari laptop dev Anda ... tetapi, ada praktik dan teknik yang menghasilkan kinerja yang lebih baik daripada yang lain.

Apakah praktik yang buruk untuk mempertimbangkan kinerja selama proses pengembangan? Haruskah saya mendorong pertimbangan ini sampai kinerja benar-benar turun ??

Memperbarui

Untuk lebih jelasnya, saya berbicara tentang situasi di mana Anda mempertimbangkan atau hanya akan bekerja pada beberapa fungsi. Anda tahu ada beberapa cara untuk mengimplementasikannya, tetapi Anda tidak yakin seberapa baik setiap implementasi akan berskala. Mungkin juga ada beberapa teknik yang bahkan tidak Anda kenal. Dalam skala kecil, salah satu pendekatan mungkin akan memadai, tetapi pada skala yang lebih besar beberapa akan mengikuti dan beberapa tidak. Seringkali ketika saya meminta pendapat atau panduan jawabannya adalah: khawatir tentang hal itu nanti ...

Penundaan pertimbangan kinerja terkadang didasarkan pada kesalahan penerapan frasa:

Optimalisasi prematur adalah akar dari semua kejahatan.

Jika Anda membaca kutipan lengkap, yang ingin Knuth katakan adalah bahwa optimasi mikro yang diterapkan selama pengembangan tanpa pembuatan profil umumnya tidak disarankan, karena mereka mengarah pada kode yang kurang dapat dikelola tanpa harus mencapai manfaat kinerja yang substansial.

Tetapi itu tidak berarti Anda tidak boleh mempertimbangkan kinerja sampai aplikasi hampir selesai. Jika Anda melakukannya, Anda mungkin menemukan bahwa kinerja tidak memadai, arsitektur desain Anda tidak mendukung kinerja yang lebih baik, dan Anda harus memulai dari awal.

Ada beberapa hal yang dapat Anda lakukan selama pengembangan untuk mencapai kinerja yang baik, tanpa optimasi esoterik (dan prematur):

1. Gunakan arsitektur yang masuk akal dan dipikirkan dengan matang.
2. Gunakan struktur data dengan benar.
3. Gunakan teknologi (perpustakaan, kerangka kerja) yang berkinerja memadai.

Jika Anda melakukan hal-hal ini, Anda akan menemukan bahwa setiap optimasi kinerja yang perlu terjadi akan terbatas pada sebagian kecil dari kode Anda. Profiling akan mengidentifikasi kode itu, dan memungkinkan Anda untuk memfokuskan peningkatan kinerja Anda di mana mereka akan melakukan yang paling baik, tanpa mengorbankan pemeliharaan.

Inilah yang TIDAK HARUS dipikirkan:

• Apakah ++ilebih cepat dari itu i++?
• Apakah switchlebih cepat dari itu if?
• Haruskah inlinesaya fungsi saya?
• Apakah fungsi virtual lambat?
• Apakah C ++ / Java / C # lebih cepat / lebih lambat dari yang lain?
• bla, bla, ...

Inilah yang harus dipikirkan:

• Apa yang diharapkan dari beban kerja yang realistis?
• Seberapa sering informasi input berubah, dan siapa yang menyediakannya? Apakah masuk akal untuk mempertimbangkan kompilasi?
• Sudahkah saya menjaga struktur data saya sesederhana dan senyormal mungkin? Itu berarti tidak khawatir tentang hashing dan hal-hal seperti itu.
• Sudahkah saya menyimpan notifikasi seminimal mungkin? (Di situlah perubahan dalam satu bagian data memerlukan perubahan waktu yang sama di bagian lain, karena struktur data tidak dinormalisasi.)

Mengenai poin terakhir, dalam pengalaman saya yang terbaik adalah merancang struktur data sehingga, jika harus dinormalisasi, bahwa itu dapat mentolerir ketidakkonsistenan sementara, yang nantinya dapat diselesaikan dengan semacam sapuan berkala. Pembunuh utama kinerja adalah ketika notifikasi memicu notifikasi lebih lanjut, yang memicu lebih jauh, sampai pada tingkat yang tidak pernah Anda tebak sebelumnya. Dan seringkali itu adalah usaha yang sia-sia karena perubahan yang membatalkan sendiri.

Jika Anda telah melakukan semua ini, Anda memiliki desain yang bersih. Kemudian secara berkala saat Anda mengembangkannya, profil. ( Penghentian acak adalah metode yang saya andalkan.) Kemudian jika Anda dapat melihat bahwa kinerja akan ditingkatkan dengan menghadirkan algoritma yang lebih canggih, tentu saja lakukanlah.

Tidak, Anda harus memikirkan kinerja (terutama dalam mendesain basis data) sejak awal. Ada banyak kerusakan pada industri kami oleh orang-orang yang berpikir optimasi apa pun adalah optimasi prematur. Kutipan itu awalnya dimaksudkan untuk mencegah orang melihat optimasi mikro sebelum masalah terjadi. Itu tidak dimaksudkan untuk tidak melakukan optimasi sama sekali. Dalam database misalnya, ada banyak teknik yang diketahui berkinerja buruk. Menghindari hal-hal itu, dalam desain, adalah bagian dari apa yang perlu Anda lakukan. Sangat sulit untuk membuat ulang basis data dengan 100.000.000 catatan karena dirancang menggunakan teknik perforiming yang buruk dan kita tidak bisa lagi menghindari masalah dengan membeli perangkat keras yang lebih baik.

Khawatir tentang kebenaran ¹ pertama, lalu rawat, lalu keselamatan dan keandalan, lalu Anda bisa memikirkan kinerja. Terapkan pesanan ini ke setiap bagian kode saat Anda mengembangkannya. Ada kemungkinan bahwa solusi pemain mungkin secara alami jatuh hanya dari menjaga hal-hal yang jelas dan langsung.

80% kinerja memilih algoritma dan struktur data yang tepat untuk masalah yang dihadapi; quicksort yang dioptimalkan dengan buruk masih akan mengalahkan beat jenis bubble yang sangat dioptimalkan dalam kasus rata-rata (kasus terburuk itu seri).

Apa yang semua orang di SO coba hantam adalah pola pikir "yang lebih cepat, ++ p atau p ++", di mana orang-orang terjebak dalam mengakali kompiler sehingga mereka kehilangan jejak masalah yang lebih besar, menghasilkan kode yang rapuh, bug -diri, salah , dan yang terbaik, tidak lebih cepat dari solusi yang lebih mudah. Saya sudah berurusan dengan kode semacam itu secara langsung; salah satu contohnya sangat rapuh sehingga kami tidak bisa melakukan perubahan apa pun tanpa merusaknya sepenuhnya.

¹ Di mana "kebenaran" berarti "memenuhi spesifikasi", yang tidak identik dengan "bebas bug".

Anda harus mulai memikirkan kinerja begitu Anda tahu apa itu kinerja "baik". Dengan kata lain, akan salah untuk mulai berpikir tentang kinerja sebelum Anda mengidentifikasi apa ambang batas berikut:

• Performa yang tidak dapat diterima - perbaiki sekarang sebelum semakin jauh dari tangan
• Kinerja yang dapat diterima - saatnya untuk fokus pada fitur lain sebelum Anda mencoba melakukan lebih banyak lagi dengan kinerja.
• Kinerja target - angka kinerja yang diidealkan. Yaitu jika Anda memiliki waktu dan sumber daya yang memadai, apa yang akan Anda butuhkan sistem Anda?

Setelah Anda mengidentifikasi apa ambang itu, Anda juga mengidentifikasi metrik yang Anda gunakan untuk mengukur kinerja. Itu berarti Anda dapat mengatur beberapa tes kinerja otomatis yang dapat Anda jalankan beberapa kali sehari. Itu akan memberi tahu Anda jika Anda menjadi lebih baik atau lebih buruk.

Untuk menghasilkan metrik tersebut, Anda perlu memahami apa yang perlu dilakukan sistem Anda. Misalnya, apakah metrik kinerja absolut diperlukan (respons dalam waktu X) atau apakah pengukuran throughput diperlukan (respons X per waktu Y)? Optimalisasi throughput dan waktu absolut memerlukan pendekatan yang berbeda, dan jika Anda tidak tahu apa yang benar-benar penting, Anda mungkin mengoptimalkan cara yang salah.

Anda mungkin pernah mendengar bahwa optimasi prematur adalah akar dari semua kejahatan. Pertanyaannya adalah apa yang membuatnya prematur? Menurut pendapat saya, tidak pernah merupakan ide buruk untuk memikirkan kinerja, tetapi jangan khawatir berlebihan sampai kode Anda berfungsi. Setelah berhasil, lakukan beberapa pengujian beban berat, profil dan identifikasi kemacetan, dan lakukan optimisasi kinerja Anda.

Yang sedang berkata, tidak ada yang salah dengan berpikir tentang kinerja selama tahap pengkodean awal jika Anda tahu teknik tertentu yang akan membuat perbedaan nyata. Misalnya, memilih satu struktur penyimpanan dari pustaka atas yang lain karena pengalaman masa lalu telah mengajarkan Anda bahwa salah satu dari mereka lebih cepat / menggunakan lebih sedikit RAM daripada yang lain. Atau membangun di sederhana (Anda dapat membuatnya lebih canggih jika pengujian kemudian menuntut hal itu) sistem caching untuk data yang Anda tahuakan banyak diakses dan akan jauh lebih baik di-cache. Dengan cara ini, Anda tidak terlalu khawatir tentang kinerja (setidaknya tidak pada awalnya) tetapi Anda menggunakan tips dan trik yang telah Anda pelajari sepanjang jalan dari proyek lain. Usahakan agar ini tetap sederhana sehingga mudah dimasukkan selama pengembangan awal, dan mungkin menawarkan beberapa manfaat juga.

Kinerja harus dirinci dalam spesifikasi terkait sistem dan pengguna dari Dokumen Persyaratan Anda. Saya tahu banyak orang mencemooh ide untuk melakukan Analisis Kebutuhan dalam pengembangan aplikasi, tetapi dokumen seperti itu akan secara ringkas menjawab apa dan di mana Anda harus mencurahkan sumber daya terkait kinerja Anda ketika aplikasi hampir selesai. Dan itu akan menjawab pertanyaan itu tepat waktu

Dokumentasi Persyaratan akan menghemat ratusan jam waktu yang seharusnya terbuang sia-sia untuk proses yang tidak esensial.

Pendekatan yang seimbang akan lebih baik. Kinerja itu penting tetapi tidak sepenting menyelesaikan sesuatu, jadi:

1. pertama-tama buat fitur yang mencoba sedikit berpikir tentang apa yang Anda lakukan dan bagaimana melakukannya (gunakan sedikit waktu untuk memikirkan kinerja tetapi tidak banyak)
2. Menguji
3. sekali berjalan mulai berpikir tentang apakah ada kebutuhan nyata untuk membuatnya lebih baik (umumnya Anda tidak akan, tetapi dalam beberapa kasus Anda mungkin).

Ini adalah pendekatan umum saya untuk performace vs fungsionalitas, dan dalam kasus umum semuanya tergantung pada apa yang dilakukan oleh program dan memverifikasi apakah ada kebutuhan untuk membuat segala sesuatunya bekerja lebih baik dan berapa banyak waktu yang diperlukan untuk saya.

Mari kita berpikir tentang situs web T&J seperti ini, saya pikir orang-orang di belakangnya pasti banyak berpikir tentang bagaimana cara mengajukan pertanyaan dan mendapatkan jawaban sebanyak mungkin dengan biaya sesedikit mungkin. Tetapi, ketika memikirkan notifikasi, sebenarnya tidak terlalu menjadi masalah jika notifikasi muncul sesekali dan memberi tahu Anda ada jawaban atau sesuatu yang baru.

Ada satu cara penangguhan aman berpikir tentang kinerja: sedapat mungkin menggunakan bahasa domain khusus.

Jika sebagian besar pengembangan Anda dapat dilakukan dengan DSL kecil Anda sendiri, dan mereka dirancang cukup baik untuk mengekspresikan domain masalah Anda dalam bentuk paling umum dan tingkat tinggi, adalah mungkin untuk mendapatkan prototipe yang berfungsi terlebih dahulu, tanpa pernah memikirkan kinerja, dan kemudian hanya meningkatkan implementasi DSL Anda, bukan kode domain masalah yang sebenarnya.

Ini adalah pendekatan yang jauh lebih baik dari segi pemeliharaan veiw juga.

Anda harus memperhitungkan kinerja. Namun, Anda harus menggambar garis untuk menandai akhir penyetelan, karena (biasanya) waktu Anda lebih penting daripada komputer.

Artikel teks yang sangat bagus tentang kinerja adalah: The Computer Performance Shell Game .

Permainan shell kinerja komputer, juga dikenal sebagai "menemukan hambatan", selalu dimainkan di antara empat sumber daya berikut:

• CPU
• Disk
• Jaringan
• Penyimpanan

Pada saat tertentu, komputer Anda sedang menunggu beberapa operasi untuk menyelesaikan salah satu sumber daya ini. Tapi yang mana: CPU, memori, disk, atau jaringan? Jika Anda tertarik dengan kinerja, hal pertama yang harus Anda lakukan adalah menentukan kemacetan mana yang saat ini menghambat kinerja - dan menghilangkannya.

Cara "terbaik" adalah istilah yang sangat dimuat, dan jawabannya mungkin sangat tergantung pada faktor-faktor yang tidak diketahui sampai runtime.

• Apakah Anda memiliki banyak memori? - Anda akan mendapatkan kinerja yang lebih baik dengan struktur data "all-in-memory", tetapi jika Anda tidak memiliki cukup pertukaran memori akan mematikan kinerja Anda.
• Apakah Anda membutuhkan ketekunan? Database memberikan integritas tetapi lebih lambat dari struktur data "all-in-memory" di atas. JAUH lebih lambat.
• Bisakah Anda menyimpan hasil? Pernis dapat membantu dengan itu! http://www.varnish-cache.org/

Daftar ini terus berlanjut.

Apa yang Anda dapat lakukan, adalah menulis "hal paling sederhana yang mungkin kerja" dari pengetahuan Anda saat ini tidak memiliki, dan melakukannya dengan modular mode sehingga Anda dapat dengan mudah mengatur ulang ketika Anda tahu lebih banyak. Perhatikan bahwa hal "paling sederhana" belum tentu sederhana!

Itu selalu sesuatu yang harus Anda ingat. Saya pikir apa yang kebanyakan orang coba katakan adalah bahwa tidak ada gunanya menghabiskan dua hari mencoba untuk mengoptimalkan sesuatu yang Anda bahkan tidak tahu itu rusak. Setelah Anda menjalankan produk, dan dapat melakukan beberapa pengujian kegunaan, itu akan menunjukkan di mana Anda mengalami masalah kinerja. Kemudian, setelah Anda dapat mengidentifikasi masalah kinerja yang sebenarnya, Anda dapat menargetkan pengoptimalan yang perlu Anda lakukan.

Paling tidak secara teori, Anda harus mulai berpikir tentang kinerja begitu Anda dalam pengujian beta dan bukan sebelumnya.

Namun ini bukan lisensi untuk membuat keputusan desain yang buruk. Misalnya, menggunakan string NVARCHAR sebagai kunci utama adalah jalur pasti untuk kinerja yang buruk; yang mengatakan, itu adalah kebiasaan kotor terlepas dari masalah kinerja dan Anda tidak boleh menggunakannya di tempat pertama.

Jika desain Anda mengikuti praktik terbaik konvensional (semuanya dalam bentuk normal ke-3, menyembunyikan informasi yang tepat di kelas Anda, penggunaan singleton yang minimal, dll), dan ada masalah kinerja di kemudian hari, itu akan mudah ditangani (buat indeks di sini, mengimplementasikan cache di sana).

HTH

Tergantung. Penting untuk mengingat aturan 80/20: sebagian besar (katakanlah 80%) dari kode dalam aplikasi tidak akan pernah cukup sering dieksekusi untuk membuat perbedaan kinerja yang nyata. Anda harus fokus pada 20% sisanya di mana aplikasi terikat untuk menghabiskan sekitar 80% dari waktu pelaksanaannya.

Anda mungkin dapat mengidentifikasi beberapa hot spot kinerja yang jelas sebelumnya, seperti jika Anda tahu bahwa perhitungan tertentu akan diulang jutaan kali lipat. Dalam kasus seperti itu, sangat penting untuk mengoptimalkannya di muka dengan memilih struktur data dan algoritma yang tepat untuk pekerjaan itu.

Namun, optimasi itu lebih merupakan kegiatan desain. Apa yang biasanya tidak berharga adalah optimasi mikro, di mana seseorang menghabiskan banyak waktu dengan trik-trik cerdik yang cerdik atas nama "mendapatkan kinerja". Terutama jika dilakukan tanpa pengukuran yang tepat sebelum dan sesudah, perubahan tersebut mungkin tidak membuat perbedaan, atau sebenarnya memperlambat aplikasi dalam keadaan kehidupan nyata.

Itu tergantung pada tahap perkembangan Anda

1) Jika Anda sedang membangun fungsionalitas perangkat lunak Anda, teruskan berfungsi dan pastikan itu berfungsi dengan baik (mis. Diinginkan dan efisien).

2) Setelah blok bangunan terintegrasi, Anda akan mendapatkan petunjuk tentang sumber daya hogger, di sana Anda memiliki ruang untuk optimasi.

Jika Anda harus mulai berpikir tentang kinerja, Anda dalam masalah. Anda harus selalu memikirkan kinerja. Bahkan, saya curiga programmer yang baik akan berpikir tentang kinerja bahkan ketika mereka tidak berniat, dalam mode «pria berpikir tentang seks setiap tujuh detik».

Yang penting adalah tindakan apa yang akan Anda ambil berdasarkan semua pemikiran itu. Pikiran itu murah, tetapi tindakan dapat melanggar kode dan menghancurkan tenggat waktu.

Sebagian besar waktu, satu-satunya tindakan yang masuk akal adalah tidak melakukan apa-apa: Anda mengidentifikasi bahwa kode Anda tidak akan cukup sering dipanggil agar masalah kinerja dapat diamati — mungkin itu adalah kode startup yang dijalankan sekali per komputer untuk 1% dari basis pengguna potensial Anda, mungkin itu sedikit kode server berlebihan yang tenggelam dalam lautan akses database lambat, mungkin itu hanya tugas bilangan bulat di bagian kode yang tidak kritis.

Cukup sering, Anda mencurigai bahwa operasi yang diberikan dapat menyebabkan masalah kinerja yang dapat diselesaikan dengan perubahan sederhana. Misalnya, perasaan mengomel bahwa menjalankan kueri SQL kompleks pada setiap permintaan, atau meminta sepotong data yang sama dari kamus dua kali, akan berdampak buruk bagi Anda. Di sinilah pengetahuan teknik optimasi berguna, dan mungkin kesimpulan paling mengejutkan terjadi:

Jika Anda mengetahui teknik cepat yang hampir pasti akan meningkatkan kinerja sepotong kode, jangan lakukan itu.

Jika Anda bisa memikirkannya sekarang, Anda pasti bisa melakukannya dalam lima menit kemudian. Tidak memasukkan kode (tapi, mungkin, dalam // TODOkomentar) meninggalkan kode pembersih dan menghemat waktu Anda sebelumnya untuk bekerja pada fitur lain, sementara tidak membuang waktu jika Anda akhirnya membuang kode itu nanti. Jika kode asli ternyata menyebabkan masalah kinerja saat diuji, kembali dan terapkan teknik cepat Anda.

Saya tidak mengatakan di sini bahwa Anda harus menghindari penulisan kode yang idiomatis hanya karena kebetulan lebih cepat. Tulis kode idiomatik sesuai dengan praktik terbaik yang meningkatkan produktivitas dan keterbacaan serta mengurangi bug. Hanya saja jika Anda memiliki pilihan antara kode by-the-book idiomatik dan alternatif yang lebih cepat tetapi mudah ditulis, selalu gunakan keterbacaan alih-alih kecepatan.

Satu-satunya situasi yang sulit adalah ketika tampaknya tidak ada cara mudah untuk meningkatkan kinerja kode, namun sangat jelas bahwa sepotong kode akan rusak segera setelah dikirimkan — sebuah basis data lengkap untuk setiap klik, ratusan permintaan SQL per halaman di situs, atau apa pun yang sama mengerikannya. Di sinilah Anda benar-benar harus berhenti dan berpikir lagi. Ini biasanya masalah arsitektur yang tidak dapat diselesaikan pada skala lokal. Konfirmasikan kecurigaan Anda dengan lonjakan cepat atau prototipe, cari pengalaman serupa dan solusi umum, dan pertimbangkan perubahan arsitektur atau setetes fitur.

IMHO, penting untuk memikirkan kinerja sebelum Anda menerapkan sistem, tetapi hanya pikirkan. Anda harus menganalisis aplikasi dan mencari tahu apa yang mungkin menjadi hambatan kinerja potensial.

Kemudian implementasikan sistem sesederhana mungkin. Jika masalah kinerja muncul, maka optimalkan.

Misalnya, Anda memiliki klien GUI yang mendapatkan data melalui beberapa jenis layanan (SOAP, REST HTTP, dll). Maka hal yang paling penting untuk kinerja tinggi / skalabilitas adalah memiliki panggilan sesedikit mungkin, masing-masing panggilan mengembalikan banyak data, daripada banyak panggilan mengembalikan sedikit informasi masing-masing, yaitu lebih suka komunikasi chunky daripada mengobrol.

Saat menerapkan sistem semacam ini, saya tidak akan terlalu peduli tentang jumlah panggilan antar sistem. Tetapi saya akan memastikan bahwa basis kode akan memudahkan saya untuk memperbaiki / mengoptimalkan ketika kebutuhan muncul.

Anda harus memikirkan kinerja dengan cara yang sangat umum sejak awal. Anda harus memilih struktur data dan algoritma yang akan bekerja dengan baik untuk aplikasi Anda dan cukup efisien. Algoritma sangat penting untuk perangkat lunak, dan struktur data lebih dari itu. Anda mungkin harus melakukan penulisan ulang besar jika Anda perlu melakukan perubahan besar pada keduanya, sementara detail yang lebih kecil dapat ditulis ulang dengan lebih mudah.

Anda mungkin juga ingin mendapatkan kebiasaan yang efisien, tetapi ini tergantung pada bahasa. Dalam C ++, misalnya, "++ i;" sebagai pernyataan atau ungkapan yang berdiri sendiri selalu setidaknya sebagus "i ++;", dan berpotensi menjadi lebih efisien. Namun, dalam kebanyakan kasus, Anda harus menulis kode yang jelas dan mempercayai kompiler. Membiasakan diri mengkhawatirkan efisiensi mikro hampir pasti akan menyebabkan Anda lebih banyak masalah daripada yang dipecahkan. Untuk aplikasi desktop, baik kompiler setidaknya sama cerdasnya dengan Anda tentang hal-hal seperti i >> 1vs. i / 2, atau cara terbaik untuk meningkatkan kinerja adalah dengan mendapatkan kompiler yang lebih baik, jadi jangan khawatir tentang itu.

Selain itu, jangan terlalu khawatir sampai Anda mendapatkan sesuatu yang dapat Anda uji. Pada saat itu, Anda dapat membuat profil program untuk melihat di mana hot spot berada, dan mungkin mendapatkan ide apakah Anda memiliki program kinerja atau tidak. Jika Anda perlu meningkatkan kinerja, temukan di mana program menghabiskan sebagian besar waktunya, dan tingkatkan hal-hal di sana. Jika Anda telah merancang efisiensi global yang memadai, dan menulis program dengan baik, Anda hanya mengubah sebagian kecil dari program.

Saya pikir yang terbaik yang dapat Anda lakukan adalah mengikuti praktik desain yang baik (misalnya, jangan melakukan hal-hal yang Anda tahu akan menghambat kinerja) sampai Anda mendapatkan sesuatu yang berhasil. Jika Anda tidak dapat mengukur peningkatan, Anda tidak dapat melakukan peningkatan. Setelah Anda memiliki sesuatu yang dapat Anda uji, maka sering kali merupakan ide yang baik untuk menjalankan profiling dan mendapatkan ide di mana hot spot (jika ada) berada. Jika ada sesuatu yang melompat pada Anda, Anda harus mempertimbangkan refactoring atau menulis ulang area masalah, tetapi jika itu tidak terlalu buruk (hanya karena kode menghabiskan 90% dari waktunya dalam dua atau tiga metode tidak berarti apa-apa jika berkinerja cukup baik secara keseluruhan) maka teruslah berkembang. Sesuatu yang saya lihat lebih dari sekali adalah pengembang yang menghabiskan waktu berhari-hari mengoptimalkan bagian paling kompleks dari sistem,

Kapan saya harus mulai memikirkannya? Berapa banyak usaha yang harus saya lakukan? Itu tergantung pada Skala Cockburn proyek. (Dengan kata lain, apa risiko tidak memiliki kinerja yang baik?)

Pelajari dasar-dasarnya jauh sebelumnya (lihat jawaban Robert Harvey ). Untuk menerapkan pemikiran yang berorientasi pada kinerja selama berbagai tahap pengembangan perangkat lunak, pengembang harus mengetahuinya dari dalam, sehingga proses berpikir tidak akan terhalang oleh pertimbangan tambahan tersebut. (Dengan kata lain, mulailah berpikir tentang kinerja sebelum proyek disusun.)

Selama tahap awal pengembangan, gunakan alat bantu profil kinerja secara bebas dan catat riwayat statistik. Berikan perhatian khusus pada pengorganisasian informasi tersebut untuk membuatnya berguna untuk pengambilan keputusan di kemudian hari.

Kemudian, tergantung pada sifat proyek Anda dan Skala Cockburn-nya:

• Rapid Prototyping, atau "mengeluarkan kode seperti tidak ada hari esok", atau pengembangan internal dengan dampak bisnis yang rendah: simpan saja statistiknya. Jangan berpikir tentang kinerja. Terapkan fungsi dengan cara termudah. Tetap dengan algoritma pertama yang muncul di pikiran Anda.

  • Di paruh akhir proyek, akan ada pengujian kinerja ad-hoc untuk mengidentifikasi "hotspot" berdasarkan kasus penggunaan aktual. Jika ada masalah kinerja yang membuat perangkat lunak tidak dapat digunakan, itu harus mudah diidentifikasi.
  • Untuk pengembangan in-house dengan dampak bisnis yang rendah, cukup gunakan kode dan perbaiki masalah kinerja nanti.

• Aplikasi desktop, yang memerlukan pendekatan kinerja yang konsisten dan menyeluruh. Tidak harus sangat dioptimalkan; namun, harus ada "sedikit" hang (non-responsif) sebanyak mungkin.

  • Aplikasi desktop biasanya memiliki jalur eksekusi yang sangat berbelit-belit yang merumitkan pemikiran berorientasi kinerja. Desain berlapis akan memungkinkan pemisahan masalah kinerja Database / Jaringan dari masalah kinerja GUI, untuk ditangani oleh para ahli yang berbeda di tim Anda.
  • Riwayat jejak log akan memungkinkan hotspot diidentifikasi.

• Komputasi berkinerja tinggi, yang mengharuskan mendapatkan kinerja maksimal dari perangkat keras.

  • Tunjuk seseorang di tim Anda untuk bertugas menganalisis dan melaporkan statistik kinerja.
  • Buat teori tentang karakteristik kinerja, verifikasi dengan eksperimen, dan bandingkan dengan prediksi Anda dari model Comp Sci yang disederhanakan.
  *

Pada awalnya. Identifikasi karakteristik kinerja yang diperlukan. Jika Anda tidak dapat mengidentifikasi target, Anda harus melangkah mundur untuk lebih memahami persyaratan atau menunda sampai Anda mengetahui persyaratan komponen dengan risiko yang mungkin Anda tulis ulang. Lalu, tes. Jangan mengoptimalkan, tes. Jika kode Anda gagal dalam tes kinerja, optimalkan. Dengan adanya kerangka kerja pengujian, penggunaan alat pemantauan kinerja yang ada harus membuat tugas ini cukup mudah.

Pertahankan tes kinerja di tempat selama masa proyek sebagai tes regresi. Kode pemeliharaan terkenal karena memicu masalah kinerja karena 'perbaikan' sering memiliki fokus yang sangat sempit.

Saya selalu mengandalkan formula sederhana:

1. Buat itu bekerja
2. Perbaiki itu
3. Buat itu cepat

... dalam urutan itu.

Menurut c2 , formulasi ini dikaitkan dengan Kent Beck .