Berapa banyak pengembang sebelum integrasi berkelanjutan menjadi efektif bagi kami?

Ada overhead yang terkait dengan integrasi berkelanjutan, misalnya, pengaturan, pelatihan ulang, kegiatan penyadaran, penghentian untuk memperbaiki "bug" yang ternyata merupakan masalah data, pemisahan gaya gaya pemrograman yang dipaksakan, dll.

Pada titik apa integrasi berkesinambungan membayar untuk dirinya sendiri?

EDIT: Ini adalah temuan saya

Set-up adalah CruiseControl.Net dengan Nant, membaca dari VSS atau TFS.

Berikut adalah beberapa alasan untuk kegagalan, yang tidak ada hubungannya dengan pengaturan:

Biaya investigasi : Waktu yang dihabiskan untuk menyelidiki apakah lampu merah disebabkan oleh inkonsistensi logis asli dalam kode, kualitas data, atau sumber lain seperti masalah infrastruktur (misalnya, masalah jaringan, pembacaan batas waktu dari kontrol sumber, server pihak ketiga sedang down, dll, dll.)

Biaya politik atas infrastruktur : Saya mempertimbangkan melakukan pemeriksaan "infrastruktur" untuk setiap metode dalam uji coba. Saya tidak punya solusi untuk batas waktu kecuali untuk mengganti membangun server. Pita merah menghalangi dan tidak ada penggantian server.

Biaya perbaikan unit tes : Lampu merah karena masalah kualitas data bisa menjadi indikator dari tes unit yang ditulis dengan buruk. Jadi, tes unit dependen data ditulis ulang untuk mengurangi kemungkinan lampu merah karena data yang buruk. Dalam banyak kasus, data yang diperlukan dimasukkan ke dalam lingkungan pengujian untuk dapat menjalankan tes unitnya secara akurat. Masuk akal untuk mengatakan bahwa dengan membuat data lebih kuat maka tes menjadi lebih kuat jika tergantung pada data ini. Tentu saja, ini berhasil!

Biaya pertanggungan, yaitu, menulis tes unit untuk kode yang sudah ada : Ada masalah cakupan tes unit. Ada ribuan metode yang tidak memiliki tes unit. Jadi, dibutuhkan jumlah hari kerja yang cukup besar untuk menciptakannya. Karena ini akan terlalu sulit untuk menyediakan kasus bisnis, diputuskan bahwa unit test akan digunakan untuk metode publik baru yang akan datang. Mereka yang tidak memiliki unit test disebut 'berpotensi infra merah'. Titik intesting di sini adalah bahwa metode statis adalah titik diperdebatkan dalam bagaimana mungkin untuk secara unik menentukan bagaimana metode statis tertentu gagal.

Biaya rilis yang dipesan lebih dahulu : Skrip Nant hanya sejauh ini. Mereka tidak berguna untuk, katakanlah, CMS dependen build untuk EPiServer, CMS, atau penyebaran database berorientasi UI.

Ini adalah jenis masalah yang terjadi pada server build untuk menjalankan pengujian per jam dan build QA semalam. Saya terhibur bahwa ini tidak perlu sebagai master bangunan dapat melakukan tugas-tugas ini secara manual pada saat rilis, khususnya, dengan band satu orang dan sebuah bangunan kecil. Jadi, langkah tunggal membangun belum membenarkan penggunaan CI dalam pengalaman saya. Bagaimana dengan multistep build yang lebih kompleks? Ini bisa menjadi rasa sakit untuk dibangun, terutama tanpa naskah Nant. Jadi, bahkan setelah membuat satu, ini tidak lebih berhasil. Biaya memperbaiki masalah lampu merah melebihi manfaatnya. Akhirnya, pengembang kehilangan minat dan mempertanyakan validitas lampu merah.

Setelah mencobanya dengan adil, saya percaya bahwa CI itu mahal dan ada banyak pekerjaan yang harus dilakukan alih-alih menyelesaikan pekerjaan. Ini lebih hemat biaya untuk mempekerjakan pengembang berpengalaman yang tidak membuat kekacauan proyek besar daripada memperkenalkan dan memelihara sistem alarm.

Ini adalah kasusnya bahkan jika para pengembang pergi. Tidak masalah jika pengembang yang baik pergi karena proses yang dia ikuti akan memastikan bahwa dia menulis spesifikasi kebutuhan, spesifikasi desain, menempel pada pedoman pengkodean, dan mengomentari kodenya sehingga dapat dibaca. Semua ini ditinjau. Jika ini tidak terjadi maka pemimpin timnya tidak melakukan pekerjaannya, yang harus diambil oleh manajernya dan seterusnya.

Agar CI bekerja, tidak cukup hanya menulis unit test, berupaya mempertahankan cakupan penuh, dan memastikan infrastruktur yang berfungsi untuk sistem yang cukup besar.

Intinya: Orang mungkin mempertanyakan apakah memperbaiki bug sebelum rilis bahkan diinginkan dari perspektif bisnis. CI melibatkan banyak pekerjaan untuk menangkap beberapa bug yang dapat diidentifikasi pelanggan dalam UAT atau perusahaan dapat dibayar untuk memperbaiki sebagai bagian dari perjanjian layanan klien ketika masa garansi berakhir.

Menyiapkan mesin CI mirip dengan memasang alarm kebakaran di rumah.

Menurut saya manfaatnya tidak berkorelasi dengan banyak pengembang, tetapi dengan basis kode yang besar. Mesin CI secara aktif melakukan semua pekerjaan membosankan yang tidak ingin Anda lakukan sendiri, dan melakukannya setiap saat.

Jika Anda merusak modul jarak jauh yang sudah lama tidak Anda sentuh, Anda akan diberi tahu dengan segera. Tidak hanya kompilasi yang bijak, tetapi juga berfungsi jika Anda telah mengatur tes unit.

Juga perhatikan bahwa jika Anda membiarkan mesin CI Anda melakukan semua pekerjaan yang membosankan, termasuk mengatur installer dll, Anda tidak harus melakukannya secara manual. Anda cukup memeriksa sumber Anda, dan menunggu produk jadi dibangun di lokasi standar. (EDIT: Engine CI juga bekerja di lingkungan yang terdefinisi dengan baik, menghindari pengaturan spesifik pengembang, memastikan reproduktifitas)

Ini juga merupakan bagian dari jaminan kualitas.

EDIT: Setelah menulis di atas, saya memiliki pengalaman dengan alat pembuatan Maven untuk Java. Pada dasarnya ini memungkinkan kita untuk menyimpan konfigurasi CI lengkap di dalam proyek (dengan pom.xml) membuatnya lebih mudah untuk mempertahankan instalasi CI dan / atau bermigrasi ke mesin CI lain.

Ini bukan berapa banyak pengembang, tetapi berapa banyak langkah yang diperlukan untuk mendapatkan dari 1 ke n (inklusif), di mana 1 & n ...

1: Memeriksa kode
Dan
n: memiliki paket installable \ deployable

Jika n <2 Anda mungkin tidak perlu CI
sebaliknya, Anda perlu CI

Pembaruan
Dari membaca temuan Anda, saya hanya dapat menyimpulkan bahwa Anda mendekati CI dari arah yang salah dan untuk alasan yang salah.

Ini bisa bernilai usaha bahkan untuk tim yang terdiri dari satu. Ini terutama benar ketika Anda mengembangkan kode lintas platform dan Anda perlu memastikan bahwa perubahan Anda akan bekerja pada kedua platform. Sebagai contoh, kompiler C ++ Microsoft lebih menerima daripada GCC, jadi jika Anda mengembangkan di Windows tetapi perlu mendukung Linux juga, memiliki sistem CI memberitahu Anda ketika build Anda rusak di Linux adalah bantuan besar.

Beberapa sistem CI cukup mudah diatur, sehingga biaya overhead tidak terlalu besar. Coba Jenkins atau Hudson misalnya.

Seperti yang Anda katakan ada biaya overhead pengaturan dan membuatnya tetap berjalan.

Tetapi pertanyaan di mana titik impas bukanlah fungsi dari berapa banyak orang yang Anda miliki di tim Anda, melainkan fungsi dari panjang proyek Anda.

Karena itu, ada bagian dari biaya setup yang dapat Anda gunakan dalam semua proyek masa depan Anda, sehingga dalam jangka panjang biaya overhead mungkin mendekati nol.

Saya mengatur Jenkins minggu ini untuk membangun proyek .NET kecil yang saya kerjakan. Saya mengintegrasikannya dengan kontrol sumber Git saya sehingga memicu pembangunan di setiap komit. Saya mengintegrasikan unit test ke dalam build. Saya mengintegrasikan analisis statis dalam bentuk pelanggaran FxCop dan StyleCop.

Sekarang setiap kali saya check-in, itu memeriksa semua kode saya, membangunnya, menambah nomor versi di semua majelis, mengujinya, menganalisisnya untuk pelanggaran FxCop dan StyleCop, mengarsipkan pembuatan dan mencatat hasil dalam sejumlah grafik sehingga Saya memiliki visibilitas dari waktu ke waktu hasil pengujian dan pelanggaran.

Melakukannya dari awal membutuhkan waktu satu jam atau lebih (mungkin sehari dengan Google jika Anda belum pernah melakukannya). Tidak ada biaya karena semua alat tersedia secara gratis.

Jika, ketika dan ketika proyek dibangun, saya memiliki infrastruktur berkualitas tinggi yang akan tumbuh tanpa biaya. Jika atau ketika pengembang baru bergabung dengan proyek saya bisa mendapatkan visibilitas total pada pekerjaan mereka dan dampaknya terhadap proyek tanpa biaya.

Jadi satu-satunya skenario saya dapat melihat CI tidak layak sementara adalah untuk proyek yang akan memakan waktu satu hari atau lebih dan kemudian tidak pernah ditinjau kembali, atau satu dalam bahasa di mana tidak ada alat yang ada / gratis tersedia dan biaya untuk mendapatkannya tidak proporsional dengan pekerjaan.

Jika Anda dapat memverifikasi semua aspek proyek Anda setelah setiap perubahan, maka Anda tidak perlu CI.

Dalam semua kasus lain, ini merupakan kemenangan bersih.

Overhead minimal. Saya akan mengatakan untuk proyek satu orang akan berguna. Setelah Anda mencapai dua itu sangat berharga.

Saya setuju bahwa untuk satu orang memproyeksikan jika Anda memiliki "satu langkah membangun / memverifikasi" maka Anda mungkin baik-baik saja dengan integrasi terus-menerus, tetapi dalam kasus-kasus tersebut Anda telah melakukan sebagian besar kerja keras untuk mengatur CI jadi mungkin juga hanya menempatkan itu dalam sistem formal (CC, Hudson, TeamCity, dll).

Pertanyaan, kapan CI membayar untuk dirinya sendiri, adalah pertanyaan yang sulit dijawab pada proyek baru.

Pada proyek yang sudah ada, jauh lebih mudah dilihat. Jika Anda menemukan bug penting di bagian pengembangan rantai pasokan, Anda tahu bahwa masalah ada pada titik sedini mungkin. Biaya untuk memperbaiki itu sekarang adalah yang terendah. Jika masalah itu ada di lingkungan mana pun di atas pengembangan, biaya Anda lebih tinggi.

Sekarang, manajemen mungkin memutuskan untuk merilis dengan bug, tapi itu risiko bisnis. Setidaknya sekarang ini dapat dikurangi melalui penilaian risiko, daripada panggilan telepon / panik larut malam, yang, jika mereka ditagih dengan tarif per jam, akhirnya menjadi sangat mahal.

Hal lain yang perlu diperhatikan dalam hal biaya. Seperti apa departemen QA Anda? Apakah ini pengujian manual? Jika Anda menggunakan CI, Anda mungkin dapat mengurangi biaya QA keseluruhan dengan mengotomatiskan skrip-skrip tersebut pada kotak dev Anda. Anda mungkin dapat mengurangi jumlah orang QA yang mendukung proyek Anda dengan melibatkan mereka dalam fase CI.

CI selalu selalu sepadan dengan itu: Rasa aman yang diberikannya memungkinkan Anda untuk bekerja pada tingkat yang lebih cepat daripada yang mungkin terjadi. Masalah yang Anda miliki tampaknya berkisar pada tes unit. Saya setuju bahwa tes unit sangat mahal, tetapi juga berpikir bahwa (untuk banyak hal) itu adalah pilihan paling buruk yang kita miliki. Secara pribadi, dan untuk jenis sistem yang cenderung saya kerjakan, saya bersumpah dengan tes tingkat sistem yang beroperasi pada kombinasi kasus dunia nyata dan (mungkin sintetik); Ini lebih murah daripada tes unit, dan masuk ke sudut-sudut yang sulit dijangkau dari alam semesta konseptual Anda: "Unknown Unknowns" karya Donald Rumsfeld.

Selalu gunakan, terlepas dari ukuran tim. Jika itu hanya Anda misalnya, siapa tahu, Anda mungkin membuat kode dari laptop Anda di starbucks kemudian melanjutkan dari sistem beefier Anda di rumah?

Biaya overhead sebenarnya tidak terlalu buruk.

Satu. Ya, satu sudah cukup untuk mulai menggunakan integrasi berkelanjutan.

Ini bukan masalah berapa banyak pengembang, tetapi dari

Sebuah. Berapa banyak waktu yang Anda hemat menggunakan otomatisasi dan seberapa sering.

• Hemat waktu untuk membangun setelah integrasi, menjalankan tes otomatis dan membuat pengaturan * frekuensi check-in = persen dari waktu yang disimpan.

b. Berapa banyak versi / cabang / produk yang Anda miliki.

• Jika Anda memiliki satu pengembang yang bekerja pada dua cabang yang berbeda maka waktu yang dihemat menjadi dua kali lipat, karena masing-masing cabang membutuhkan pembangunan, pengujian dan pengemasan.