Pemformatan ulang dan kontrol versi

Masalah pemformatan kode. Bahkan lekukan penting . Dan konsistensi lebih penting daripada perbaikan kecil. Tetapi proyek biasanya tidak memiliki panduan gaya yang jelas, lengkap, dapat diverifikasi , dan ditegakkan sejak hari pertama, dan perbaikan besar dapat tiba kapan saja. Mungkin Anda menemukannya

SELECT id, name, address
FROM persons JOIN addresses ON persons.id = addresses.person_id;

bisa lebih baik ditulis sebagai / lebih baik ditulis daripada

SELECT persons.id,
       persons.name,
       addresses.address
  FROM persons
  JOIN addresses ON persons.id = addresses.person_id;

saat bekerja untuk menambahkan lebih banyak kolom ke kueri. Mungkin ini adalah yang paling kompleks dari keempat kueri dalam kode Anda, atau kueri sepele di antara ribuan. Tidak peduli betapa sulitnya transisi, Anda memutuskan itu layak. Tetapi bagaimana Anda melacak perubahan kode di seluruh perubahan pemformatan utama? Anda bisa menyerah dan mengatakan "ini adalah titik di mana kita mulai lagi", atau Anda bisa memformat ulang semua kueri di seluruh riwayat penyimpanan.

Jika Anda menggunakan sistem kontrol versi terdistribusi seperti Git, Anda dapat kembali ke komit pertama, dan memformat jalan dari sana ke kondisi saat ini. Tapi itu banyak pekerjaan, dan semua orang harus berhenti bekerja (atau bersiaplah untuk ibu dari semua penggabungan) saat sedang berlangsung. Apakah ada cara yang lebih baik untuk mengubah riwayat yang memberikan yang terbaik dari semua hasil:

• Gaya yang sama di semua komit
• Pekerjaan penggabungan minimal

?

Untuk memperjelas, ini bukan tentang praktik terbaik saat memulai proyek, tetapi apa yang harus dilakukan ketika refactoring besar telah dianggap sebagai Good Thing ™ tetapi Anda masih menginginkan riwayat yang dapat dilacak? Tidak pernah menulis ulang sejarah itu bagus jika itu satu-satunya cara untuk memastikan bahwa versi Anda selalu bekerja sama, tetapi bagaimana dengan manfaat pengembang dari menulis ulang bersih? Terutama jika Anda memiliki cara (tes, definisi sintaks atau biner yang sama setelah kompilasi) untuk memastikan bahwa versi yang ditulis ulang bekerja dengan cara yang sama persis seperti aslinya?

Lakukan pemformatan ulang sebagai komitmen terpisah. Ini akan sedikit mengganggu sejarah, dan Anda harus dapat melihat sekilas mana yang melakukan hanya memformat ulang dan yang benar-benar mengubah kode. Itu bisa miring git blamedan serupa, tetapi jika itu menunjuk ke komitmen hanya reformat, itu cukup lurus ke depan untuk mencari perubahan sebelumnya sebelum itu.

Jangan menulis ulang sejarah VCS: itu bertentangan dengan prinsip VCS.

Jangan mencoba mengotomatiskan pemformatan: itu mengobati gejalanya, bukan masalah sebenarnya (= pengembang tidak mengikuti standar pengkodean).

Tetapkan standar pengkodean dan format praktik terbaik dalam dokumen umum dan minta semua pengembang menyetujuinya.

Anda menyebut Git, yang hebat, karena didistribusikan. Dengan DVCS, sangat mudah untuk menegakkan praktik terbaik melalui alur kerja gatekeeper . Gatekeeper menolak proposal penggabungan (= menarik permintaan di Git) yang tidak sesuai dengan pedoman umum. Dan maksud saya tolak , dalam huruf tebal, jika pembuat kode yang melanggar tidak akan repot untuk mengikuti aturan dan terus mengulangi kesalahan yang sama.

Teknik ini bekerja dengan baik untuk saya. Coder ingin pekerjaan mereka digabung, jadi setelah beberapa kesalahan pada awalnya mereka mulai mengikuti aturan.

Sesuai memperbaiki basis kode yang ada ... Saya sarankan melakukan itu secara bertahap, mungkin modul demi modul, atau karena masuk akal untuk proyek Anda. Uji dengan cermat pada setiap langkah. Ini mungkin terdengar bodoh, tetapi kesalahan terjadi bahkan dengan perubahan sepele seperti hanya memformat, jadi bersiaplah untuk beberapa gundukan kecil di jalan.

Jawaban untuk pertanyaan Anda yang sebenarnya adalah, "Anda tidak." Saya tahu tidak ada alat SCM saat ini yang dapat melacak perubahan dalam logika dari kode yang diformat dalam satu cara, melalui perubahan format utama, dan melalui perubahan lebih lanjut setelah kode diformat dengan cara baru. Dan, Anda tahu ini, kehilangan sejarah pada sepotong kode tidak baik.

Oleh karena itu, saya akan sedikit menentang kalimat pertama Anda. Kode format tidak peduli bahwa banyak. Cantik itu bagus, tapi bukan untuk apa kita di sini. Saya mengerti juga siapa pun yang dimasukkan ke kode varian K&R aneh neraka lama seseorang dengan indentasi dua-ruang menyebalkan (1), tapi ... memformat sebenarnya bukan halangan untuk memahami apa yang terjadi, kecuali itu sesuatu yang luar biasa patologi. Dan jika demikian, Anda tetap akan mengalami masalah dalam mengubah kode, dan tidak perlu repot-repot melakukannya.

Oleh karena itu, tidak layak untuk membuat perubahan pada kode yang telah ditetapkan dengan keras untuk memformat ulangnya. Mengubah nama variabel, memecah fungsi panjang, semua hal refactoring yang bagus yang mengubah konten, ya, tapi tidak HANYA memformat ulang.

1) - Saya pernah memiliki Windows Clipboard Viewer untuk sementara waktu. Semuanya adalah satu, 150k, modul C. Saya menemukan tempat di mana orang yang berbeda telah menggunakan, saya pikir, lima gaya penyangga yang berbeda dalam tiga puluh baris satu sama lain. Tapi itu bagian dari BEKERJA. Saya membawa sekitar cetakan dari potongan kode itu selama sepuluh tahun, tapi saya tidak menyodoknya karena sejarah itu penting, dan kode itu ada di setidaknya tiga pohon sumber (Windows 3.x, NT, masa depan 95) yang semuanya hidup di gedung yang berbeda.

Tetapi bagaimana Anda melacak perubahan kode di seluruh perubahan pemformatan utama?

Perubahan format adalah perubahan kode; perlakukan mereka seperti Anda akan mengubah kode Anda. Siapa pun yang telah mengerjakan proyek yang signifikan mungkin akan melihat bug dan masalah lain yang dibuat ketika seseorang memutuskan untuk "hanya" memformat ulang beberapa kode.

Tapi itu banyak pekerjaan, dan semua orang harus berhenti bekerja (atau bersiaplah untuk ibu dari semua penggabungan) saat sedang berlangsung.

Mengapa Anda harus memformat ulang semuanya pada saat yang bersamaan? Terutama jika pemformatan ulang tidak mengubah arti kode, Anda harus dapat memformat ulang file secara individual dan memeriksanya saat Anda melanjutkan. Lebih baik, mintalah semua orang di tim Anda untuk menyetujui gaya (jika tidak, tidak ada gunanya memformat ulang) dan minta mereka semua mengurus pemformatan ulang dalam pekerjaan mereka yang lain. Setelah beberapa saat, Anda akan membahas sebagian besar kode tanpa mengganggu sisa proyek.

Ada dua pendekatan yang saya lihat selama ini.

1. Memformat ulang kode pada commit-hook

Walaupun awalnya mengubah-ubah untuk mengubah kode setelah mereka mengirimkannya, jika prosedur pemformatan ulang Anda (misalnya astyle ) tidak merusak kode, maka ini merupakan operasi yang aman. Seiring waktu, seluruh tim akan menghargai bahwa semua kode pada akhirnya terlihat sama. Jelas, memiliki unit / tes otomatis yang komprehensif akan memastikan bahwa tidak ada yang rusak.

2. Pemformatan ulang satu kali untuk semua kode

Ini lebih berbahaya dalam pengalaman saya, dan membuat masalah pelacakan di big-bang sulit, tapi itu mungkin. Menjalankan semua tes setelah itu sangat penting. Untuk gaya pengkodean, sebagian besar perbedaan berkisar pada penggunaan spasi putih - indentasi atau baris baru. Alat penggabungan yang layak harus dapat dikatakan untuk mengabaikan semua perbedaan spasi putih, jadi ini akan membantu dengan penggabungan.