Dalam tahun-tahun saya pemrograman Java dan Scala baru-baru ini, saya tidak pernah menggunakan Ant, Maven, Gradle atau alat-alat yang membangun untuk Java. Di mana-mana saya pernah bekerja ada build manager yang mengurus semua itu - saya akan mengkompilasi secara lokal dengan IDE untuk pengembangan dan pengujian unit, kemudian memeriksa kode sumber dan memberitahu build manager yang melakukan apa yang diperlukan untuk kompilasi file semua orang untuk lingkungan yang dibagikan.

Sekarang, di sela-sela kontrak, saya telah mengerjakan proyek swadaya saya sendiri dan mencapai titik di mana itu bisa cukup baik untuk benar-benar menghasilkan uang. Saya bahkan punya calon investor yang mengantre dan berencana untuk menunjukkan kepada mereka versi beta dalam beberapa minggu ke depan.

Tapi selama ini saya cukup klik tombol build pada IDE, dan itu menciptakan file Jar dan berfungsi dengan baik. Tentu saja, kebijaksanaan konvensional menunjukkan bahwa saya "harus" menulis skrip Ant / Maven / Gradle saya sendiri dan menggunakannya sebagai pengganti IDE, tetapi apa keuntungan nyata dari hal itu dalam situasi saya (bekerja sendiri)?

Saya telah melakukan beberapa bacaan tentang bagaimana menggunakan alat-alat membangun itu, dan sepertinya saya akan menulis ratusan baris XML (atau Groovy atau apa pun) untuk melakukan apa yang dilakukan IDE dalam satu klik (IDE yang dihasilkan Ant XML untuk proyek ini lebih dari 700 baris). Itu hanya terlihat rawan kesalahan dan memakan waktu dan tidak perlu untuk situasi saya. Belum lagi kurva belajar, yang akan mengambil waktu dari semua pekerjaan lain yang saya lakukan untuk membuat produk siap untuk ditampilkan.

Saya sarankan Anda melihat menggunakan Maven sebagai lawan Ant. Jika IDE Anda dapat membangun proyek Anda dalam satu klik, maka kemungkinan Maven juga dapat membangun proyek Anda tanpa konfigurasi khusus.

Dan untuk menjawab pertanyaan itu, menyederhanakan proses penyebaran adalah salah satu contoh nyata. Jika Anda membuat distribusi yang dapat didistribusikan secara lokal, artinya Anda harus menggunakan penyebaran yang dapat didistribusikan secara manual pada sistem produksi Anda, dan menyiratkan bahwa Anda mungkin harus melakukan sedikit konfigurasi manual pada sistem produksi untuk membuatnya siap untuk ditempatkan (menginstal Tomcat , mungkin, atau menyalin ketergantungan dan sumber daya yang dibutuhkan oleh aplikasi Anda). Ini bisa memakan waktu, dan dapat membuat pembaruan penempatan menjadi proses manual yang membosankan. Ini juga memungkinkan potensi perbedaan konfigurasi kecil antara platform produksi Anda dan lingkungan pengembangan Anda menyebabkan kesalahan yang tidak jelas, sulit dilacak.

Jadi bagaimanapun, apa yang saya lakukan untuk menghilangkan pekerjaan manual ini adalah bahwa saya mengkonfigurasi proyek saya untuk membangun dengan Maven, dan saya mengkonfigurasi pom.xmlfile saya dengan semua informasi yang diperlukan untuk (dalam kasus aplikasi web Java) menemukan dan mengunduh perbaiki versi Tomcat, instal secara lokal, atur file konfigurasi Tomcat yang benar, gunakan segala dependensi proyek dan file proyek WAR itu sendiri, kemudian mulai Tomcat. Saya kemudian membuat skrip shell sederhana (dan juga .batversi untuk Windows) yang menggunakan Maven untuk membangun dan memulai server:

mvn clean install cargo:start -Dcargo.maven.wait=true

Jadi alih-alih mengemas deployable pada lingkungan dev saya dan kemudian secara manual mendorongnya ke produksi, yang harus saya lakukan adalah menyinkronkan dari sistem kontrol versi ke server produksi, dan kemudian sistem produksi itu sendiri membangun, menginstal, dan menjalankan deployable (dan melakukannya dengan cara yang identik dengan bagaimana hal itu dilakukan pada sistem pengembangan apa pun, meminimalkan kemungkinan kesalahan spesifik platform atau kesalahan konfigurasi). Dan apakah dalam lingkungan pengembangan atau produksi, yang saya lakukan untuk membangun dan memulai server adalah:

./startServer.sh #or startServer.bat for Windows

Dan untuk menyebarkan pembaruan ke lingkungan produksi prosesnya hanya:

1. Hentikan instance server yang berjalan, jika ada.
2. Lari svn update -r<target_release_revision>.
3. Lari ./startServer.sh.

Ini sederhana, mudah diingat, dan sama sekali tidak mungkin dilakukan jika saya mengandalkan penggunaan IDE saya untuk membangun yang dapat digunakan untuk saya. Hal ini juga membuat kembali ke penyebaran baik terakhir yang diketahui, jika harus dilakukan rollback.

Saya bahkan tidak dapat menghitung jumlah waktu yang digunakan oleh pendekatan ini untuk mencoba mengelola proses konfigurasi dan penyebaran secara manual.

Dan tentu saja, jawaban lain untuk pertanyaan Anda adalah manajemen ketergantungan otomatis, tapi saya yakin itu sudah dibahas oleh jawaban lain.

Selama kode Anda ada dalam kontrol sumber, gunakan IDE untuk membuat barang yang dapat didistribusikan Anda baik-baik saja.

Sebagai satu toko, apakah waktu Anda dihabiskan dengan menambahkan fitur baru ke produk Anda, atau menulis skrip pembuatan? Sesuatu mengatakan kepada saya itu tidak menulis skrip build.

Tentu, lebih sulit untuk melihat manfaatnya ketika Anda bekerja sendirian. Secara pribadi, saya telah bekerja pada banyak proyek solo dan tidak hanya saya akan menulis skrip build, saya juga mengalami kesulitan dalam menyiapkan Server CI (seperti Jenkins).

Ada overhead tentu saja, mengapa itu sepadan?

• Bangunan yang dapat direproduksi, tidak terikat dengan IDE (atau mesin Anda, jika Anda menjalankannya secara eksternal). Jika server build menjalankannya, mesin lain dapat menjalankannya.
• Kegembiraan dimulai setelah pengujian gedung dan unit (omong-omong: apakah Anda yakin Anda menguji sebelum setiap komit? Kadang-kadang saya lupa). Hasilkan dokumentasi, bangun installer, jalankan alat analisis kode favorit Anda.
• Server CI favorit Anda memungkinkan Anda melihat grafik cakupan kode, kegagalan uji unit, dll. Dari waktu ke waktu. Apakah IDE Anda melakukan itu?

Untuk proyek saya saat ini, skrip membangun, menjalankan alat analisis statis, kompres js / css, tes unit, dan paket ke dalam arsip web. Jenkins menjalankannya setelah setiap komit dan menyebarkan proyek ke server uji.

Saya mengambil waktu untuk mengatur ini (skrip build mungkin 300 baris, belum menyentuhnya dalam beberapa bulan) dan dapat mengatakan itu layak, bahkan untuk satu orang. Untuk lebih dari satu orang, itu perlu. Keterlibatan saya dalam proses build / deployment terdiri dari perintah "hg commit" dan "hg push."

Manfaat Alat Bangun

Ini adalah ringkasan singkat yang menunjukkan puncak gunung es, dan Anda tidak akan selalu memperhatikan pentingnya semua ini kecuali Anda perlu melakukan kombinasi dari banyak proyek, proyek besar dan tim menengah hingga besar. Tetapi jika Anda memiliki iman dan mencoba, Anda akan menuai manfaatnya .

Mereka memfasilitasi siklus pengembangan Anda dan karena memungkinkan Anda untuk:

• mengatur dan menyusun proyek Anda secara konsisten dan mudah
• gunakan kembali praktik-praktik baik di seluruh proyek dan mulailah dengan mudah dan cepat ,
• mengintegrasikan beberapa proyek dalam satu bangunan,
• mengotomatiskan proses integrasi berkelanjutan Anda ,
• bagikan proyek Anda dengan orang lain
  • tanpa memaksakan mereka untuk menggunakan toolkit atau IDE tertentu (terlepas dari sistem build),
  • dan tanpa mengejutkan mereka karena mereka akan mengharapkan bangunan standar
• mengotomatisasi dan memfasilitasi para pemeliharaan produk Anda
• mengotomatiskan proses rilis produk Anda

Jika Kami Terapkan ini ke Maven ...

Bagi Anda di dunia Jawa dan yang menggunakan Maven , dengan membaca ini, Anda secara alami menghubungkan setiap poin dengan:

• Konvensi proyek terstruktur Maven
• Arketipe Maven
• Mewujudkan proyek dari SCM dan pembangunan reaktor
• Jenkins / Hudson / Bamboo / dukungan lain + dukungan Maven untuk praktik pengujian integrasi
• m2eclipse, dukungan IntelliJ atau NetBeans asli - atau mvnsh untuk baris perintah
• versi-maven-plugin
• maven-release-plugin, plugin buildnumber-maven-plugin dan versi-maven-plugin

Dan tentu saja, Maven (tetapi alat-alat lain juga) memberi Anda manajemen ketergantungan , dan itu adalah penghemat waktu dan ruang yang sangat besar untuk Anda (diperhitungkan dengan jumlah orang dalam tim Anda) dan SCM Anda.

Semuanya relatif:

Saya menggunakan Maven sebagai contoh karena saya pikir itu adalah sistem build yang paling komprehensif dan "termasuk baterai", tetapi itu tidak berarti itu selalu yang terbaik. Itu cocok dengan semua kotak centang yang tercantum di atas, dan ketika mencari sistem build yang bagus, saya membandingkannya dengan daftar ini dan Maven. Namun, Maven tidak selalu sangat fleksibel - namun sangat fleksibel - jika Anda menyimpang dari proses standar Anda. Ini meningkatkan produktivitas Anda dalam kasus umum (sekali di depan kurva belajar), tidak jika Anda melawannya.

Berikut 4 alasan utama saya untuk menggunakan alat bangun:

• penanganan ketergantungan (menghindari kesalahan)
• pengujian (perubahan Anda tidak merusak modul lain - lebih mudah untuk diuji)
• komitmen aman
• lebih mudah untuk menyebarkan distribusi lokal (tidak ada yang punya waktu di QA env untuk menunggu pembangun untuk membangun proyek Anda dan dependensinya)

Dalam buku Pragmatic Programmer , Andrew Hunt dan David Thomas mengatakan bahwa 'checkout-build-test-deploy' harus menjadi perintah tunggal (Bab: Proyek Pragmatis). Kau menulis..

Saya bahkan punya calon investor yang mengantre dan berencana untuk menunjukkan kepada mereka versi beta dalam beberapa minggu ke depan

Kemudian, saya yakin tim Anda akan tumbuh .. Bahkan lebih penting untuk memiliki kemampuan uji-penyebaran otomatis dilakukan.

XML (skrip) besar yang Anda lihat, biasanya merupakan pekerjaan satu kali. Sebagian besar waktu, skrip yang sama dapat digunakan di banyak proyek.

Tidak jelas seberapa besar proyek tersebut. Jika tes terintegrasi / tes penerimaan Anda membutuhkan CPU / memori besar, Anda dapat mempertimbangkan menggunakan mesin lain sebagai server pengujian Anda. Anda juga dapat menggunakan sejumlah alat untuk menganalisis kode sumber / kode byte .

Saya berpendapat bahwa, untuk pengembang tunggal, memiliki proses dan struktur yang baik seperti pembuatan skrip jauh lebih penting daripada ketika Anda berada dalam tim. Alasannya adalah Anda tidak memiliki rekan tim untuk memanggil Anda keluar ketika Anda mengambil jalan pintas. Server CI yang menjalankan skrip build Anda menjadikan rekan setim yang hebat tanpa kompromi untuk membuat Anda jujur.

Saat basis kode Anda bertambah, Anda akan ingin menambahkan paket uji. Pengalaman saya adalah bahwa ini harus dilakukan lebih cepat daripada nanti, dan bahwa bangunan malam Anda (atau apa pun) harus menjalankan semua tes setiap waktu. Mulai dari yang kecil, XML yang dibuat secara otomatis mungkin baik-baik saja. Ketika Anda takut untuk mengubah sesuatu karena takut merusak sesuatu yang lain, itu adalah insentif yang baik untuk menulis beberapa test case.

Build non-IDE memudahkan untuk membangun kembali versi lama tanpa khawatir tentang mengkonfigurasi ulang IDE Anda seperti saat itu, memungkinkan Anda melakukan build secara non-interaktif sehingga Anda dapat mempertahankan build malam untuk diuji orang, atau mencari tahu dengan cepat jika Anda memecahkan tes tanpa harus ingat untuk menjalankannya dan menunggu sampai selesai.

Ini juga memungkinkan Anda melakukan pembangunan di lingkungan non-GUI, mis. Ssh'ing ke server, dan memungkinkan Anda untuk beralih IDE tanpa khawatir kehilangan kemampuan untuk membangun perangkat lunak Anda.

Beberapa alat pembuatan membantu Anda untuk mengotomatiskan pemberian tag dan menyebarkan rilis, datang dengan standar yang layak untuk menghasilkan laporan cakupan kode, dll.

Saat Anda menambahkan lebih banyak orang, alat build akan memastikan Anda tidak rentan terhadap konfigurasi IDE orang lain yang buruk. Saya secara teratur melakukan berbagi layar untuk memperbaiki instalasi Eclipse rekan karena mereka tidak menggunakan alat bangun (mengerjakannya).

Namun alasan utamanya adalah itu adalah sesuatu yang tidak perlu dilakukan secara manual, jadi jangan lakukan secara manual. Segala sesuatu yang lain jatuh dari itu.