Apa keuntungan membangun skrip?

Untuk sebagian besar karir pemrograman saya, saya telah menggunakan perintah "build / compile / run" dalam IDE apa pun yang saya kerjakan untuk menghasilkan program runnable. Ini satu tombol, cukup mudah. Ketika saya belajar lebih banyak tentang berbagai bahasa dan kerangka kerja, saya melihat semakin banyak pembicaraan tentang "skrip pembuatan" (ANT, Maven, Gradle, dll.) Untuk menjalankan proyek. Pemahaman saya tentang ini adalah bahwa mereka adalah instruksi untuk pembuat kompilator / penghubung / program magis yang menentukan detail konfigurasi - hal-hal kecil.

Saya ingat pernah menulis makefile di sekolah, tetapi saya tidak melihat keuntungan khusus saat itu (kami hanya menggunakannya ketika menulis di terminal Unix, di mana IDE dengan tombol "build" yang praktis tidak ada). Di luar itu, saya telah melihat pertanyaan lain di sini yang membahas bagaimana membangun skrip dapat melakukan lebih dari sekedar membuat program Anda - mereka dapat menjalankan tes unit serta sumber daya aman terlepas dari mesin host .

Saya tidak bisa menghilangkan perasaan bahwa membangun skrip penting untuk dipahami sebagai pengembang, tetapi saya ingin penjelasan yang bermakna; mengapa saya harus menggunakan / menulis skrip build?

Tanggung jawab Build Script dan Build Server membahas peran yang dimainkannya dalam cakupan yang lebih luas. Saya mencari keuntungan spesifik yang ditawarkan oleh skrip build versus perintah "build / run" IDE atau metode sederhana yang serupa.

Otomatisasi.

Ketika Anda berkembang, hanya dalam proyek yang paling sederhana akan tombol "build" default melakukan semua yang Anda butuhkan untuk dilakukan; Anda mungkin perlu membuat WS dari API, membuat dokumen, menghubungkan dengan sumber daya eksternal, menyebarkan perubahan ke server, dll. Beberapa IDE memungkinkan Anda untuk menyesuaikan proses pembuatan dengan menambahkan langkah atau pembangun tambahan, tetapi itu hanya berarti bahwa Anda membuat skrip build Anda melalui komoditas IDE.

Tetapi mengembangkan sistem tidak hanya menulis kode. Ada beberapa langkah yang terlibat. Skrip independen IDE dapat dijalankan secara otomatis, artinya:

• Saat Anda mengkomit perubahan ke kontrol versi, build baru dapat diluncurkan secara otomatis oleh server. Ini akan memastikan bahwa Anda tidak lupa untuk melakukan apa pun yang diperlukan untuk membangun.

• Demikian pula, setelah pembangunan selesai, tes dapat secara otomatis dijalankan untuk melihat apakah Anda memecahkan sesuatu.

• Sekarang seluruh organisasi (QA, sysadmin) memiliki produk yang dibangun itu

  a) dapat direproduksi dengan sempurna hanya dari versi kontrol.

  b) umum bagi mereka semua.

Bahkan ketika saya telah bekerja sebagai tim satu orang, saya telah menggunakan skrip untuk tujuan itu; ketika saya telah mengembangkan perbaikan yang akan saya komit ke SVN, ekspor SVN kembali ke direktori lain dan menggunakan skrip build untuk menghasilkan solusi, yang kemudian pergi ke sistem Preproduction dan kemudian ke Production. Jika beberapa minggu kemudian (dengan basis kode lokal saya sudah berubah) seseorang mengeluhkan bug, saya akan tahu persis revisi SVN mana yang harus saya checkout untuk debug sistem dengan benar.

Seperti kode, skrip build dijalankan oleh komputer. Komputer sangat bagus dalam mengikuti serangkaian instruksi. Bahkan, (di luar kode modifikasi diri), komputer akan menjalankan urutan instruksi yang sama persis dengan cara yang sama, diberi input yang sama. Ini memberikan tingkat konsistensi yang, well, hanya komputer yang bisa cocok.

Sebaliknya, kita, kantong daging berisi air benar-benar tercela ketika harus mengikuti langkah-langkah berikut. Otak analitis yang sial itu memiliki kecenderungan untuk mempertanyakan segala sesuatu yang dijumpainya. "Oh ... aku tidak perlu itu", atau "Apakah aku benar-benar menggunakan bendera ini? Eh ... Aku akan mengabaikannya." Selain itu, kami memiliki kecenderungan untuk berpuas diri. Setelah kami melakukan sesuatu beberapa kali, kami mulai percaya bahwa kami tahu instruksinya, dan tidak perlu melihat lembar instruksi.

Dari "Programmer Pragmatis":

Selain itu, kami ingin memastikan konsistensi dan pengulangan pada proyek. Prosedur manual membiarkan konsistensi berubah; pengulangan tidak dijamin, terutama jika aspek prosedur terbuka untuk interpretasi oleh orang yang berbeda.

Selain itu, kami sangat lamban dalam menjalankan instruksi (dibandingkan dengan komputer). Pada proyek besar, dengan ratusan file dan konfigurasi, perlu waktu bertahun-tahun untuk secara manual menjalankan semua langkah dalam proses pembuatan.

Saya akan memberi Anda contoh dunia nyata. Saya sedang mengerjakan beberapa perangkat lunak tertanam, di mana sebagian besar kode dibagikan di beberapa platform perangkat keras yang berbeda. Setiap platform memiliki perangkat keras yang berbeda, tetapi sebagian besar perangkat lunaknya sama. Tetapi ada bagian-bagian kecil yang khusus untuk setiap perangkat keras. Idealnya, potongan-potongan umum akan ditempatkan di perpustakaan dan dihubungkan ke setiap versi. Namun, potongan umum tidak dapat dikompilasi ke perpustakaan bersama. Itu harus dikompilasi dengan setiap konfigurasi yang berbeda.

Pada awalnya, saya secara manual mengkompilasi setiap konfigurasi. Hanya butuh beberapa detik untuk beralih antar konfigurasi, dan tidak terlalu merepotkan. Menjelang akhir proyek, cacat kritis ditemukan di bagian kode bersama, di mana perangkat pada dasarnya akan mengambil alih bus komunikasi. Ini BURUK! Sangat buruk. Saya menemukan bug dalam kode, memperbaikinya, dan mengkompilasi ulang setiap versi. Kecuali satu. Selama proses pembangunan, saya terganggu, dan lupa satu. Binari dirilis, mesin dibangun, dan sehari kemudian saya mendapat telepon mengatakan mesin berhenti merespons. Saya memeriksanya, dan menemukan perangkat telah mengunci bus. "Tapi saya memperbaiki bug itu!"

Saya mungkin telah memperbaikinya, tetapi tidak pernah menemukan jalannya ke papan yang satu itu. Mengapa? Karena saya tidak memiliki proses pembuatan otomatis yang membangun setiap versi dengan 1 klik.

Jika yang ingin Anda lakukan hanyalah <compiler> **/*.<extension>, buat skrip hanya untuk tujuan yang kecil (meskipun orang dapat berargumen bahwa jika Anda melihat sebuah Makefileproyek, Anda tahu Anda dapat membuatnya make) Masalahnya adalah - proyek non-sepele biasanya membutuhkan lebih dari itu - setidaknya, Anda biasanya perlu menambahkan perpustakaan dan (saat proyek matang) mengkonfigurasi parameter build.

IDE biasanya setidaknya dapat dikonfigurasi - tetapi sekarang proses pembangunannya bergantung pada opsi-opsi khusus IDE. Jika Anda menggunakan Eclipse , Alice lebih suka NetBeans , dan Bob ingin menggunakan IntelliJ IDEA , Anda tidak dapat berbagi konfigurasi, dan ketika salah satu dari Anda mendorong perubahan ke kontrol sumber, mereka perlu mengedit konfigurasi yang dibuat secara manual secara manual file dari pengembang lain, atau beri tahu pengembang lain sehingga mereka akan melakukannya sendiri (yang berarti akan ada komit di mana konfigurasi IDE salah untuk beberapa IDE ...).

Anda juga perlu mencari tahu bagaimana melakukan perubahan itu di masing-masing dan setiap IDE yang digunakan oleh tim, dan jika salah satu dari mereka tidak mendukung pengaturan tertentu ...

Sekarang, masalah ini tergantung pada budaya - pengembang Anda mungkin merasa dapat diterima untuk tidak memiliki pilihan IDE. Tetapi pengembang yang memiliki pengalaman dengan IDE biasanya lebih bahagia dan lebih efisien saat menggunakannya, dan pengguna editor teks cenderung mendapatkan fanatik agama tentang alat favorit mereka, jadi ini adalah salah satu tempat di mana Anda ingin memberikan kebebasan kepada pengembang - dan membangun sistem memungkinkan Anda melakukan hal itu. Beberapa orang mungkin memiliki preferensi sistem build, tetapi itu tidak fanatik seperti preferensi IDE / editor ...

Bahkan jika Anda membuat semua pengembang menggunakan IDE yang sama - semoga berhasil meyakinkan server build untuk menggunakannya ...

Nah, itu untuk kustomisasi proses build yang sederhana, IDE cenderung memberikan GUI yang bagus. Jika Anda menginginkan hal-hal yang lebih kompleks - seperti file sumber pra-pemrosesan / penghasil otomatis sebelum kompilasi - Anda biasanya harus menulis skrip pra-bangun di beberapa area teks dasar di dalam konfigurasi IDE. Sistem build mana yang masih harus Anda kodekan pada bagian itu, tetapi Anda dapat melakukannya di editor aktual tempat Anda menulis kode, dan yang lebih penting: kerangka kerja sistem build itu sendiri biasanya menyediakan beberapa dukungan untuk mengatur skrip ini.

Akhirnya - membangun sistem lebih baik daripada sekadar membangun proyek - Anda dapat memprogramnya untuk melakukan tugas-tugas lain yang mungkin perlu dilakukan oleh semua orang dalam tim. Di Ruby on Rails , misalnya, ada tugas sistem bangun untuk menjalankan migrasi basis data, untuk membersihkan file sementara, dll. Menempatkan tugas ini dalam sistem bangun memastikan bahwa semua orang di tim dapat melakukannya secara konsisten.

Banyak IDE hanya mengemas perintah yang digunakan untuk membangun sesuatu dan kemudian menghasilkan skrip dan menyebutnya!

Misalnya, di Visual Studio, Anda dapat melihat parameter baris perintah untuk kompilasi C ++ di kotak 'command line'. Jika Anda melihat lebih dekat pada output build Anda akan melihat file sementara yang berisi skrip build yang digunakan untuk menjalankan kompilasi.

Saat ini, semuanya MSBuild , tapi itu masih dijalankan langsung oleh IDE.

Jadi alasan Anda menggunakan baris perintah adalah bahwa Anda akan langsung ke sumber dan melewatkan perantara, seorang perantara yang mungkin telah diperbarui atau memerlukan tumpukan dependensi yang Anda tidak inginkan atau butuhkan pada server tanpa kepala yang bertindak sebagai server integrasi berkelanjutan (CI) Anda.

Selain itu, skrip Anda melakukan lebih dari langkah-langkah berorientasi pengembang yang biasanya dirancang untuk mereka. Misalnya, setelah membangun, Anda mungkin ingin binari Anda dikemas dan disalin ke lokasi khusus, atau paket penginstal dibuat, atau alat dokumentasi dijalankan di dalamnya. Banyak tugas berbeda dilakukan oleh server CI yang tidak ada gunanya pada mesin pengembang, jadi sementara Anda bisa membuat proyek IDE yang melakukan semua langkah ini, Anda kemudian harus mempertahankan dua di antaranya - proyek untuk pengembang dan yang lain untuk pembangunan. Beberapa tugas pembangunan (analisis statis misalnya) dapat memakan waktu lama yang tidak Anda inginkan untuk proyek pengembang.

Singkatnya, ini hanya lebih mudah - buat skrip untuk melakukan semua hal yang Anda inginkan dan cepat dan mudah untuk memulai itu pada baris perintah atau konfigurasi server bangun.

make

jauh lebih mudah diingat dan diketik daripada

gcc -o myapp -I/include/this/dir -I/include/here/as/well -I/dont/forget/this/one src/myapp.c src/myapp.h src/things/*.c src/things/*.h

Dan proyek dapat memiliki perintah kompilasi yang sangat kompleks. Skrip build juga memiliki kemampuan untuk hanya mengkompilasi ulang hal-hal yang berubah. Jika Anda ingin melakukan build bersih,

make clean

lebih mudah dan lebih dapat diandalkan sekali diatur dengan benar daripada mencoba mengingat masing-masing dan setiap tempat file perantara mungkin telah diproduksi.

Tentu saja, jika Anda menggunakan IDE, mengklik tombol build atau clean juga mudah. Namun, jauh lebih sulit untuk mengotomatiskan memindahkan kursor ke tempat tertentu di layar, terutama ketika tempat itu dapat bergerak jika jendela bergerak, daripada mengotomatiskan perintah teks sederhana.

Bagaimana lagi yang akan Anda lakukan? Satu-satunya cara lain adalah menentukan satu perintah baris perintah panjang.

Alasan lain adalah makefile memungkinkan kompilasi tambahan, yang mempercepat waktu kompilasi.

Makefiles juga dapat membuat proses membangun lintas-platform. CMake menghasilkan skrip build berbeda berdasarkan platform.

Sunting:

Dengan IDE, Anda terikat dengan cara tertentu dalam melakukan sesuatu. Banyak orang menggunakan vim atau emacs walaupun mereka tidak memiliki banyak fitur seperti IDE. Mereka melakukannya karena mereka menginginkan kekuatan yang disediakan oleh para editor ini. Bangun skrip diperlukan untuk mereka yang tidak menggunakan IDE.

Bahkan bagi mereka yang menggunakan IDE, Anda mungkin ingin benar-benar tahu apa yang sedang terjadi, jadi skrip build memberikan Anda detail implementasi yang tidak dimiliki oleh pendekatan GUI.

Penggunaan IDE sendiri sering membuat skrip secara internal juga; tombol run hanyalah cara lain untuk menjalankan perintah make.

Jawaban di atas mencakup banyak alasan bagus, tetapi satu contoh dunia nyata yang ingin saya tambahkan (yang tidak dapat saya tambahkan sebagai komentar karena tidak ada karma), berasal dari pemrograman Android.

Aku seorang pengembang profesional Phone Android / iOS / Windows, dan saya menggunakan layanan API Google (kebanyakan Google Maps) yang banyak .

Di Android, layanan ini mengharuskan saya menambahkan keystore , atau jenis file ID pengembang yang memberi tahu Google bahwa saya adalah siapa yang saya katakan saya, ke konsol pengembang. Jika aplikasi saya dikompilasi dengan keystore yang berbeda, bagian Google Maps dari aplikasi tidak akan berfungsi.

Alih-alih menambahkan dan mengelola selusin keystores ke konsol pengembang, hanya satu yang benar-benar dapat digunakan untuk memperbarui aplikasi, saya memasukkan keystore ini dalam repo kami yang aman dan menggunakan Gradle untuk memberi tahu Android Studio persis apa keystore yang akan digunakan saat membangun untuk "debug" atau "lepaskan". Sekarang, saya hanya perlu menambahkan dua keystores ke konsol pengembang Google saya, satu untuk "debug" dan satu untuk "rilis", dan semua anggota tim saya dapat mengkloning repo dan mendapatkan hak untuk mengembangkan tanpa harus masuk ke dev menghibur dan menambahkan hash SHA keystore khusus mereka, atau lebih buruk, membuat saya mengelolanya. Ini memiliki manfaat tambahan dengan memberikan masing-masing anggota tim salinan keystore penandatanganan, yang berarti bahwa jika saya keluar dari kantor dan pembaruan dijadwalkan, anggota tim hanya perlu mengikuti daftar instruksi yang sangat singkat untuk mendorong suatu memperbarui.

Otomasi bangunan seperti ini membuat build tetap konsisten, dan mengurangi utang teknis dengan mengurangi waktu set-up ketika kita mendapatkan pengembang baru, mesin baru, atau ketika kita harus mengubah citra sebuah mesin.

Bangun keunggulan skrip:

• perubahan terlihat seperti kode (misalnya, dalam perintah git diff), tidak seperti opsi yang diperiksa berbeda dalam dialog

• menciptakan lebih banyak output daripada bangunan sederhana

Di beberapa proyek saya sebelumnya, saya telah menggunakan skrip build untuk:

• menghasilkan dokumentasi proyek (berbasis oksigen)
• membangun
• jalankan tes unit
• menghasilkan laporan cakupan tes unit
• kemas binari ke dalam arsip rilis
• menghasilkan catatan rilis internal (berdasarkan pesan "git log")
• pengujian otomatis

Seringkali Anda dapat memanggil tombol "build" dengan cara otomatis (Visual Studio menerima argumen baris perintah, misalnya). Orang-orang menulis skrip build segera setelah mereka membutuhkan sesuatu yang tidak bisa disediakan oleh tombol build.

Misalnya, sebagian besar IDE hanya akan membiarkan Anda membangun satu platform pada satu waktu. Atau hanya satu bahasa pada satu waktu. Lalu ada apa yang Anda lakukan dengan output yang dibangun: dapatkah IDE Anda menggulung semuanya menjadi paket instalasi?