Ubiquitous Language

The domain model, the code, and the people should use Ubiquitous Language

Ubiquitous language adalah salah satu istilah lagi yang terkesan sangat keren dalam dunia software developement. Khususnya karena berasal dari Dunia Domain Driven Design (DDD) maka sering kali hanya di kenal dan di gunakan oleh solusi arsitek dan para sofware developer tidak pernah mengetahuinya.

Menurut saya hal ini sangat di sayangkan, karena Ubiquitous languange ini kalau di beberapa organisas dari negara maju sudah di pakai di setiap tempat dan di setip individu yang terlibat dalam pembuatan software. Saya percaya ubiquuitous language ini akan sangat bermanfaat dan berguna apabila di fahami dan gunakan oleh organisasi-organisasi atau perushaan yang terlibat dalam proses pembuatan sebuah software.

Apa Itu Ubiquitous Language

Ubiquitous Language sebenarnya merupakan konsep dan sekaligus praktek terbaik dalam mendesign software berbaasis domain yang mendorong penggunaan sebuat bahasa yang umum dan di gunakan bersama-sama di berbagai tempat dan orang.

Bahasa ini harus di gunakan di semua komunikasi baik itu tertulis atau langsung antara tim developer dan tim domain expert (tim produk atau tim bisnis). Hal ini dilakukan untuk memastikan agar komunikasi yang terjadi berjalan dengan baik, benar , dan lancar di sepanjang proses development khusus nya dan setelah proses development.

Bahasa ini harus selalu di lakukan secara konsisten di semua bagian , mulai dari semua document yang di perkukan seperti FSD, PRD, TRD di dalam code kita, dan di semua komunikasi internal dan ekternal agar bisa menjaga dari kebingunngan, salah pemahaman dan translasi yang salah tidak terjadi.

Kenapa Ini Berguna?

Kita semua tahu bahwa sebuah perangkat lunak dibangun atas kerjasama banyak orang. Manusia memerlukan komunikasi, dan jika kita memiliki teknik yang dapat mengurangi tingkat kesalahpahaman serta menurunkan tingkat ambigu, maka akan meningkatkan pemahaman dalam domain bisnis bagi seorang pengembang perangkat lunak, dan meningkatkan pemahaman tentang perangkat lunak bagi seorang ahli dalam domain tersebut.

Penggunaan bahasa yang umum digunakan (ubiquitous language) akan membantu mengurangi jumlah bug dan mempercepat proses pembuatan perangkat lunak secara tidak langsung. Yang terakhir, tentu saja, akan mengarah pada pembuatan sebuah perangkat lunak yang memiliki kualitas baik.

Percakapan antar tim product dan developer yang tidak menggunakan bahasa yang sama

Dari percakapan antar tim product dan tim developer terlihat bahwa developer tidak menggunakan bahasa atau istilah yang sama. Jika kita onboarding seorang developer baru ke dalam tim dan mengerjakana tau melanjutkan apa yang telah di buat oleh developer selanjutnya maka bisa kita prediksi akan terdapat banyak bug karena developer baru ini kehilangan context dan pemahaman yang sama dengan yang di mau oleh tim product.

Ubiquitous Language penting karena akan mengurangi masalah translasi atau terjemah. Proses translasi ini tidak akurat karena sering kehilangan informasi penting ketika berpindah dari satu orang ke orang lain , berpindah dari dokumentasi ke code, dan di dalam kode juga karena memiliki layer akan berpotensi tiap layer akan menterjemahkan dengan maksud yang beda.

Bagaimana Memulainya

Untuk memulai best praktis dari ubiquitous language ini berikut terdapat lima langkah yang dapat digunakan oleh kita untuk memulai menerapkan teknin ubiquitous ini.

1. Buatlah sebuah glosary atau daftar istilah yang di sepakati dan di buat bersama -sama antara domain expert dan developer
2. Jadikan Glosary ini adalah kitab suci bagi kedua belah pihak. Gunakan dan pertahankan terus di semua dokumen yang ada. Gunakan notion, confluence, dan centralize doc lainnya.
3. Gunakan tool seperti contextive pada IDE code anda. Membawa clossary tadi kedalam lingkungan code dengan mudah. https://github.com/dev-cycles/contextive
4. Buat dan tingkatkan Akuntability dari tim
5. Mulailah refactoring nama, istilah , dan semua hal pada code Anda agar sesuai dengan Glosary yang telah di buat.

Contoh Code Menerapkan Ubiquiotous Languange

public class ShoppingCart {
    private List<Item> items = new ArrayList<>();

    public void addItem(Item item) {
        items.add(item);
    }

    public void removeItem(Item item) {
        items.remove(item);
    }

    public double calculateTotal() {
        double total = 0.0;
        for (Item item : items) {
            total += item.getPrice();
        }
        return total;
    }
}

public class Item {
    private String name;
    private double price;

    public Item(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        Item item1 = new Item("Mouse", 15.99);
        Item item2 = new Item("Keyboard", 29.99);

        cart.addItem(item1);
        cart.addItem(item2);

        System.out.println("Total: $" + cart.calculateTotal());
    }
}

Dalam contoh ini, kita memiliki kelas ShoppingCart yang berisi item-item yang dibeli dan dapat menghitung total belanjaan. Kelas Item mewakili barang yang dapat dibeli dan memiliki nama dan harga. Dengan menggunakan istilah yang sama di kode dan dalam domain permasalahan yang diperlukan, kita dapat membuat kode yang lebih mudah dimengerti dan di-maintain.

Code Tidak Menerapkan Ubiquiotous Languange

public class Cart {
    private List<Product> items = new ArrayList<>();

    public void addProduct(Product product) {
        items.add(product);
    }

    public void removeProduct(Product product) {
        items.remove(product);
    }

    public double calculateTotal() {
        double total = 0.0;
        for (Product product : items) {
            total += product.getPrice();
        }
        return total;
    }
}

public class Product {
    private String productName;
    private double productPrice;

    public Product(String productName, double productPrice) {
        this.productName = productName;
        this.productPrice = productPrice;
    }

    public String getProductName() {
        return productName;
    }

    public double getProductPrice() {
        return productPrice;
    }
}

public class Main {
    public static void main(String[] args) {
        Cart cart = new Cart();

        Product product1 = new Product("Mouse", 15.99);
        Product product2 = new Product("Keyboard", 29.99);

        cart.addProduct(product1);
        cart.addProduct(product2);

        System.out.println("Total: $" + cart.calculateTotal());
    }
}

Dalam contoh ini, saya mengubah istilah ShoppingCart menjadi Cart, Item menjadi Product, dan calculateTotal() menjadi calculateTotalPrice(). Meskipun kode ini masih berfungsi dengan baik, namun tidak menggunakan istilah yang konsisten dengan domain permasalahan yang diberikan.

Video yang menjelaskan Lebih Menarik dan Detil mengenai Ubiquitos Language ini bisa di lihat disini.