Belajar C++ - Tooling Modern & Build Automation

#Pendahuluan

Kode yang hebat tidak berarti apa-apa tanpa proses yang menjaganya tetap berkualitas. Di proyek nyata, kalian tidak menunggu manusia untuk memeriksa semua hal — tooling mengambil alih: CMake membangun dengan benar di semua platform, CI menjalankan tes dan analisis otomatis, formatter menjaga konsistensi, dan dependency management menjaga build tetap dapat direproduksi.

Episode 19 membahas tooling modern: workflow CMake yang benar, pipeline continuous integration dengan GitHub Actions dan GitLab CI, clang-format dan clang-tidy untuk konsistensi kode, serta reproducible builds dan pengelolaan dependency.

#Workflow CMake Modern

#Struktur CMake yang Benar

CMake modern tidak lagi memakai variabel global. Setiap target mendeklarasikan kebutuhan sendiri dengan target_compile_features dan target_link_libraries. Pendekatan berbasis target ini membuat dependency tersampaikan secara transparan:

cat > CMakeLists.txt <<'EOF'
cmake_minimum_required(VERSION 3.20)
project(workspace LANGUAGES CXX)
 
add_library(utilitas STATIC util.cpp)
target_compile_features(utilitas PUBLIC cxx_std_20)
target_include_directories(utilitas PUBLIC .)
 
add_executable(app main.cpp)
target_link_libraries(app PRIVATE utilitas)
EOF
cmake -S . -B build -G Ninja
cmake --build build
ctest --test-dir build

cmake -S . -B build -G Ninja mengkonfigurasi proyek dengan generator Ninja yang lebih cepat dari Make. target_compile_features(utilitas PUBLIC cxx_std_20) menetapkan C++20 untuk library dan semua yang me-nya-link. ctest --test-dir build menjalankan tes terdaftar.

#Preset dan Mode Build

Gunakan CMake presets untuk membakukan cara build tim. Preset mendefinisikan konfigurasi debug dan release dalam satu file CMakePresets.json, sehingga semua orang memakai perintah yang sama — tanpa menghafal bendera:

{
  "version": 3,
  "configurePresets": [
    {
      "name": "debug",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build/debug",
      "cacheVariables": {
        "CMAKE_BUILD_TYPE": "Debug",
        "CMAKE_CXX_FLAGS": "-fsanitize=address"
      }
    }
  ]
}

Preset debug di atas mengaktifkan AddressSanitizer secara otomatis. Pemanggilan cmake --preset debug lalu cmake --build --preset debug menghasilkan build yang konsisten untuk semua anggota tim.

#Continuous Integration

#Pipeline GitHub Actions

CI menjalankan build, tes, dan analisis di server setiap kali ada perubahan. Pipeline GitHub Actions untuk C++ biasanya memakai matriks compiler dan sistem operasi:

name: cpp-ci
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: sudo apt install -y ninja-build
      - run: cmake -S . -B build -G Ninja
      - run: cmake --build build
      - run: ctest --test-dir build --output-on-failure

cmake --build build membangun proyek di CI, dan ctest --test-dir build --output-on-failure menjalankan tes dengan laporan kegagalan. Pipeline berjalan untuk setiap push dan pull request, menangkap regresi sebelum menggabungkan kode.

#GitLab CI

GitLab CI memakai .gitlab-ci.yml dengan konsep stages yang serupa. Kunci keberhasilan di keduanya: build dan tes harus berjalan tanpa interaksi manual, dan artefak build sebaiknya diupload agar bisa diunduh untuk dianalisis lebih lanjut.

#Formatting dan Linting

#clang-format untuk Konsistensi

clang-format memformat kode secara otomatis mengikuti aturan yang ditetapkan dalam .clang-format. Setiap anggota tim memakai format identik, sehingga diff menjadi bersih dan review fokus pada logika, bukan perbedaan spasi:

clang-format -i main.cpp util.cpp
clang-tidy main.cpp -- -std=c++20
cppcheck --enable=all main.cpp

clang-format -i menulis ulang file sesuai konfigurasi. clang-tidy dan cppcheck — yang sudah dibahas di episode 11 — mendeteksi bug dan masalah gaya. Aturan umum untuk konfigurasi formatter: kunci file .clang-format agar semua orang memakai yang sama.

#Memeriksa Format di CI

Format yang tidak konsisten bisa menghentikan merge. Tambahkan langkah CI yang memeriksa apakah kode sudah diformat:

clang-format --dry-run --Werror main.cpp

clang-format --dry-run --Werror hanya melaporkan file yang tidak sesuai format tanpa mengubahnya, dan mengembalikan kode error. Pipeline menolak perubahan yang belum diformat — ini menjaga konsistensi tanpa bergantung pada disiplin individu.

#Reproducible Builds dan Dependency Management

#Membangun Ulang yang Identik

Reproducible build berarti dua build dari kode yang sama menghasilkan biner yang identik. Faktor yang merusak reproducibility: timestamp build, jalur absolut, dan variasi lingkungan. CMake membantu lewat CMAKE_CXX_FLAGS yang ditetapkan dan sumber yang disimpan bersama:

cmake -S . -B build -DCMAKE_BUILD_TYPE=Release \
    -DCMAKE_CXX_FLAGS="-std=c++20 -O2 -ffile-prefix-map=$PWD=."
cmake --build build

-ffile-prefix-map=$PWD=. mengganti jalur absolut di metadata dengan relatif, menghilangkan satu sumber ketidak-konsistenan. Untuk alasan serupa, CI sebaiknya memakai image container yang dijaga versinya.

#Dependency Management

Mengelola dependency C++ tidak semudah bahasa lain. Vendor dengan git submodules atau FetchContent untuk dependency kecil, dan paket manager seperti vcpkg atau Conan untuk dependency besar. FetchContent memungkinkan menaruh dependency langsung di CMakeLists:

include(FetchContent)
FetchContent_Declare(json
  GIT_REPOSITORY https://github.com/nlohmann/json
  GIT_TAG v3.11.3)
FetchContent_MakeAvailable(json)

FetchContent_MakeAvailable(json) mengunduh dan membangun library JSON nlohmann pada versi tetap v3.11.3. Mengunci versi (bukan branch) adalah syarat build yang dapat direproduksi.

#Penutup

Inti yang harus dibawa pulang:

• CMake modern berbasis target: target_compile_features dan target_link_libraries.
• Preset membakukan konfigurasi build untuk seluruh tim.
• GitHub Actions dan GitLab CI menjalankan build dan tes otomatis.
• clang-format menjaga konsistensi; periksa format di CI.
• Reproducible build menghindari timestamp dan jalur absolut.
• Vcpkg, Conan, dan FetchContent mengelola dependency dengan versi terkunci.

Di episode 20 selanjutnya kita akan membahas cross-platform development — menulis kode portabel untuk Windows, Linux, dan macOS, abstraksi platform-specific dan conditional compilation, cross-compilation untuk target arsitektur berbeda, serta portabilitas library dan dependency yang vendor-neutral.