Strategi percabangan dan versi untuk perpustakaan bersama

Posting ini tampaknya terkait, tetapi otak saya mulai meleleh, mencoba memikirkan hal ini melalui: P

Majikan saya baru saja mulai menggunakan kontrol sumber, terutama karena sebelum mereka mempekerjakan lebih banyak pengembang, "repositori" adalah hard drive dari dev, yang bekerja terutama dari rumah. Semua kode .NET yang ditulisnya diperiksa secara massal , dan ada banyak fungsi duplikat (baca: salin-tempel). Saat ini, sistem SCM kami adalah cadangan yang dimuliakan.

Saya ingin menarik beberapa kode duplikat ke perpustakaan bersama. Saya meninggalkan repo asli sendiri sehingga kami tidak merusak apa pun — kami dapat memindahkan dan / atau memperbaiki kode yang ada saat dan ketika diperlukan. Jadi saya sudah menyiapkan repo hanya untuk kode baru, termasuk perpustakaan.

Masalah saya berkisar pada versi perpustakaan tanpa membuat kami miring dalam proses yang berlebihan: setelah mengakui bahwa kami membutuhkan pendekatan yang lebih koheren, dengan lebih banyak devs semua menulis kode yang sangat mirip, manajemen dan dev lainnya terbuka untuk mengatur kembali hal-hal, tetapi mungkin tidak akan turun dengan baik jika solusi mulai mempengaruhi produktivitas.

Solusi ideal dalam pikiran obsesif saya adalah membangun perpustakaan secara terpisah, dengan setiap proyek bergantung dibangun terhadap versi yang dipilih secara sengaja dan kompatibel. Dengan begitu, kami tahu persis klien mana yang memiliki versi pustaka mana, dapat lebih dipercaya mereproduksi bug, mempertahankan cabang rilis independen untuk produk dan pustaka, dan tidak memecah proyek masing-masing saat mengubah kode bersama.

Ini membuat memperbarui perpustakaan rumit, terutama untuk dev yang bekerja dari rumah. Saya berharap perpustakaan berubah dengan cepat, setidaknya pada awalnya ketika kita (akhirnya) mengumpulkan bit-bit umum bersama. Sangat mungkin bahwa saya sepenuhnya memikirkan hal ini dan kami akan baik-baik saja hanya membangun segalanya terhadap komitmen perpustakaan terbaru, tapi saya ingin setidaknya bersiap - siap untuk hari kami memutuskan bahwa beberapa komponen harus versi independen dan didistribusikan. Fakta bahwa beberapa perpustakaan harus diinstal di GAC membuat versi sangat penting.

Jadi pertanyaan saya adalah: apa yang saya lewatkan? Saya merasa seperti saya terpaku pada satu solusi dan sekarang saya mencoba menemukan variasi di atasnya yang akan membuat perubahan lebih lancar. Strategi apa yang pernah Anda gunakan untuk menyelesaikan masalah seperti ini sebelumnya? Saya menyadari pertanyaan ini ada di mana-mana; Saya akan melakukan yang terbaik untuk membersihkan dan mengklarifikasi poin-poin ketidakpastian.

Dan sebanyak yang saya ingin gunakan Mercurial, kami telah menghabiskan uang untuk SCM (Vault) komersial terpusat dan beralih bukanlah pilihan. Selain itu, saya pikir masalahnya di sini lebih dalam dari pilihan alat kontrol versi.

Saya memuji inisiatif Anda. Ini akan menghasilkan sejumlah manfaat bagi organisasi saat Anda menerapkannya. Saya akan memindahkan kode daripada menyalinnya. Memiliki salinan kemungkinan akan menghasilkan perubahan yang tidak kompatibel yang perlu diselesaikan.

Akan ada rasa sakit karena perpustakaan dikembangkan dan distabilkan. Setelah selesai, manfaatnya akan tiba. Ingat bahwa antarmuka ke perpustakaan pada dasarnya adalah kontrak dengan proyek yang bekerja dengan kontrak. Anda mungkin memiliki keuntungan menghapus antarmuka lama karena Anda mungkin dapat menentukan apakah mereka digunakan.

Sementara perpustakaan stabil, mendapatkan perpustakaan baru mungkin harus menjadi bagian dari proses pembaruan kode. Anda mungkin ingin menjadwalkan komitmen perubahan perpustakaan. Mengumumkan kode yang dipindahkan dapat membantu mengurangi perubahan yang bertentangan.

Perpustakaan harus diperlakukan sebagai proyek terpisah dan distabilkan sesegera mungkin. Setelah mereka distabilkan (terutama antarmuka), akan lebih mudah untuk mengintegrasikan perubahan dengan proyek lain. Perpustakaan baru harus bekerja dengan kode lama. Tag rilis perpustakaan stabil dengan id rilis mereka sendiri. Cobalah untuk memperlakukan perpustakaan seperti yang Anda lakukan dengan perpustakaan pihak ketiga.

Kode yang dibagikan antar proyek harus diperlakukan sebagai proyek sendiri. Mereka harus diperlakukan dengan ketelitian yang sama seperti perpustakaan pihak ketiga. Tidak ada jalan lain.

Jika Anda tidak dapat membuat grup Anda mengadopsi strategi untuk kode bersama, Anda dapat mengadopsi sendiri dengan bantuan alat manajemen kode sumber modern seperti Mercurial atau GIT, bahkan jika tidak ada SCM yang secara resmi akan digunakan oleh perusahaan Anda. Dengan sedikit perhatian, dua SCM dapat menggunakan direktori kerja yang sama hanya dengan mengatakan satu untuk mengabaikan file internal yang lain. Anda akan menggunakan satu SCM untuk berurusan dengan yang sehari-hari, dan yang satu perusahaan untuk diintegrasikan.

Bagaimanapun, Anda harus bertanggung jawab atas kapan harus memperbarui direktori kerja Anda dengan modifikasi proyek lain yang telah dibuat untuk kode bersama. Itu harus terjadi hanya ketika Anda siap untuk berurusan dengan ketidakcocokan yang mungkin timbul; jika tidak, pekerjaan Anda mungkin menjadi tidak stabil yang tidak bisa dilakukan.

Jika Anda memiliki kemampuan untuk memecahnya menjadi proyek "modul" yang terpisah, saya akan mengambil pendekatan itu. Satu hal yang perlu diperhatikan adalah kode kopling. Anda akan membuat pemisahan kekhawatiran dengan memecahnya, yang merupakan praktik yang baik.

Beberapa manfaat:

1. Debugging sederhana dari setiap modul.
2. Siklus pembuatan yang lebih cepat (tidak ada pembangunan kembali perpustakaan yang tidak berubah)
3. Setelah sesuatu berfungsi, Anda cenderung untuk tidak merusaknya dengan mengubah area lain di luar modul itu (bukan 100%, tetapi Anda mengurangi peluang).
4. Lebih mudah untuk memecah tugas kerja jika itu bukan kekacauan besar yang saling tergantung.
5. Distribusi lebih cepat dari potongan-potongan kecil ketika Anda memperbaiki satu perpustakaan (alasan besar mengapa Anda memiliki file .dll / .so).

Saya punya satu pertanyaan tentang bagian ini:

"Solusi ideal dalam pikiran obsesif saya adalah membangun perpustakaan secara terpisah, dengan setiap proyek bergantung dibangun terhadap versi yang dipilih secara sengaja dan kompatibel."

Apakah Anda statis menghubungkan seluruh proyek? Jika demikian ini akan menyebabkan: 6. Pengurangan kode mengasapi yang tidak perlu.

Beberapa negatif:

1. Jika proyek ini kecil, maka Anda hanya menambahkan kompleksitas di mana tidak diperlukan.
2. Bercabang banyak modul dapat berubah menjadi masalah pemeliharaan untuk proyek yang sangat besar. Saya tidak tahu "Vault", jadi saya tidak yakin apakah operasi percabangannya baik atau buruk.

Saat ini, sepertinya Anda memiliki satu basis kode yang dibangun sekaligus menjadi satu target. Anda mungkin memiliki tidak lebih dari lima pengembang. Saya benar-benar tidak melihat kegunaan memisahkan perpustakaan terlalu banyak. Anda akan mengubah alur kerja Anda dari kode -> kompilasi -> jalankan ke kode -> kompilasi -> salin DLL -> kompilasi -> jalankan ... ick.

Beberapa perusahaan (Google dan Amazon) memiliki infrastruktur yang cukup untuk pengembangan sehingga cukup sulit untuk memiliki banyak perpustakaan terpisah yang dibangun secara terpisah. Infrastruktur untuk membuatnya tanpa rasa sakit melibatkan cara untuk menentukan versi pustaka yang hidup di SCM Anda (yang mungkin Anda miliki), cara untuk menentukan versi dependensi yang hidup di SCM Anda, server build yang dapat memahami dan mengkompilasi semuanya dengan benar , dan cara untuk mengambil artefak build yang sesuai dari server build Anda dan dari ruang kerja lokal Anda. Saya ragu Anda memilikinya.

Tanpa infrastruktur itu, saya akan memisahkan proyek ketika salah satu dari yang berikut ini berlaku:

• Anda memiliki banyak produk atau aplikasi berbeda tergantung pada perpustakaan ini
• Anda bekerja secara eksklusif di perpustakaan ini selama beberapa hari sekaligus
• Fungsi perpustakaan sangat terpisah dari apa pun yang terkait dengan bisnis (misalnya, pembungkus di sekitar API khusus platform)
• Waktu pembangunan untuk proyek gabungan tumbuh terlalu besar

Saya khawatir tentang membangun infrastruktur itu ketika Anda memiliki banyak proyek dan beberapa pengembang telah berdedikasi dan siklus rilis independen.

Apa yang dapat dan harus Anda lakukan sekarang adalah menyiapkan server build untuk build yang andal dan berulang dan pastikan bahwa Anda dapat menemukan revisi sumber dari executable yang diberikan. Anda tampaknya menggunakan .NET; cukup mudah untuk mengatur CruiseControl.NET untuk memasukkan string versi, termasuk nomor revisi.

Setelah Anda memiliki server build, memisahkan perpustakaan akan menjadi masalah memindahkannya di Vault, menambahkan target lain di CC.NET, dan menyalin DLL yang dihasilkan ke folder perpustakaan proyek utama Anda dan melakukan itu. Lebih mudah di sisi SCM daripada pengembangan sehari-hari.

Mercurial memiliki fitur yang disebut subrepositori. Baru-baru ini saya membaca blog ini dari Kiln yang menjelaskan cara kerjanya.

Pada dasarnya, Anda menautkan proyek Anda ke revisi tertentu dari repositori perpustakaan. Anda dapat memperbarui perpustakaan sebanyak yang Anda inginkan tanpa merusak proyek yang tergantung. Saat Anda siap, Anda dapat menarik fitur baru perpustakaan ke dalam proyek Anda dan menangani kerusakan apa pun. Proyek yang berbeda dapat menautkan ke revisi perpustakaan yang berbeda, sehingga mereka tidak semua harus sinkron dan menggunakan revisi perpustakaan yang sama.

Mungkin Vault memiliki fitur serupa.

Kami telah menambahkan file metadata ke setiap modul di SC yang menunjukkan nama semua modul lain yang bergantung padanya. Suatu produk akan memiliki file metadata kedua yang menunjukkan versi mana dari setiap modul yang diperlukan untuk produk tersebut. Di atas ini adalah alat untuk menganalisis file metadata, memeriksa semua modul yang diperlukan, dan menghasilkan proyek untuk IDE kami.

Ini memastikan build kami selalu direproduksi, dan file header yang benar selalu dibagi antara komponen. Kompleksitas lain dapat ditata seiring dengan berkembangnya kebutuhan. Kami memiliki alat yang sekarang dapat menghasilkan laporan tentang perbedaan antara dua build dari suatu produk, menentukan file sumber yang berubah, komentar check-in, komentar versi, penulis, di semua modul independen di SC. Kami mendapatkan jumlah penggunaan kembali yang fenomenal dari basis kode kami.