Ada saat ketika Anda mulai memahami bahwa, dalam arsitektur layanan mikro, lebih menakutkan untuk menunggu seminggu untuk menyebarkan semua layanan mikro sekaligus untuk memastikan bahwa semuanya bekerja bersama, daripada untuk menegakkan versi api secara ketat, menulis banyak otomatis tes (sedikit dari masing-masing: unit dan eksplorasi, integrasi), dan penyebaran otomatis ke produksi segera setelah komit Anda lulus sebagai tes di atas panggung.
Sekarang, sepertinya ide bagus selama Anda ingat untuk menulis tes, menguji Anda perubahan sebelum melakukan, tahu cara menggunakan versi API, dan Anda tidak akan menjatuhkan basis data dalam skrip pembaruan db tambahan yang dijalankan pada penerapan (yang bukan masalah besar karena harus gagal di panggung).
Tetapi apakah itu layak untuk dilakukan dengan programmer junior? Mungkin saya harus menerapkan skema tarik-permintaan. Ini akan membuatnya kurang seperti penyebaran terus menerus (itu dugaan saya)?
Saya harap ini bukan berdasarkan opini dan saya dapat mengandalkan Anda untuk berbagi pengalaman, terima kasih.
Harap dicatat, saya tidak bertanya tentang CI atau tentang pengiriman berkelanjutan. Kami sudah memilikinya. Apa yang kami coba sekarang adalah menjadikannya penyebaran berkelanjutan yang artinya memiliki semuanya pada produksi tepat setelah kode masuk.
it is more scary to wait a week to deploy all micro services at once to make sure that everything works together, than to strictly enforce api versioning, write lots of automatic tests (...), and auto deploy to production as soon as your commit passes as tests on stage- itu berdasarkan pendapat;) IMHO jauh lebih sulit untuk memastikan kesuksesan dengan penyebaran layanan independen daripada dengan pendekatan monolitik: softwareengineering.stackexchange.com/a/342346/187812 . Dan dengan CI sejati (tanpa cabang fitur / integrasi) Anda tidak perlu menunggu selama seminggu.Jawaban:
Kenapa tidak? Salah satu hal yang Anda gambarkan akan menjadi masalah apakah Anda menggunakan penyebaran berkelanjutan atau tidak. Masalahnya, tampaknya, adalah bahwa Anda khawatir junior akan membuat kesalahan besar. Dan kesalahan itu akan segera diproduksi sebelum ada yang bisa menangkapnya.
Itu sebabnya Anda melakukan review kode dan melakukan pengujian. Sebelum apa pun digabungkan ke dalam cabang utama Anda dan dijadwalkan untuk dirilis, perlu kode ditinjau, baik oleh beberapa junior lainnya (sehingga mereka mendapatkan pengalaman) dan oleh pengembang senior (untuk menggunakan keahlian mereka untuk membuat kode lebih baik). Setiap orang harus mencari bug bencana ini. Dan itu harus menghentikan mereka. Jika tidak, Anda mungkin memerlukan QA / pengujian yang lebih baik pada lingkungan pementasan (dan mungkin beberapa pengembang yang lebih baik jika ulasan kode melewatkan hal-hal ini).
sumber
Penerapan berkelanjutan akan bekerja dengan baik jika Anda memiliki serangkaian tes otomatis yang bagus.
Pengembang junior dapat bersemangat tentang tugas mereka sendiri dan tidak melihat bahwa mereka memecahkan masalah. Anda dapat memperbaikinya dengan beberapa otomatisasi. Siapkan server build yang akan menjalankan tes setiap saat, dan dapatkan mereka alat seperti CatLight build notifier . Ini akan memberi mereka umpan balik yang cepat dan jelas ketika mereka memecahkan banyak hal.
Mereka akan memperbaiki masalah kecil saat terjadi dan menjaga pengiriman terus menerus Anda berjalan.
sumber
Satu-satunya cara untuk mempelajari kebiasaan baik adalah mempraktikkannya, jadi ya pengembang junior juga dapat mempraktikkan penerapan berkelanjutan. Anda mungkin ingin mempertimbangkan untuk menambahkan langkah-langkah ke dalam pipa untuk melakukan hal-hal seperti memeriksa cakupan tes dan mungkin menjalankan analisis kode statis, dan gagal membangun jika cakupan pengujian tidak cukup tinggi. Itu akan memastikan bahwa junior devs memahami harapan sebelum sesuatu dianggap lengkap.
sumber
Anda tidak hanya dapat melakukan ini dengan pengembang junior tetapi juga wajib dari Anda. Pertama, Anda akan mengurangi kualitas perangkat lunak Anda, dan yang kedua ini membantu pengembang junior mempelajari keterampilan pengembangan perangkat lunak yang baik.
Sebagai analogi: Apakah Anda ingin dokter Anda tidak mempraktikkan ilmu kedokteran semaksimal mungkin karena ia takut akan kesalahan magang muda? Bagaimana dokter menangani potensi kerusakan?
sumber
Dari pengalaman masa lalu dengan basis kode Big Ball Of Mud yang berevolusi secara alami selama bertahun-tahun di tangan banyak pengembang junior yang tidak diawasi, saya ingin menunjukkan apa yang terjadi ketika Anda tidak berlatih CI dengan pengembang tersebut.
Edit / Perbarui : Sesuai komentar RubberDuck; jawaban ini mengasumsikan bahwa target gabungan Anda untuk integrasi adalah cabang pengembangan daripada cabang evaluasi atau rilis.
1. Pengembang junior cenderung berkomunikasi dengan rekan kerja atau penyelia mereka
Integrasi berkelanjutan bukan hanya masalah penggabungan kode, ini adalah titik waktu di mana pengembang dipaksa untuk berinteraksi dengan pemangku kepentingan lainnya.
Komunikasi itu penting, dan tanpa ingin menggeneralisasi secara berlebihan, itu cenderung merupakan keterampilan yang dipelajari yang datang kurang alami bagi pengembang yang tidak berpengalaman dibandingkan dengan mereka yang terbiasa bekerja di lingkungan tim.
Jika Anda mengizinkan pengembang junior untuk duduk di bilik mereka dan mem-bash kode selama berminggu-minggu tanpa diminta untuk sering melaporkan / ulasan, maka mereka cenderung menghindari komunikasi sama sekali.
2. Kode yang mereka hasilkan kemungkinan membutuhkan peninjauan yang lebih ketat
Pernahkah Anda meninjau sesuatu yang begitu buruk sehingga Anda berharap dapat mengambilnya lebih awal dan mencegahnya agar tidak pernah ditulis? Ini sering terjadi.
Anda tidak dapat mencegah kode buruk ditulis, tetapi Anda dapat membatasi waktu yang terbuang. Jika Anda berkomitmen untuk sering meninjau dan menggabungkan, maka Anda meminimalkan ruang untuk waktu yang terbuang.
Skenario terburuk adalah bahwa Anda dapat meninggalkan pengembang junior sendirian selama beberapa minggu di proyek miniatur mereka sendiri, dan ketika mereka akhirnya siap untuk meninjau kode, tidak ada cukup waktu tersisa bagi mereka untuk membuang seluruh kekacauan pergi dan mulai lagi dari awal.
Banyak proyek menjadi bola lumpur besar hanya karena seluruh kode buruk ditulis ketika tidak ada yang memperhatikan sampai semuanya terlambat.
3. Anda harus kurang yakin bahwa pengembang junior atau anggota tim baru lainnya telah memahami persyaratan
Terkadang pengembang mungkin membangun solusi sempurna untuk masalah yang salah; ini menyedihkan karena biasanya kesalahpahaman sederhana yang akan sangat mudah untuk dihindari jika hanya seseorang yang mengajukan pertanyaan yang tepat sebelumnya dalam proses.
Sekali lagi, ini adalah masalah yang lebih cenderung mempengaruhi pengembang yang tidak berpengalaman yang lebih cenderung menerima persyaratan "buruk" pada nilai nominal daripada mendorong kembali dan mempertanyakan kebijaksanaan persyaratan.
4. Mereka cenderung kurang akrab dengan pola umum, dengan arsitektur kode yang ada, dan dengan alat dan solusi yang terkenal
Kadang-kadang pengembang menghabiskan seluruh waktu untuk menciptakan kembali roda secara tidak perlu hanya karena mereka tidak tahu bahwa ada solusi yang lebih baik. Atau mereka mungkin menghabiskan waktu berhari-hari untuk mencoba mematok pasak persegi ke dalam lubang bundar tanpa menyadari apa yang mereka lakukan salah.
Sekali lagi, hal semacam ini lebih mungkin terjadi pada pengembang yang tidak berpengalaman, dan cara terbaik untuk mengatasi masalah ini adalah dengan memastikan ulasan rutin.
5. Periode yang lama antara komit / penggabungan kode membuat cacat lebih sulit untuk diidentifikasi dan diperbaiki
Ketika bug muncul segera setelah berminggu-minggu perubahan kode telah digabungkan ke cabang master, tantangan untuk mengidentifikasi perubahan yang mungkin menyebabkan bug menjadi lebih sulit.
Jelas strategi bercabang keseluruhan Anda juga ikut berperan di sini; idealnya semua pengembang Anda akan bekerja di cabang mereka sendiri, atau di dalam cabang fitur (atau keduanya), dan tidak akan pernah bekerja langsung dari master / trunk.
Saya telah melihat situasi di mana seluruh tim semuanya bekerja langsung ke master / trunk pada saat yang sama, dan ini adalah lingkungan yang mengerikan bagi CI, tetapi untungnya solusi menarik semua orang menjauh dari master / trunk umumnya memberikan stabilitas yang cukup untuk pekerjaan individu barang / tiket / dll.
Seharusnya selalu "OK" bagi pengembang mana pun untuk mematahkan cabang master / trunk, dengan pemahaman bahwa penggabungan harus terjadi secara teratur, bahwa pemecahan perubahan dan cacat harus diidentifikasi lebih cepat, dan karenanya diselesaikan lebih cepat juga. Cacat terburuk biasanya adalah mereka yang tetap tidak terdeteksi selama berbulan-bulan atau bahkan bertahun-tahun.
Kesimpulan; keuntungan utama dari integrasi berkelanjutan / penerapan berkelanjutan adalah:
Jadi jika Anda tidak berlatih CI dengan pengembang junior Anda, maka Anda menerima banyak risiko yang tidak perlu, karena ini adalah anggota tim Anda yang membutuhkannya lebih dari yang lain.
sumber
Ya, Anda dapat berlatih CI dengan pengembang junior. Sangat bodoh untuk tidak berada dalam iklim pembangunan saat ini. Ini sangat berguna untuk dapat mendorong untuk repo dan kemudian secara otomatis digabung menjadi kode panggung - dan untuk menonton semuanya secara real-time di Travis (atau Bambu, Jaringan Pipa dll ...)!
Bawa orang DevOps Anda dan minta dia menjalani prosesnya bersama mereka, ditambah seorang senior yang bersiaga hanya untuk mengawasi hal-hal dan menautkannya dengan ulasan kode mereka (Anda melakukannya, kan?)
Jika kekhawatiran Anda adalah bahwa kode shite akan melewati, itu bukan pada CI dan bukan pada junior: itu pada Anda .
Jadi bantu mereka menjadi lebih baik dan terbiasa menggunakan kode stage / prod lebih cepat Anda akan berterima kasih pada diri sendiri dalam jangka panjang.
sumber