Bisakah Anda melakukan penyebaran berkelanjutan dengan programmer junior?


11

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.
Dan Cornilescu

Sistem CI yang baik harus membantu - semua orang membuat kesalahan, bukan hanya juniornya. Dan kerusakan tidak berarti pengembang membuat kesalahan atau tidak melakukan pekerjaan mereka dengan benar, lihat Bagaimana perubahan pra-verifikasi yang berhasil dapat menyebabkan regresi yang seharusnya ditangkap?
Dan Cornilescu

Jawaban:


16

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).


1
Saya khawatir bahwa menggunakan cabang fitur dan menarik permintaan membuatnya kurang penyebaran berkelanjutan. Salah satu aspek yang ingin saya pecahkan adalah kompatibilitas antar komponen. Saya yakin mereka bekerja bersama setelah saya membuat satu perubahan di salah satu layanan. Saya merasa stres ketika kita harus menyatukan semua setelah banyak perubahan. Jika saya meninjau perubahan sebelum mereka bergabung dengan cabang utama maka saya bahkan mungkin bingung urutan perubahan karena komponen dalam repo berbeda.
doker

@doker Jika Anda khawatir harus menyatukan banyak layanan, maka jangan lakukan. Pastikan setiap layanan (dan perubahan yang dilakukan untuknya) berdiri sendiri. Jika layanan A diubah, lakukan tinjauan kode cepat untuk memastikan itu akan bekerja dengan perubahan baru dan dapat digunakan sendiri. Jika melanggar perubahan dibuat, gunakan tinjauan kode sebagai tempat untuk menegakkan versi API. Jika layanan B tergantung pada layanan A, lakukan pekerjaan pada A terlebih dahulu lalu keluarkan. Kemudian kerjakan B. Jika junior memberi Anda perubahan ke A, B, C dan D dan mereka semua saling bergantung, mereka perlu mendokumentasikannya sehingga Anda dapat meninjau.
Becuzz

1
@doker Skenario semacam ini adalah alasan mengapa orang yang sering menggunakan / mengirim secara terus-menerus sangat pro-fitur-switch. Jika perubahan Anda biasanya di belakang sakelar fitur (tidak harus setiap perubahan kecil), maka Anda dapat menggunakan potongan kapan pun dengan fitur mati, nyalakan ketika semua bagian ada, dan matikan jika Anda menemukan masalah yang signifikan.
Derek Elkins meninggalkan SE

3

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.

Ikon status bangunan CatLight

Mereka akan memperbaiki masalah kecil saat terjadi dan menjaga pengiriman terus menerus Anda berjalan.


3

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.


1

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?


1

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.

  • Jelas perlu ada lebih banyak kontrol atas kode untuk rilis dan penyebaran langsung; jika tidak ada cabang produksi yang terpisah maka akan lebih baik mempertimbangkan perubahan pada strategi percabangan / penggabungan untuk menjalankan cabang pengembangan master (yang digunakan untuk pengujian integrasi dan tidak pernah untuk rilis) di samping cabang rilis master. Ini menjaga semua manfaat CI dan penggabungan yang sering tanpa risiko melanggar kode produksi.

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:

  • Komunikasi di antara tim Anda meningkat
  • Kualitas kode umumnya dipertahankan pada standar yang lebih tinggi
  • Persyaratan cenderung dilewatkan atau disalahartikan
  • Masalah arsitektur dan desain harus dideteksi lebih cepat,
  • Cacat lebih mungkin terdeteksi dan diperbaiki pada tahap sebelumnya

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.


OP berbicara tentang model di mana komit untuk menguasai memicu penyebaran aktual ke dalam produksi . Jadi tidak. Tidaklah masalah untuk mematahkan cabang utama dalam model itu.
RubberDuck

@RubberDuck poin bagus, menambahkan komentar untuk memperjelas bahwa pendekatan ini adalah untuk pengujian integrasi dan bukan untuk mendorong perubahan kode baru secara langsung ke cabang produksi.
Ben Cottrell

0

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.


1
OP berbicara tentang Penyebaran Kontinyu bukan Integrasi / Pengiriman
RubberDuck
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.