Framework Prabogo: Kenalin Nih, Framework Baru Dari Golang!

28 September 2025

Framework Prabogo: Kenalin Nih, Framework Baru Dari Golang!

Prabogo hadir sebagai solusi baru bagi para developer bahasa Go. Framework Prabogo memperkenalkan konsep modern seperti antarmuka perintah interaktif dan dukungan AI bawaan untuk membantu menyederhanakan berbagai tugas pengembangan proyek. Sebagai framework serba guna, Prabogo mengambil pendekatan arsitektur heksagonal untuk memisahkan logika bisnis dari detail teknis seperti database atau framework web. Dengan fitur semacam ini, pengembang dapat lebih fokus pada logika utama aplikasi, bukan menulis ulang kode infrastruktur.

Pada dasarnya, Go dibuat agar sederhana dan ringan. Namun ketika aplikasi berkembang kompleks, pengembang sering terjebak menulis kode berulang (setup server, koneksi database, dsb). Prabogo hadir menutup celah ini dengan menyediakan lapisan tambahan tanpa membuat aplikasi jadi berat. Anda tetap dapat menulis idiom Go murni, namun Prabogo memberikan shortcut melalui perintah CLI untuk banyak pekerjaan rutin.

Kenapa perlu Prabogo? Golang memang terkenal sederhana dan cepat, namun sering kali developer perlu membangun sendiri bagian-bagian infrastruktur (seperti koneksi database, routing, atau sistem pesan) secara manual. Prabogo hadir untuk merampingkan proses tersebut. Misalnya, framework ini menyediakan built-in AI assistance — instruksi atau saran AI langsung dari CLI — sehingga Anda bisa mendapatkan bantuan cerdas saat menulis kode atau dokumentasi. Selain itu, kerangka proyek (project structure) biasanya sudah lengkap, jadi Anda dapat langsung membuat fitur baru tanpa menghabiskan waktu membuat folder atau file dasar.

Selain itu, Prabogo sangat cocok untuk tim besar atau aplikasi skala enterprise. Bagi pengembang yang ingin tetap menulis kode Go idiomatis, Prabogo juga fleksibel. Anda bebas menulis implementasi sesuai keinginan, sementara Prabogo menangani struktur dan kontrak kode. Ini berarti pola-pola yang umum (seperti entitas domain, adaptor database, handler HTTP) sudah tersedia, tapi kode bisnis Anda tetap “murni” Go.

Fitur Utama Prabogo

Berikut beberapa fitur unggulan Prabogo yang sering menjadi topik pembicaraan di komunitas Golang:

Arsitektur Hexagonal: Memisahkan logika bisnis dari dependensi eksternal (database, pesan, web framework) sehingga kode lebih bersih. Desain ini memudahkan Anda menukar komponen (misal database) tanpa merusak logika inti aplikasi.
Komponen Plug-and-Play: Memungkinkan pergantian cepat komponen infrastruktur (misalnya database atau message broker) dengan perubahan kode minimal. Ingin mengganti MySQL ke PostgreSQL atau RabbitMQ ke Kafka? Cukup implementasi adapter yang berbeda, sisanya tetap berjalan.
Perintah Interaktif (CLI): Tersedia antarmuka baris perintah interaktif yang memandu proses scaffolding dan pengembangan. Misalnya, make run menampilkan menu pilihan tugas seperti membuat model, migrasi, atau menjalankan server HTTP secara grafis. Dukungan fzf semakin memudahkan pencarian opsi.
Komponen Dekoupled: Desain Prabogo menjaga logika bisnis tetap independen dari detail teknis eksternal. Strategi ini membuat penulisan test menjadi lebih mudah karena Anda bisa memfokuskan test hanya pada logika domain, lalu menggunakan mock untuk komponen luar.
Dokumentasi & Pedoman Bawaan: Prabogo menyediakan dokumentasi komprehensif dan pedoman desain langsung dalam proyek. Hal ini mempermudah tim menjaga konsistensi arsitektur dan mengikuti pola yang sudah ditetapkan.
Generasi Kode Otomatis: Perintah make sederhana dapat menghasilkan boilerplate untuk model, migrasi, adapter, dan mock secara otomatis. Ini menghemat waktu, karena Anda tidak perlu menulis ulang kode rutinitas.
AI Bawaan: Prabogo menyediakan instruksi bantuan AI langsung dalam CLI untuk mempercepat pengembangan dan dokumentasi proyek. Sistem ini dapat menyarankan struktur kode atau memberikan saran otomatis, misalnya membantu menentukan skema database atau cara menulis handler tertentu dengan lebih cepat dan akurat.

Penjelasan Fitur

Arsitektur heksagonal Prabogo mengatur program ke dalam lapisan domain dan lapisan antarmuka. Lapisan domain hanya berisi aturan bisnis (misalnya entitas dan service), sedangkan lapisan antarmuka (port/adapters) menangani komunikasi dengan dunia luar. Contohnya, port dapat berupa interface penyimpanan data, sementara adapter-nya bisa implementasi PostgreSQL atau Redis. Karena itu, bila Anda ingin mengganti jenis database, cukup membuat adapter baru tanpa menyentuh logika bisnis. Prabogo memastikan domain Anda tetap fokus pada fungsionalitas inti dan tidak terjebak detail teknis.

Fitur plug-and-play sangat membantu ketika tim memutuskan mengganti teknologi tertentu. Daripada mengubah puluhan baris kode, cukup tulis adapter baru. Sederhananya, Prabogo mengurus integrasi: Anda cukup fokus definisi model di domain, sedangkan Prabogo otomatis membuat kerangka untuk menghubungkan ke teknologi pilihan. Misalnya, jika ingin menambahkan cache Redis, jalankan make outbound-cache-redis VAL=order, Prabogo langsung membuat file adapter Redis yang sesuai.

Pada sisi developer experience, perintah interaktif membuat kegiatan sehari-hari lebih menarik dan mudah. Ketimbang mengetik make model VAL=nama secara penuh, Anda bisa memilih dari menu yang tampil. Jika sudah memakai fzf, Anda cukup mulai mengetik nama perintah dan hasilnya langsung muncul. Fitur ini menghemat waktu dan mengurangi risiko salah ketik. Bahkan, setelah perintah dijalankan, Prabogo menampilkan status atau pesan keberhasilan secara jelas di terminal, sehingga Anda langsung tahu file apa saja yang dibuat.

Terakhir, dokumentasi bawaan dan generasi kode adalah pemenang utama untuk produktivitas. Begitu membuat proyek baru, struktur direktori sudah siap. Saat membuat fitur baru, kode-kode standar langsung tersedia lewat perintah make. Dengan begitu, developer lebih banyak menulis logika custom, bukan menulis ulang struktur boilerplate. Begitu pula, banyak tugas rutin seperti pembuatan handler HTTP atau migrasi database di-cover otomatis. Ini menjadi alasan utama banyak orang menyukai Prabogo: sangat mempercepat kickstart proyek baru.

Cara Memulai dengan Prabogo

Untuk memulai proyek baru dengan Prabogo, ikuti langkah-langkah berikut:

Persiapkan Lingkungan: Pastikan Go sudah terinstal (versi minimal 1.23.0) serta Docker/Docker Compose tersedia jika diperlukan. Opsional, instal tool fzf untuk antarmuka interaktif yang lebih baik.
Instal Prabogo Installer: Jalankan go install github.com/prabogo/prabogo-install@latest. Perintah ini akan mengunduh dan memasang alat prabogo-install, yang berguna membuat kerangka proyek.
Buat Proyek Baru: Setelah terinstal, buat proyek baru dengan prabogo-install nama-proyek. Prabogo akan membuat direktori dan file dasar (seperti cmd/, internal/, model/, dll). Berkat ini, struktur awal sudah siap tanpa Anda membuatnya satu per satu.
Siapkan Variabel Lingkungan: Masuk ke direktori proyek (cd nama-proyek), duplikat file .env.example menjadi .env, lalu jalankan go mod tidy. Jangan lupa isi file .env sesuai kebutuhan (misal konfigurasi koneksi database, PORT, dsb). Setelah itu, jalankan docker-compose up -d untuk menyalakan layanan pendukung seperti database atau message broker (jika ada).

5.** Jalankan Aplikasi**: Gunakan make run untuk memulai antarmuka interaktif. Anda bisa memilih mode yang diinginkan, misal menjalankan HTTP server (make http), consumer pesan (make message SUB=nama_subscriber), atau menjalankan perintah tertentu (make command CMD=nama_command VAL=nilai). Perintah go run cmd/main.go http juga tersedia untuk menjalankan langsung mode HTTP.

Dengan mengikuti langkah-langkah di atas, Anda akan memiliki proyek Prabogo siap pakai. Misalnya, setelah membuat proyek, Anda langsung melihat folder seperti cmd/, internal/domain, model/, adapter/, dll. Kini Anda tinggal menulis fitur di lokasi yang tepat tanpa harus repot menyiapkan fondasi lagi.

Arsitektur Hexagonal di Prabogo

Prabogo menekankan pola Hexagonal Architecture (Ports & Adapters) untuk menjaga kode tetap terorganisir. Ide utamanya adalah memisahkan intinya (domain) dari luarnya. Secara umum, komponen arsitektur ini meliputi:

Port: Interface yang mendefinisikan cara komunikasi antar komponen. Contoh: interface untuk menyimpan data produk.
Adapter: Implementasi dari port yang menghubungkan ke sistem eksternal. Contoh: adapter PostgreSQL yang mengimplementasikan port penyimpanan data.
Domain: Lapisan terpenting yang berisi logika bisnis dan model entitas. Lapisan ini tidak mengandung kode spesifik teknologi apa pun.
Application: Lapisan penghubung yang mengatur alur kerja, validasi data, dan penggunaan domain untuk menangani permintaan.

Pendekatan ini memiliki beberapa keuntungan:

Penggantian Mudah: Anda bisa mengganti komponen infrastruktur (misal database) dengan sedikit perubahan. Cukup ganti adapter, tanpa mengubah domain.
Pengujian Terpisah: Logika bisnis dapat diuji dalam isolasi penuh. Karena domain tidak tergantung komponen luar, Anda cukup memberikan mock pada port untuk test.
Pengembangan Paralel: Tim dapat bekerja pada fitur baru tanpa khawatir detail infrastruktur. Misalnya, frontend/backend dapat dikembangkan secara terpisah selama kontrak port tersusun.
Separation of Concerns: Kode menjadi terstruktur: domain fokus aturan bisnis, adapter fokus integrasi teknis. Hal ini menjaga kode tetap bersih dan mudah dipelihara.

Dengan Hexagonal Architecture, Prabogo memastikan aplikasi Anda scalable dan mudah di-maintain seiring waktu. Pindah ke teknologi baru atau melakukan testing regresi jadi tidak mengganggu logika utama karena sudah dipisahkan dengan jelas.

Perintah (make) dan Generasi Kode Otomatis

Prabogo menyediakan berbagai perintah make untuk mengotomatisasi tugas pengembangan. Ini membantu Anda tidak perlu menulis kode boilerplate manual setiap kali. Berikut beberapa perintah penting (diakses melalui Makefile):

make model VAL=nama: Membuat struktur model/entitas baru (misal folder model/nama dan file domain).
make migration-postgres VAL=nama: Menghasilkan file migrasi database PostgreSQL untuk entitas nama.
make inbound-http-fiber VAL=nama: Membuat handler HTTP menggunakan framework Fiber untuk entitas nama.
make inbound-message-rabbitmq VAL=nama: Membuat konsumer pesan RabbitMQ untuk entitas nama.
make inbound-command VAL=nama: Membuat handler baris perintah (CLI) untuk entitas nama.
make outbound-database-postgres VAL=nama: Menghasilkan adapter database PostgreSQL untuk entitas nama.
make outbound-http VAL=nama: Menghasilkan adapter HTTP client untuk nama.
make outbound-message-rabbitmq VAL=nama: Menghasilkan adapter RabbitMQ untuk nama.
make outbound-cache-redis VAL=nama: Menghasilkan adapter Redis untuk entitas nama.
make generate-mocks: Membuat mock dari directive go:generate pada file registry, berguna untuk testing.

Selain itu, ada perintah runtime yang sering dipakai:

make build: Membangun image Docker dari aplikasi.

make http: Menjalankan aplikasi dalam mode server HTTP (dalam container).
make message SUB=nama_subscriber: Menjalankan mode konsumen pesan di dalam container.
make command CMD=perintah VAL=nilai: Menjalankan perintah spesifik di dalam aplikasi.

Semua perintah ini tersentral di Makefile sehingga pengembangan menjadi konsisten. Misalnya, saat menambahkan model baru, Anda cukup menjalankan make model. Kode interface (port) dan kerangka adapter (database) langsung dibuat. Ini memastikan setiap bagian mengikuti standar arsitektur yang konsisten.

Sebagai contoh konkret, bila Anda menjalankan perintah di atas:

make model VAL=product  
make migration-postgres VAL=product  
make outbound-database-postgres VAL=product

Prabogo akan membuat folder internal/domain/product beserta struktur dasarnya, file internal/adapter/postgres/product_postgres.go, dan file migrasi SQL yang sudah berisi kerangka tabel products. Anda tinggal mengisi detailnya.

Alur Pengembangan (Development Workflow)

Dokumentasi Prabogo merekomendasikan alur kerja terstruktur untuk membangun aplikasi. Berikut ringkasan langkah-langkah umum:

Create Models (Buat Model): Buat entitas domain yang merepresentasikan konsep bisnis, misal product, order, atau customer. Perintah: make model VAL=product.
Create Migrations (Buat Migrasi): Setelah model siap, definisikan skema database melalui migrasi. Perintah: make migration-postgres VAL=product.
Implement Domain Logic (Logika Domain): Tulis logika bisnis inti di folder domain. Misalnya, di internal/domain/product tambahkan validasi, kalkulasi harga, atau aturan diskon. Pastikan logika ini bersifat pure (tanpa dependensi luar), sehingga mudah diuji.
Create Inbound Adapters (Adapter Masuk): Buat adapter untuk input eksternal. Contoh:

Endpoint HTTP (Fiber) untuk entitas, dengan make inbound-http-fiber VAL=product.
Konsumen pesan (RabbitMQ), dengan make inbound-message-rabbitmq VAL=order.
Handler CLI, dengan make inbound-command VAL=product.

Create Outbound Adapters (Adapter Keluar): Buat adapter untuk akses eksternal:

Database (Postgres) via make outbound-database-postgres VAL=product.
HTTP client via make outbound-http VAL=payment_api.
Cache Redis via make outbound-cache-redis VAL=product.

Write Tests (Tulis Test): Tulis unit test untuk logika domain. Buat mock dengan make generate-mocks dan lalu jalankan go test -cover ./internal/domain/... untuk mengecek cakupan tes.
Run the Application (Jalankan Aplikasi): Terakhir, jalankan aplikasi dengan make http untuk mode HTTP server atau mode lain sesuai kebutuhan.

Dengan alur ini, setiap aspek aplikasi terkelola dengan baik. Tim dapat bekerja paralel: satu tim menangani domain, tim lain adapter, tanpa sering konflik. Pengujian pun mudah karena isolasi antara domain dan adapter.

Prabogo juga menganut prinsip Domain-Driven Design (DDD): tiap fitur diwakili oleh model domain yang kuat, dengan batasan jelas. Anda didorong untuk membuat domain models, value objects, dan domain events untuk menyelesaikan masalah bisnis secara eksplisit. Dalam pengujian, Prabogo memudahkan menulis unit tests untuk semua logika domain karena struktur kode sudah terpisah. Cukup tambahkan mock saat mengetes fungsionalitas, logika utama Anda tetap terisolasi.

Deploy dan Infrastruktur

Proyek Prabogo sudah siap dikontainerisasi. Struktur Docker Compose sudah tersedia, sehingga proses deployment lebih mudah. Anda tinggal menjalankan make build untuk membuat image Docker aplikasi:

make build

Perintah ini membangun image yang kemudian dapat digunakan di berbagai lingkungan. Untuk development atau staging, mudah menjalankan segala layanan dengan Docker Compose. Cukup docker-compose up, dan database, cache, dll. langsung aktif.

Saat siap produksi, ada beberapa opsi:

Docker Compose: Cocok untuk lingkungan lokal dan proyek kecil. docker-compose up menjalankan semua service sekaligus.
Kubernetes: Untuk orkestrasi dan skalabilitas, deploy container di cluster. Buat Deployment/Service di Kubernetes menggunakan image yang dibangun.
Cloud (AWS/GCP/Azure): Anda dapat mengirim image ke container registry lalu deploy di layanan seperti AWS ECS, GCP Cloud Run, atau Azure Container Instances.

Karena arsitektur port-and-adapters, Prabogo juga mendukung desain microservices. Setiap layanan dapat dibuat dari template Prabogo yang sama. Dengan pola yang konsisten, tim dapat menjalankan beberapa service independen sambil tetap mengikuti arsitektur sama. Adapter terpisah memungkinkan tiap service berkomunikasi lewat pesan atau HTTP dengan mudah, sementara logika domain tetap terjaga.

Struktur direktori rekomendasi (sesuai dokumentasi) membantu proyek tetap terorganisir:

cmd/ – Entry point aplikasi (main.go untuk server HTTP, worker pesan, atau CLI).
internal/ – Kode internal aplikasi.
- domain/ – Logika bisnis inti (entitas, service).
- port/ – Definisi interface (port).
- adapter/ – Implementasi port (database, API eksternal, cache).
- model/ – Struktur data seperti DTO atau entity.
- migration/ – Skrip migrasi basis data.
utils/ – Fungsi bantu umum.
tests/ – Utility dan mock untuk testing.

Struktur ini memastikan setiap bagian kode ada di tempat yang tepat, memudahkan navigasi dan kolaborasi.

Code Generation dan Testing

Setelah menjalankan perintah make, banyak kode sudah terbuat otomatis. Dokumentasi Prabogo juga menjelaskan lebih lanjut cara kerja generator internal. Misalnya, kode generator akan membuat interface (port) di port/ dan menambahkan entry di registry agar adapter baru dikenali.

Karena desain modular, Anda dianjurkan menulis unit test sebanyak mungkin pada lapisan domain. Contoh perintah:

go test -cover ./internal/domain/...
go test -coverprofile=coverage.profile -cover ./internal/domain/...
go tool cover -html=coverage.profile -o coverage.html

Perintah tersebut menjalankan seluruh tes di domain dan menghasilkan laporan cakupan kode. Untuk menghindari flaky tests, gunakan make generate-mocks untuk membuat stub, sehingga tes hanya fokus pada logika bisnis.

Contoh Kasus: API E-Commerce

Sebagai contoh, bayangkan kita membuat API untuk aplikasi e-commerce (toko online) dengan Prabogo. Langkahnya adalah:

Buat Model Domain: Definisikan entitas seperti Produk dan Pelanggan. Contoh: jalankan make model VAL=product dan make model VAL=customer. Perintah ini membuat direktori internal/domain/product dan internal/domain/customer beserta struktur file dasarnya.
Buat Migrasi Database: Setelah model siap, buat skrip migrasi. Jalankan make migration-postgres VAL=product dan make migration-postgres VAL=customer. Prabogo akan menghasilkan file SQL migrasi di folder migration/.
Tulis Logika Domain: Isi aturan bisnis di internal/domain. Misalnya, pada product tambahkan fungsi validasi harga, atau perhitungan diskon. Semua logika ini berada di domain murni, bebas dari dependensi eksternal.
Buat Endpoint HTTP (Inbound): Buat handler untuk menangani permintaan klien. Misal, make inbound-http-fiber VAL=product akan membuat file handler HTTP dan route (misal /products) di Fiber. Lakukan juga make inbound-http-fiber VAL=customer untuk endpoint pelanggan.
Adapter Database (Outbound): Siapkan adapter untuk menyimpan data. Misalnya, jalankan make outbound-database-postgres VAL=product dan make outbound-database-postgres VAL=customer. Ini membuat kelas repository yang menghubungkan domain Product dan Customer ke database PostgreSQL.
Tuliskan Test: Setelah komponen siap, tulis unit test di folder internal/domain. Gunakan make generate-mocks untuk membuat mock. Anda dapat mengetes fungsi domain tanpa database nyata.
Jalankan Aplikasi: Terakhir, jalankan make http untuk mode server HTTP. Misalnya, akses http://localhost:8080/products dan http://localhost:8080/customers. Endpoint harus bisa menerima request GET/POST sesuai yang Anda buat.

Dengan alur ini, Anda dapat berkonsentrasi pada logika utama (misal bagaimana memproses order), sementara Prabogo menangani banyak pekerjaan rutin. Struktur folder dan kode boilerplate seperti handler dan adapter sudah langsung tersedia, mempercepat waktu development.

Perbandingan dengan Kerangka Kerja Go Lain

Di dunia Go ada banyak kerangka kerja populer. Misalnya, Gin sangat cepat (ideal untuk situs web bertrafik tinggi), sedangkan Echo mudah disesuaikan dengan banyak fitur (middleware, routing dinamis). Beego dan Buffalo menawarkan banyak alat bawaan sehingga mudah membangun aplikasi komprehensif tanpa konfigurasi rumit. Sementara itu, FastHTTP (bukan kerangka kerja penuh) berfokus pada kecepatan server HTTP tingkat rendah dan sangat ringan.

Prabogo berbeda dengan kerangka kerja web seperti di atas. Tujuan Prabogo bukan untuk menggantikan routing HTTP atau mengoptimalkan performa HTTP saja, melainkan memberikan fondasi arsitektur aplikasi yang kuat. Dengan Prabogo, pengembang lebih fokus ke logika domain dan workflow pengembangan yang terstruktur. Seluruh struktur proyek dan kode rutin dibuat otomatis, sehingga membangun API atau aplikasi web menjadi lebih cepat. Intinya, Prabogo mempermudah developer membangun aplikasi berskala besar dan terkelola, bukan hanya menyederhanakan routing HTTP.

Kapan Menggunakan Prabogo

Prabogo cocok dipakai ketika Anda ingin kecepatan pengembangan tanpa mengorbankan kualitas kode. Jika tim Anda sering membuat layanan baru, menerapkan domain-driven design, atau membangun API/mikroservis, Prabogo akan mempercepat proses bootstrap setiap layanan. Misalnya, startup yang ingin cepat menghadirkan fitur baru akan sangat terbantu karena banyak boilerplate otomatis dibuat.

Di sisi lain, Prabogo mungkin tidak terlalu diperlukan untuk proyek yang sangat sederhana (hanya beberapa endpoint) atau tim yang tidak membutuhkan arsitektur kompleks. Dalam kasus tersebut, overhead mempelajari pola arsitektur Prabogo bisa jadi tidak sebanding dengan manfaatnya. Namun, untuk proyek menengah ke atas atau tim yang menekankan maintainability, berinvestasi pada Prabogo biasanya menghasilkan efisiensi jangka panjang.

Untuk proyek yang sudah berjalan tanpa Prabogo, migrasi bisa dilakukan secara bertahap. Mulailah dengan mengidentifikasi domain inti dan membuat modul baru menggunakan Prabogo. Misalnya, saat menambah fitur baru, buatlah modul dengan prabogo-install lalu kembangkan di dalam kerangka Prabogo sambil perlahan memindahkan logika dari kode lama. Seiring waktu, lebih banyak bagian aplikasi dapat dipindah ke struktur Prabogo. Pendekatan bertahap ini membantu meminimalisir risiko gangguan produksi dan memudahkan transisi ke arsitektur baru.

Kesimpulan

Prabogo adalah salah satu terobosan menarik di ekosistem Go yang mengedepankan produktivitas dan kebersihan arsitektur. Dengan menyediakan banyak scaffold otomatis, fungsi CLI interaktif, dan dukungan AI bawaan, Prabogo membuat proses pengembangan aplikasi menjadi lebih cepat dan terstruktur. Alih-alih menulis kode boilerplate berulang, developer dapat langsung berfokus pada logika inti sesuai kebutuhan bisnis. Struktur folder dan arahan perintah yang konsisten juga mempermudah tim memahami alur aplikasi. Dalam praktiknya, keunggulan arsitektur hexagonal Prabogo terasa ketika aplikasi mulai berkembang.

Memisahkan logika bisnis dari detail teknis memungkinkan tim mengganti layanan eksternal dengan lebih mudah tanpa merombak keseluruhan kode. Selain itu, penulisan unit test menjadi lebih sederhana karena lapisan domain bisa diuji sendirian. Kombinasi fitur-fitur ini membuat Prabogo ideal untuk proyek berskala besar yang membutuhkan maintainability tinggi. Sekalipun demikian, penting diingat bahwa Prabogo relatif baru sehingga komunitasnya belum sebesar framework lain. Namun bila tujuan Anda adalah membangun aplikasi full-stack yang maintainable dan berbasis prinsip DDD, Prabogo bisa menjadi investasi waktu yang berharga. Dengan segala fiturnya, banyak developer yang mulai melirik Prabogo sebagai kerangka kerja pilihan dalam proyek Go mereka.

Penasaran menguasai pengembangan web secara menyeluruh? CodePolitan menawarkan KelasFullstack, program online belajar Fullstack Web Developer dari A sampai Z. Kelas ini cocok untuk kamu yang ingin memiliki karir profesional dengan gaji tinggi, melengkapi skill yang dibutuhkan industri, serta belajar membuat website atau aplikasi untuk mengembangkan bisnis online sendiri. Pelajari lebih lanjut di situs CodePolitan - KelasFullstack. Yuk, daftar sekarang dan tingkatkan skill-mu!

Referensi