<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Bagus Manggala Yudha on Medium]]></title>
        <description><![CDATA[Stories by Bagus Manggala Yudha on Medium]]></description>
        <link>https://medium.com/@bagusmanggalayudha?source=rss-2518abaf0d61------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ZZb3A0ZPlZwPURdPU8n5CA.jpeg</url>
            <title>Stories by Bagus Manggala Yudha on Medium</title>
            <link>https://medium.com/@bagusmanggalayudha?source=rss-2518abaf0d61------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 06:35:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@bagusmanggalayudha/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Analisis Protokol dan Alur Layer OSI pada Aplikasi Steam]]></title>
            <link>https://medium.com/@bagusmanggalayudha/analisis-protokol-dan-alur-layer-osi-pada-aplikasi-steam-0dc7e9342af9?source=rss-2518abaf0d61------2</link>
            <guid isPermaLink="false">https://medium.com/p/0dc7e9342af9</guid>
            <dc:creator><![CDATA[Bagus Manggala Yudha]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 08:32:50 GMT</pubDate>
            <atom:updated>2026-11-16T08:34:38.593Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mYfeTd5jilJATnLcznVPOw.png" /></figure><p><strong>Halo Semuanya!</strong></p><p>Kami Bagus Manggala Yudha (0057) dan Aufa Abid Rahman Nashir (0055), mahasiswa Teknologi Informasi di Universitas Tidar. Pada kelas Teori Jaringan Komputer kali ini, kami akan mempelajari tentang Analisis Protokol dan Alur Layer OSI pada Aplikasi Steam.</p><h3>1. Studi Kasus</h3><p>Aplikasi yang digunakan dalam analisis ini adalah Steam, yaitu platform distribusi game digital yang memungkinkan pengguna membeli, mengunduh, memperbarui, dan memainkan berbagai game.</p><p>Aktivitas yang dianalisis adalah proses download game melalui Steam. Ketika pengguna memilih sebuah game dan menekan tombol Download, aplikasi Steam akan mengirimkan permintaan ke server untuk mendapatkan file game. Server kemudian mengirimkan data melalui jaringan internet hingga file berhasil diterima dan disimpan di komputer pengguna.</p><h3>2. Service Name and Transport Protocol Port Number</h3><p>Dalam proses login dan download konten melalui Steam, terdapat beberapa protokol dan port yang digunakan, yaitu:</p><p><strong>HTTP (Hypertext Transfer Protocol)</strong></p><ul><li>Transport Protocol: TCP</li><li>Port Number: 80</li><li>Digunakan untuk komunikasi data melalui web.</li></ul><p><strong>HTTPS (Hypertext Transfer Protocol Secure)</strong></p><ul><li>Transport Protocol: TCP</li><li>Port Number: 443</li><li>Digunakan untuk komunikasi web yang dilindungi dengan enkripsi TLS.</li></ul><p><strong>Steam Network Services</strong></p><ul><li>Transport Protocol: TCP</li><li>Port Number: 27015–27050</li><li>Digunakan untuk mendukung komunikasi jaringan pada layanan Steam.</li></ul><p><strong>Steam Network Services</strong></p><ul><li>Transport Protocol: UDP</li><li>Port Number: 27015–27050</li><li>Digunakan untuk kebutuhan komunikasi jaringan Steam yang memanfaatkan protokol UDP.</li></ul><p>TCP berfungsi mengatur pengiriman data agar dapat diterima secara berurutan dan melakukan pengiriman ulang jika terjadi kehilangan data. Sementara itu, UDP lebih mengutamakan kecepatan pengiriman tanpa memastikan setiap paket diterima.</p><p>Port dan protokol tersebut merupakan bagian dari layanan jaringan Steam. Tidak semuanya harus digunakan secara bersamaan ketika pengguna melakukan download game.</p><h3>3. Alur Kerja Tiap Layer OSI (Top-Down)</h3><p>Berikut penjelasan alur kerja tujuh layer OSI ketika pengguna melakukan download game melalui Steam.</p><p><strong>a. Layer 7 — Application</strong></p><p>Pada layer ini, pengguna berinteraksi langsung dengan aplikasi Steam. Ketika tombol Download ditekan, Steam membuat permintaan kepada server untuk mendapatkan data game yang akan diunduh. Protokol HTTP atau HTTPS dapat digunakan dalam komunikasi tersebut.</p><p><strong>b. Layer 6 — Presentation</strong></p><p>Layer Presentation bertugas mengatur format data agar dapat dipahami oleh sistem penerima. Pada komunikasi HTTPS, proses enkripsi dan dekripsi TLS membantu melindungi data selama proses pengiriman.</p><p><strong>c. Layer 5 — Session</strong></p><p>Layer Session berfungsi mengatur dan menjaga sesi komunikasi antara aplikasi Steam dan server. Dengan adanya pengelolaan sesi, pertukaran data dapat berlangsung selama proses download.</p><p><strong>d. Layer 4 — Transport</strong></p><p>Pada layer ini, TCP berfungsi mengatur pengiriman data agar sampai secara berurutan dan memeriksa apakah data diterima dengan baik. Jika terdapat data yang hilang, TCP dapat melakukan pengiriman ulang. Layer ini juga menggunakan nomor port untuk membedakan layanan komunikasi.</p><p><strong>e. Layer 3 — Network</strong></p><p>Layer Network bertugas menentukan alamat tujuan dan jalur pengiriman data. Protokol IP digunakan untuk mengirimkan paket data dari server Steam menuju komputer pengguna melalui jaringan internet.</p><p><strong>f. Layer 2 — Data Link</strong></p><p>Pada layer Data Link, paket data dibungkus menjadi frame agar dapat dikirim melalui jaringan lokal. Layer ini menggunakan alamat MAC untuk membantu komunikasi antarperangkat dalam jaringan yang sama.</p><p><strong>g. Layer 1 — Physical</strong></p><p>Layer Physical merupakan lapisan paling bawah yang bertugas mengirimkan data dalam bentuk sinyal melalui media fisik. Media yang digunakan dapat berupa kabel Ethernet maupun gelombang radio Wi-Fi.</p><p>Setelah data sampai ke komputer pengguna, proses penerimaan berjalan dari Layer 1 menuju Layer 7. Data kemudian diproses oleh sistem operasi dan aplikasi Steam hingga file game dapat diterima dan disimpan.</p><h3>4. Bukti Observasi Aplikasi dan Pengecekan</h3><p>Untuk membuktikan adanya komunikasi jaringan ketika melakukan download game melalui Steam, pengamatan dapat dilakukan menggunakan Command Prompt dan Wireshark.</p><p><strong>Langkah pengamatan menggunakan Command Prompt:</strong></p><ul><li>Buka aplikasi Steam.</li><li>Pilih salah satu game dan mulai proses download.</li></ul><p>Di sini, kami menggunakan game Counter Strike 2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UPHiApd6HN6hS4xsuwV1pQ.png" /></figure><ul><li>Buka Command Prompt Windows.</li><li>Masukkan perintah berikut.</li></ul><p>netstat -ano</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Byt_fnw2bEcneYEUUzmMkg.png" /></figure><ul><li>Perhatikan daftar koneksi jaringan yang sedang berlangsung.</li><li>Cari koneksi yang berkaitan dengan Steam berdasarkan alamat IP, port, dan PID.</li><li>Untuk mengetahui nama proses berdasarkan PID, gunakan perintah:</li></ul><p>tasklist | findstr steam</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bXvQQML8BlufTBjGtizzzA.png" /></figure><p>Berdasarkan hasil pengamatan menggunakan perintah netstat -ano, ditemukan adanya penggunaan port UDP 27036 dengan PID 19268. Untuk mengetahui proses yang menggunakan port tersebut, dilakukan pengecekan menggunakan perintah tasklist | findstr steam.</p><p>Hasil pengecekan menunjukkan bahwa PID 19268 merupakan proses steam.exe. Hal ini menunjukkan bahwa aplikasi Steam telah membuka socket UDP untuk kebutuhan komunikasi jaringan.</p><p>Dari pengamatan tersebut, dapat diketahui bahwa Steam menggunakan protokol UDP dalam aktivitas jaringan.</p><p><strong>Langkah pengamatan menggunakan Wireshark:</strong></p><ol><li>Buka aplikasi Wireshark.</li><li>Pilih interface jaringan yang sedang digunakan, misalnya Wi-Fi.</li><li>Mulai proses capture.</li><li>Jalankan proses download game melalui Steam.</li><li>Gunakan filter tcp.port == 443 || tcp.port == 80 untuk melihat lalu lintas HTTP dan HTTPS.</li><li>Amati alamat IP tujuan, protokol, dan komunikasi paket data yang muncul.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aSwWUwIKbVA011dUrU2oVg.png" /></figure><p>Berdasarkan hasil penangkapan paket data (<em>packet capture</em>) menggunakan aplikasi Wireshark pada antarmuka jaringan Wi-Fi saat proses pengunduhan (<em>download</em>) game di Steam berlangsung, diperoleh bukti dan kesimpulan teknis sebagai berikut:</p><ul><li><strong>Filter Aktif (</strong><strong>tcp.port == 443 || tcp.port == 80):</strong> Menunjukkan bahwa pemantauan difokuskan secara spesifik pada lalu lintas web standar HTTP dan HTTPS.</li><li><strong>Penggunaan Protokol &amp; IPv6:</strong> Komunikasi terpantau menggunakan protokol TCP dan TLSv1.3, dengan perangkat klien dan server saling bertukar data via format alamat IPv6.</li><li><strong>Transfer Paket Jumbo (</strong><strong>Continuation Data):</strong> Terlihat deretan paket dengan ukuran panjang yang sangat bervariasi dan besar—mulai dari 1.506 bytes hingga menembus 12.962 bytes—yang menandakan proses unduhan file game sedang ngebut mengirimkan <em>payload</em> data dalam jumlah masif.</li><li><strong>Kehadiran Paket Kontrol (</strong><strong>[ACK]):</strong> Aliran data ini juga diselingi dengan paket <em>acknowledgement</em> ([ACK]) beserta nomor urut (Seq dan Ack) untuk memastikan kestabilan koneksi.</li><li><strong>Statistik Trafik Fantastis:</strong> Dari total sekitar 1,09 juta paket jaringan yang berhasil direkam (1.095.997 packets), sebanyak 94,1% di antaranya (1.031.602 packets) sukses disaring dan ditampilkan di layar sesuai filter yang dipasang.</li></ul><h3>Kesimpulan</h3><p>Berdasarkan analisis tersebut, proses download game melalui Steam melibatkan komunikasi antara aplikasi pengguna dengan server melalui jaringan internet. Setiap layer OSI memiliki fungsi masing-masing, mulai dari aplikasi yang mengirimkan permintaan hingga layer Physical yang mengirimkan sinyal melalui media jaringan.</p><p>Dengan memahami alur kerja setiap layer OSI, kita dapat mengetahui bagaimana data dikirimkan dari server Steam hingga akhirnya diterima dan disimpan di komputer pengguna.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0dc7e9342af9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jaringan Komputer: DHCP Client dan DHCP Server dengan Winbox]]></title>
            <link>https://medium.com/@bagusmanggalayudha/jaringan-komputer-dhcp-client-dan-dhcp-server-dengan-winbox-d44c34f8c045?source=rss-2518abaf0d61------2</link>
            <guid isPermaLink="false">https://medium.com/p/d44c34f8c045</guid>
            <category><![CDATA[winbox]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[mikrotik]]></category>
            <dc:creator><![CDATA[Bagus Manggala Yudha]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 00:01:15 GMT</pubDate>
            <atom:updated>2026-11-16T00:01:51.355Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*LigUaTghcHm_0BuW.png" /></figure><p><strong>Halo Semuanya!</strong></p><h3>1. Pendahuluan</h3><h4>1.1 Latar Belakang</h4><p>Hi, kami Excel Bagus Herlambang NPM <strong>0056 </strong>dan Bagus Manggala Yudha NPM <strong>0057</strong>, Mahasiswa S1 Teknologi Informasi. Seperti praktikum sebelumnya, kami mengerjakan praktikum ini berdua, jadi laporannya juga ditulis bersama. Materinya <strong>DHCP Server dan Client pada Mikrotik RB951</strong> (Modul III), dengan konfigurasi lewat Winbox.</p><p>Di praktikum Packet Tracer sebelumnya kami sudah mencoba DHCP lewat simulasi. Kali ini kami melakukannya pada perangkat fisik, dan Mikrotik berperan ganda: sebagai <strong>DHCP Client</strong> yang menerima IP dari jaringan di atasnya lewat ether1, sekaligus sebagai <strong>DHCP Server</strong> yang membagikan IP ke PC lewat ether2.</p><h4>1.2 Tujuan Praktikum</h4><ol><li>Memahami konsep dan fungsi DHCP dalam jaringan komputer.</li><li>Mengonfigurasi DHCP Client dan DHCP Server pada Mikrotik RB951 menggunakan Winbox.</li><li>Menghubungkan dan menguji PC agar mendapat IP address secara otomatis dari DHCP Server Mikrotik.</li><li>Menganalisis hasil konfigurasi pembagian IP otomatis.</li></ol><h4>1.3 Dasar Teori Singkat</h4><p><strong>DHCP (Dynamic Host Configuration Protocol)</strong> adalah protokol yang membagikan IP address, subnet mask, gateway, dan DNS ke perangkat secara otomatis, sehingga tidak perlu diisi satu per satu. Prosesnya berjalan dalam empat tahap yang sering disingkat <strong>DORA</strong>: Discover (client mencari server), Offer (server menawarkan IP), Request (client meminta IP yang ditawarkan), dan Acknowledge (server menyetujui).</p><p>Mikrotik bisa memerankan dua sisi. Sebagai <strong>DHCP Client</strong>, ia menerima IP dari perangkat di atasnya, misalnya modem atau router upstream. Sebagai <strong>DHCP Server</strong>, ia membagikan IP dari rentang (pool) yang ditentukan ke perangkat di jaringan lokal. IP yang dibagikan bersifat pinjaman selama <strong>lease time</strong>, lalu diperbarui atau dilepas.</p><h3>2. Metodologi</h3><h4>2.1 Alat dan Bahan</h4><ul><li>Router Mikrotik RB951 beserta adaptor daya</li><li>PC lab dengan port LAN aktif sebagai perangkat administrator dan client</li><li>Kabel UTP Straight-Through</li><li>Aplikasi Winbox bawaan PC lab</li></ul><h4>2.2 Langkah Kerja</h4><p><strong>2.2.1 Topologi dan Koneksi Fisik</strong></p><p>Port <strong>ether1</strong> Mikrotik dihubungkan ke jaringan di atasnya (sisi DHCP Client), sedangkan port <strong>ether2</strong> dihubungkan ke PC lab (sisi DHCP Server). Setelah router menyala, kami membuka Winbox dan terhubung ke Mikrotik lewat MAC address.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/521/0*vReD4npxWDl2v8ED.png" /><figcaption>Mikrotik RB951 dengan dua kabel terpasang: ether1 ke jaringan atas dan ether2 ke PC</figcaption></figure><p><strong>2.2.2 Konfigurasi DHCP Client pada ether1</strong></p><p>Di Winbox, buka <strong>IP &gt; DHCP Client</strong>, klik tombol <strong>+</strong>. Interface dipilih <strong>ether1</strong>, opsi <strong>Use Peer DNS</strong> dan <strong>Use Peer NTP</strong> dicentang, lalu klik Apply dan OK.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*h8Czmo6mzN2D-9vh.jpeg" /><figcaption>Menambah DHCP Client pada interface ether1</figcaption></figure><p>Kalau berhasil, kolom Status menampilkan <strong>bound</strong>, artinya Mikrotik sudah mendapat IP dari jaringan di atasnya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*JLvJsWU7ceAi4vTh.jpeg" /><figcaption>Status DHCP Client ether1: bound</figcaption></figure><p><strong>2.2.3 Memberi IP Address pada Interface LAN</strong></p><p>Di <strong>IP &gt; Addresses</strong>, klik <strong>+</strong> lalu isi Address <strong>192.168.50.1/24</strong> dengan interface <strong>ether2</strong>. Interface ini yang nanti menjadi gateway bagi PC.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*XNUKfuGwHYar2di3.jpeg" /><figcaption>Menambah IP 192.168.50.1/24 pada ether2</figcaption></figure><p><strong>2.2.4 Membuat DHCP Server</strong></p><p>Buka <strong>IP &gt; DHCP Server &gt; DHCP Setup</strong>, lalu pilih interface <strong>ether2</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*jgB79IRs1NehhRUq.jpeg" /><figcaption>DHCP Setup: memilih interface ether2</figcaption></figure><p>Wizard berikutnya kami isi sebagai berikut: DHCP Address Space <strong>192.168.50.0/24</strong>, Gateway <strong>192.168.50.1</strong>, pool IP <strong>192.168.50.2 sampai 192.168.50.100</strong>, DNS Server <strong>8.8.8.8</strong> dan <strong>8.8.4.4</strong>, serta Lease Time <strong>10 menit</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*Zk57x-_CX0lci2zG.jpeg" /><figcaption>Menentukan pool IP 192.168.50.2–192.168.50.100</figcaption></figure><p>Di akhir wizard muncul pesan bahwa setup selesai, dan DHCP Server bernama dhcp1 tampil pada interface ether2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*eM2aEnZng1Ty90ea.jpeg" /><figcaption>DHCP Setup selesai, dhcp1 aktif di ether2</figcaption></figure><p><strong>2.2.5 Mengatur PC sebagai DHCP Client</strong></p><p>Di PC lab, buka <strong>Network Connections</strong>, lalu klik kanan adapter Ethernet, pilih <strong>Properties &gt; Internet Protocol Version 4 (TCP/IPv4)</strong>. Pilihan <strong>Obtain an IP address automatically</strong> dan <strong>Obtain DNS server address automatically</strong> dicentang.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*JMTOg4CzTqpeALPh.jpeg" /><figcaption>Pengaturan TCP/IPv4 pada PC: IP dan DNS otomatis</figcaption></figure><p><strong>2.2.6 Pengujian</strong></p><p>Pertama kami cek IP yang diterima PC dengan <strong>ipconfig </strong>di Command Prompt, lalu menguji koneksi ke Mikrotik dengan <strong>ping 192.168.50.1</strong>.</p><pre>ipconfig<br>ping 192.168.50.1</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*2qzVFCKY6rVdMeEQ.jpeg" /><figcaption>Hasil ipconfig: PC mendapat IP dari Mikrotik</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*mN3Fv44r2gu6ENRd.jpeg" /><figcaption>Ping dari PC ke 192.168.50.1: 4 reply, 0% loss</figcaption></figure><p>3. Hasil dan Analisis</p><h4>3.1 Hasil</h4><ul><li><strong>DHCP Client (ether1):</strong> status <strong>bound</strong>, dengan IP 10.20.110.7/24, gateway 10.20.110.1, DHCP server 192.168.20.9, dan DNS 103.108.191.111 serta 103.108.191.112.</li><li><strong>DHCP Server (ether2):</strong> dhcp1 berhasil dibuat dengan pool 192.168.50.2 sampai 192.168.50.100, gateway 192.168.50.1, DNS 8.8.8.8 dan 8.8.4.4, serta lease time 10 menit.</li><li><strong>PC:</strong> mendapat IP <strong>192.168.50.100</strong>, subnet mask 255.255.255.0, dan gateway <strong>192.168.50.1</strong> secara otomatis.</li><li><strong>Ping</strong> dari PC ke 192.168.50.1 berhasil 4 dari 4 paket (0% loss), waktu balasan kurang dari 1 ms, TTL 64.</li></ul><h4>3.2 Analisis</h4><p>Mikrotik menjalankan dua peran sekaligus pada dua jaringan yang berbeda. Di sisi ether1, ia menjadi client dan menerima alamat dari jaringan atas (10.20.110.0/24). Di sisi ether2, ia menjadi server dan membagikan alamat jaringan lokal baru (192.168.50.0/24). Keduanya dipisahkan oleh router, sehingga PC hanya perlu tahu gateway-nya, yaitu 192.168.50.1.</p><p>IP yang diterima PC (192.168.50.100) berada di dalam pool yang kami tentukan, dan seluruh parameternya (subnet mask, gateway, DNS) terisi otomatis tanpa diketik manual. Itu bukti DHCP Server bekerja. Ping berhasil karena PC dan Mikrotik kini berada dalam satu subnet 192.168.50.0/24. Alamat yang didapat tidak harus yang paling awal di pool, cukup selama masih dalam rentang yang ditentukan. Pada hasil <strong>ipconfig </strong>juga terlihat adapter lain (Ethernet 6, 192.168.56.1). Itu adapter virtual bawaan VirtualBox pada PC lab, bukan bagian dari praktikum ini.</p><p>Lease time 10 menit berarti IP hanya dipinjamkan sementara dan harus diperbarui setelahnya. Untuk jaringan kecil seperti di lab, nilai ini bisa diubah sesuai kebutuhan lewat IP &gt; DHCP Server.</p><h3>4. Kesimpulan</h3><p>Dari praktikum ini, keempat tujuan tercapai. Konsep DHCP dipahami sebagai proses pembagian IP otomatis (DORA) dengan lease time. DHCP Client pada ether1 berhasil memperoleh IP (status bound), DHCP Server pada ether2 berhasil dikonfigurasi dengan pool 192.168.50.2 sampai 192.168.50.100, dan PC memperoleh IP 192.168.50.100 beserta gateway-nya secara otomatis. Ping dari PC ke Mikrotik berhasil tanpa packet loss, membuktikan pembagian IP otomatis berjalan dengan benar.</p><h3>5. Referensi dan Lampiran</h3><h3>Referensi</h3><ul><li>Modul Praktikum Jaringan Komputer — Modul III: DHCP Server dan Client. Program Studi Teknologi Informasi.</li><li>Dokumentasi MikroTik RouterOS dan Winbox</li></ul><h3>Lampiran</h3><p>Dokumentasi praktikum:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/544/0*Xzu1mIUs02TU4dJT.png" /><figcaption>Router Mikrotik RB951, adaptor daya, dan kabel UTP</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d44c34f8c045" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Big Data: Pemrosesan Data Streaming dengan Spark Structured Streaming]]></title>
            <link>https://medium.com/@bagusmanggalayudha/big-data-pemrosesan-data-streaming-dengan-spark-structured-streaming-562f0299fb1c?source=rss-2518abaf0d61------2</link>
            <guid isPermaLink="false">https://medium.com/p/562f0299fb1c</guid>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[spark-streaming]]></category>
            <category><![CDATA[apache-spark]]></category>
            <dc:creator><![CDATA[Bagus Manggala Yudha]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 15:11:12 GMT</pubDate>
            <atom:updated>2026-11-11T15:11:12.556Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YePYuMOfCoPFsdJsPvcjkw.png" /></figure><p><strong>Halo Semuanya!</strong></p><p>Saya Bagus Manggala Yudha, mahasiswa Teknologi Informasi di Universitas Tidar. Pada Praktikum Big Data kali ini, kita akan mempelajari tentang Pemrosesan Data Streaming dengan Spark Structured Streaming.</p><h3>1. PENDAHULUAN</h3><h4>1.1 Tujuan Praktikum</h4><p>Tujuan dari praktikum ini adalah:</p><ol><li>Memahami perbedaan antara Batch Processing dan Stream Processing.</li><li>Memahami konsep dasar Spark Structured Streaming.</li><li>Mengetahui fungsi input source, trigger, output sink, dan output mode dalam pemrosesan streaming.</li><li>Mampu membangun streaming query menggunakan PySpark.</li><li>Mampu melakukan agregasi data streaming berdasarkan kategori tertentu.</li><li>Memahami penerapan agregasi berbasis window waktu.</li><li>Mampu mensimulasikan aliran data menggunakan folder sebagai sumber streaming.</li></ol><h4>1.2 Dasar Teori</h4><p><strong>A. Pengertian</strong> Batch Processing</p><p>Batch Processing merupakan metode pemrosesan data yang dilakukan terhadap sekumpulan data yang sudah terkumpul dan tersimpan sebelumnya.</p><p>Pada metode ini, data biasanya dikumpulkan terlebih dahulu sebelum diproses dalam satu waktu tertentu. Contohnya adalah pembuatan laporan penjualan bulanan atau pengolahan data transaksi yang sudah tersimpan dalam file CSV.</p><p>Karakteristik Batch Processing:</p><ol><li>Data bersifat statis dan sudah tersedia sebelum proses dimulai.</li><li>Pemrosesan dilakukan secara berkala atau terjadwal.</li><li>Cocok untuk pengolahan data dalam jumlah besar.</li><li>Hasil pemrosesan tidak selalu tersedia secara langsung ketika data masuk.</li></ol><p><strong>B. Pengertian Stream Processing</strong></p><p>Stream Processing merupakan metode pemrosesan data yang dilakukan secara berkelanjutan ketika data baru masuk ke dalam sistem.</p><p>Metode ini banyak digunakan pada sistem yang membutuhkan pemantauan data secara langsung atau mendekati real-time.</p><p>Contohnya adalah transaksi e-commerce, data sensor Internet of Things (IoT), log aktivitas pengguna aplikasi, dan pemantauan media sosial.</p><p>Karakteristik Stream Processing:</p><ol><li>Data terus mengalir dan bertambah secara berkelanjutan.</li><li>Data diproses secara inkremental ketika tersedia.</li><li>Cocok untuk sistem yang membutuhkan pemantauan secara real-time.</li><li>Hasil pemrosesan dapat diperbarui ketika data baru masuk.</li></ol><p><strong>C. Perbedaan Batch Processing dan Stream Processing</strong></p><p><strong>Batch Processing</strong></p><ul><li>Sifat data: Statis dan sudah terkumpul.</li><li>Waktu pemrosesan: Terjadwal.</li><li>Contoh: Laporan penjualan bulanan.</li></ul><p><strong>Stream Processing</strong></p><ul><li>Sifat data: Terus mengalir.</li><li>Waktu pemrosesan: Saat data tersedia.</li><li>Contoh: Pemantauan transaksi secara langsung.</li></ul><p><strong>D. Pengertian Spark Structured Streaming</strong></p><p>Spark Structured Streaming merupakan fitur dari Apache Spark yang digunakan untuk melakukan pemrosesan data streaming menggunakan DataFrame API.</p><p>Fitur ini memungkinkan pengguna mengolah data yang terus masuk menggunakan sintaks yang hampir sama dengan pemrosesan DataFrame biasa.</p><p>Spark Structured Streaming bekerja menggunakan konsep micro-batch, yaitu data yang masuk diproses dalam kelompok-kelompok kecil secara berulang.</p><p>Dengan demikian, pengguna tidak perlu membuat algoritma pemrosesan streaming dari awal karena Spark telah menyediakan mekanisme untuk mengelola aliran data tersebut.</p><p><strong>E. Komponen Spark Structured Streaming</strong></p><p>Dalam Spark Structured Streaming terdapat beberapa komponen penting, yaitu:</p><p><strong>1. Input Source</strong></p><p>Input Source merupakan sumber data yang dibaca oleh Spark. Pada praktikum ini, sumber data menggunakan folder yang berisi file CSV.</p><p><strong>2. Trigger</strong></p><p>Trigger menentukan kapan Spark akan menjalankan pemrosesan data streaming. Trigger mengatur interval pemrosesan micro-batch.</p><p><strong>3. Output Sink</strong></p><p>Output Sink merupakan tempat penyimpanan hasil pemrosesan streaming.</p><p>Pada praktikum ini digunakan memory sink untuk menyimpan hasil sementara dalam tabel yang dapat diakses menggunakan SQL.</p><p><strong>4. Output Mode</strong></p><p>Output Mode menentukan bagaimana hasil pemrosesan streaming ditampilkan atau disimpan.</p><p>Beberapa mode yang digunakan dalam Spark Structured Streaming adalah:</p><ul><li><strong>Append:</strong> Hanya menambahkan baris baru yang sudah selesai diproses.</li><li><strong>Complete:</strong> Menampilkan seluruh hasil agregasi terbaru setiap kali terdapat pembaruan.</li><li><strong>Update:</strong> Hanya menampilkan baris yang mengalami perubahan.</li></ul><p><strong>F. Pengertian Micro-Batch</strong></p><p>Micro-batch merupakan metode pemrosesan data streaming dengan membagi aliran data menjadi kelompok-kelompok kecil.</p><p>Setiap kali terdapat data baru, Spark akan memproses data tersebut dalam satu batch kecil.</p><p>Pada praktikum ini, micro-batch disimulasikan dengan cara menambahkan file CSV baru ke dalam folder yang sedang diawasi oleh Spark.</p><p><strong>G. Pengertian Window Waktu</strong></p><p>Window waktu merupakan teknik pengelompokan data streaming berdasarkan rentang waktu tertentu.</p><p>Teknik ini digunakan untuk menghitung agregasi data berdasarkan interval waktu, misalnya total transaksi setiap satu menit atau jumlah pesanan setiap lima menit.</p><p>Pada Spark Structured Streaming, window waktu dapat dibuat menggunakan fungsi window().</p><p>Contohnya:</p><pre>window(col(&quot;waktu_transaksi&quot;), &quot;1 minute&quot;)</pre><p>Perintah tersebut digunakan untuk mengelompokkan data berdasarkan rentang waktu satu menit.</p><h3>2. ALAT DAN BAHAN</h3><p>Alat dan bahan yang digunakan dalam praktikum ini adalah:</p><ol><li>Laptop atau komputer.</li><li>Python versi 3.11.</li><li>Apache Spark versi 3.5.9.</li><li>PySpark versi 3.5.9.</li><li>Jupyter Notebook.</li><li>Library Pandas.</li><li>File CSV sebagai sumber data simulasi streaming.</li></ol><h3>3. LANGKAH KERJA PRAKTIKUM</h3><h4>3.1 Persiapan SparkSession</h4><p>Langkah pertama adalah mempersiapkan lingkungan kerja menggunakan Jupyter Notebook.</p><p>Selanjutnya, lakukan import library yang diperlukan.</p><p>Kode program:</p><pre>from pyspark.sql import SparkSession<br>from pyspark.sql.types import StructType, StructField, StringType, IntegerType, TimestampType<br>from pyspark.sql.functions import window, sum as spark_sum, count, avg, col<br>import os<br>import shutil<br>import time<br>import pandas as pd</pre><p>Penjelasan:</p><ol><li>SparkSession digunakan untuk membuat sesi Spark.</li><li>StructType dan StructField digunakan untuk mendefinisikan struktur data.</li><li>StringType, IntegerType, dan TimestampType digunakan untuk menentukan tipe data setiap kolom.</li><li>window() digunakan untuk membuat pengelompokan berdasarkan rentang waktu.</li><li>spark_sum() digunakan untuk menghitung total nilai.</li><li>count() digunakan untuk menghitung jumlah data.</li><li>avg() digunakan untuk menghitung nilai rata-rata.</li><li>col() digunakan untuk mereferensikan kolom DataFrame.</li><li>pandas digunakan untuk membuat file CSV sebagai simulasi data streaming.</li></ol><p>Selanjutnya, buat SparkSession:</p><pre>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan10-StructuredStreaming&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br># Mengurangi jumlah partisi shuffle default (200) agar pemrosesan pada VM/laptop kita lebih cepat<br># -- semakin kecil dataset (seperti simulasi kita), semakin tidak perlu partisi sebanyak itu<br>spark.conf.set(&quot;spark.sql.shuffle.partitions&quot;, &quot;4&quot;)<br><br>print(&quot;SparkSession siap. Versi Spark:&quot;, spark.version)</pre><p>Penjelasan:</p><ul><li>appName() digunakan untuk memberikan nama aplikasi Spark.</li><li>master(&quot;local[*]&quot;) digunakan untuk menjalankan Spark menggunakan seluruh core CPU yang tersedia.</li><li>getOrCreate() digunakan untuk membuat SparkSession atau menggunakan sesi yang sudah tersedia.</li><li>setLogLevel(&quot;ERROR&quot;) digunakan untuk mengurangi pesan log yang ditampilkan.</li><li>spark.sql.shuffle.partitions diatur menjadi 4 agar pemrosesan data simulasi lebih ringan.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/280/1*Pln7jKAUj4YHB0bdAVJV1g.png" /></figure><h4>3.2 Membuat Folder Simulasi Streaming</h4><p>Setelah SparkSession berhasil dibuat, langkah selanjutnya adalah menyiapkan folder yang digunakan sebagai sumber data streaming.</p><p>Kode program:</p><pre>folder_stream = &quot;simulasi_stream_transaksi&quot;<br>folder_checkpoint = &quot;checkpoint_pertemuan10&quot;<br><br>shutil.rmtree(folder_stream, ignore_errors=True)<br>shutil.rmtree(folder_checkpoint, ignore_errors=True)<br>os.makedirs(folder_stream, exist_ok=True)<br><br>print(f&quot;Folder simulasi streaming &#39;{folder_stream}&#39; siap (kosong).&quot;)</pre><p>Penjelasan:</p><ol><li>folder_stream merupakan folder yang digunakan sebagai sumber data streaming.</li><li>folder_checkpoint merupakan lokasi yang disiapkan untuk checkpoint.</li><li>shutil.rmtree() digunakan untuk menghapus folder lama apabila masih tersedia.</li><li>os.makedirs() digunakan untuk membuat folder baru.</li></ol><p>Pada praktikum ini, folder tersebut awalnya dikosongkan. File CSV akan ditambahkan secara bertahap untuk mensimulasikan data yang masuk ke sistem streaming.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/496/1*GJ57Zro_pNJfFwb6M-0x7Q.png" /></figure><h4>3.3 Mendefinisikan Skema Data</h4><p>Dalam Spark Structured Streaming, skema data harus didefinisikan secara eksplisit.</p><p>Berbeda dengan pemrosesan batch yang dapat menggunakan inferSchema=True, pemrosesan streaming berbasis file pada praktikum ini mengharuskan skema ditentukan terlebih dahulu.</p><p>Hal tersebut diperlukan karena data streaming belum tersedia secara lengkap ketika proses dimulai.</p><p>Kode program:</p><pre>skema_transaksi = StructType([<br>    StructField(&quot;trx_id&quot;, StringType(), True),<br>    StructField(&quot;kota&quot;, StringType(), True),<br>    StructField(&quot;kategori&quot;, StringType(), True),<br>    StructField(&quot;pendapatan&quot;, IntegerType(), True),<br>])<br><br>print(&quot;Skema berhasil didefinisikan:&quot;)<br>print(skema_transaksi)print(&quot;Skema berhasil didefinisikan:&quot;)<br>print(skema_transaksi)</pre><p>Penjelasan:</p><ul><li>trx_id merupakan ID transaksi dengan tipe String.</li><li>kota merupakan nama kota dengan tipe String.</li><li>kategori merupakan kategori transaksi dengan tipe String.</li><li>pendapatan merupakan nilai pendapatan dengan tipe Integer.</li><li>Parameter True menunjukkan bahwa kolom tersebut diperbolehkan memiliki nilai null.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*8rvwmNACWecEZfTSToYN5Q.png" /></figure><h4>3.4 Membangun Streaming Query Pertama</h4><p>Pada tahap ini dilakukan pembuatan streaming query pertama menggunakan Spark Structured Streaming.</p><p><strong>A. Mendefinisikan Input Source</strong></p><p>Langkah pertama adalah membaca data dari folder simulasi menggunakan readStream.</p><p>Kode program:</p><pre>df_stream = spark.readStream \<br>    .format(&quot;csv&quot;) \<br>    .schema(skema_transaksi) \<br>    .option(&quot;header&quot;, True) \<br>    .load(folder_stream)<br><br>print(&quot;Streaming DataFrame berhasil didefinisikan (belum berjalan — baru &#39;rencana&#39;).&quot;)<br>print(&quot;df_stream.isStreaming:&quot;, df_stream.isStreaming)</pre><p>Penjelasan:</p><ol><li>readStream digunakan untuk membaca data secara streaming.</li><li>format(&quot;csv&quot;) menentukan bahwa sumber data menggunakan format CSV.</li><li>schema(skema_transaksi) menentukan struktur data yang digunakan.</li><li>option(&quot;header&quot;, True) menunjukkan bahwa baris pertama file CSV merupakan nama kolom.</li><li>load(folder_stream) menentukan folder yang akan dipantau oleh Spark.</li></ol><p>Properti isStreaming digunakan untuk memastikan bahwa DataFrame yang dibuat merupakan DataFrame streaming.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/558/1*FdaRLiI7UOMAqyRtUrsMow.png" /></figure><p><strong>B. Melakukan Transformasi dan Agregasi</strong></p><p>Setelah input source berhasil dibuat, langkah selanjutnya adalah melakukan agregasi berdasarkan kota.</p><p>Kode program:</p><pre>agregasi_stream = df_stream.groupBy(&quot;kota&quot;).agg(<br>agregasi_stream = df_stream.groupBy(&quot;kota&quot;).agg(<br>    spark_sum(&quot;pendapatan&quot;).alias(&quot;total_pendapatan&quot;),<br>    count(&quot;trx_id&quot;).alias(&quot;jumlah_transaksi&quot;)<br>)<br><br>print(&quot;Transformasi berhasil didefinisikan.&quot;)</pre><p>Penjelasan:</p><ol><li>groupBy(&quot;kota&quot;) digunakan untuk mengelompokkan data berdasarkan nama kota.</li><li>spark_sum(&quot;pendapatan&quot;) digunakan untuk menghitung total pendapatan setiap kota.</li><li>count(&quot;trx_id&quot;) digunakan untuk menghitung jumlah transaksi setiap kota.</li><li>alias() digunakan untuk memberikan nama pada kolom hasil agregasi.</li></ol><p>Hasil agregasi akan menampilkan total pendapatan dan jumlah transaksi berdasarkan masing-masing kota.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/272/1*WxxtBfqPxffLA6M4O3ggCw.png" /></figure><p><strong>C. Mendefinisikan Output Sink</strong></p><p>Selanjutnya, hasil agregasi akan disimpan menggunakan memory sink.</p><p>Kode program:</p><pre>query = agregasi_stream.writeStream \<br>    .outputMode(&quot;complete&quot;) \<br>    .format(&quot;memory&quot;) \<br>    .queryName(&quot;hasil_agregasi&quot;) \<br>    .start()<br><br>print(&quot;Streaming query dimulai! Status:&quot;, query.status)</pre><p>Penjelasan:</p><ul><li>writeStream digunakan untuk menentukan tujuan hasil streaming.</li><li>outputMode(&quot;complete&quot;) digunakan untuk menampilkan seluruh hasil agregasi terbaru.</li><li>format(&quot;memory&quot;) digunakan untuk menyimpan hasil sementara dalam memori.</li><li>queryName(&quot;hasil_agregasi&quot;) memberikan nama tabel yang dapat diakses melalui Spark SQL.</li><li>start() digunakan untuk memulai proses streaming.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/892/1*rCa5DGMaFzgLPu5nrH_WYQ.png" /></figure><h4>3.5 Mengirim Data Streaming Batch Pertama</h4><p>Setelah streaming query berjalan, selanjutnya dilakukan simulasi pengiriman data pertama dengan membuat file CSV baru.</p><p>Kode program:</p><pre>pd.DataFrame({<br>    &quot;trx_id&quot;: [&quot;T1&quot;, &quot;T2&quot;, &quot;T3&quot;],<br>    &quot;kota&quot;: [&quot;Magelang&quot;, &quot;Solo&quot;, &quot;Magelang&quot;],<br>    &quot;kategori&quot;: [&quot;Elektronik&quot;, &quot;Fashion&quot;, &quot;Makanan&quot;],<br>    &quot;pendapatan&quot;: [150000, 200000, 75000],<br>}).to_csv(f&quot;{folder_stream}/batch_1.csv&quot;, index=False)<br><br>print(&quot;Batch 1 dikirim. Menunggu Spark memproses...&quot;)<br>time.sleep(6)  # memberi waktu Spark memproses micro-batch (proses pertama kali butuh waktu ekstra)<br><br>spark.sql(&quot;SELECT * FROM hasil_agregasi ORDER BY total_pendapatan DESC&quot;).show()</pre><p>Penjelasan:</p><ol><li>pd.DataFrame() digunakan untuk membuat data transaksi.</li><li>to_csv() digunakan untuk menyimpan data ke dalam file CSV.</li><li>File batch_1.csv dimasukkan ke folder simulasi streaming.</li><li>time.sleep(6) digunakan untuk memberikan waktu kepada Spark agar memproses data.</li><li>spark.sql() digunakan untuk mengambil hasil agregasi dari tabel memory sink.</li></ol><p>Data batch pertama terdiri dari tiga transaksi:</p><p>Transaksi T1:</p><ul><li>Kota: Magelang</li><li>Kategori: Elektronik</li><li>Pendapatan: Rp150.000</li></ul><p>Transaksi T2:</p><ul><li>Kota: Solo</li><li>Kategori: Fashion</li><li>Pendapatan: Rp200.000</li></ul><p>Transaksi T3:</p><ul><li>Kota: Magelang</li><li>Kategori: Makanan</li><li>Pendapatan: Rp75.000</li></ul><p>Hasil agregasi yang ditampilkan:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/368/1*3J2EDpivu9VGVCunLSIMgQ.png" /></figure><h3>3.6 Mengirim Data Streaming Batch Kedua</h3><p>Selanjutnya, dilakukan pengiriman batch kedua dengan menambahkan file CSV baru ke dalam folder yang sama.</p><p>Kode program:</p><pre>pd.DataFrame({<br>    &quot;trx_id&quot;: [&quot;T4&quot;, &quot;T5&quot;],<br>    &quot;kota&quot;: [&quot;Magelang&quot;, &quot;Yogyakarta&quot;],<br>    &quot;kategori&quot;: [&quot;Fashion&quot;, &quot;Elektronik&quot;],<br>    &quot;pendapatan&quot;: [300000, 500000],<br>}).to_csv(f&quot;{folder_stream}/batch_2.csv&quot;, index=False)<br><br>print(&quot;Batch 2 dikirim. Menunggu Spark memproses...&quot;)<br>time.sleep(6)<br><br>spark.sql(&quot;SELECT * FROM hasil_agregasi ORDER BY total_pendapatan DESC&quot;).show()</pre><p>Penjelasan:</p><p>Pada tahap ini, file batch_2.csv ditambahkan ke folder simulasi.</p><p>Spark secara otomatis mendeteksi file baru dan memproses data tersebut tanpa perlu membuat ulang streaming query.</p><p>Data batch kedua terdiri dari:</p><p><strong>Transaksi T4</strong></p><ul><li>Kota: Magelang</li><li>Kategori: Fashion</li><li>Pendapatan: Rp300.000</li></ul><p><strong>Transaksi T5</strong></p><ul><li>Kota: Yogyakarta</li><li>Kategori: Elektronik</li><li>Pendapatan: Rp500.000</li></ul><p>Hasil agregasi setelah batch kedua yang ditampilkan:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/392/1*KM0KhhYvvHyR84TB-A_TRg.png" /></figure><p>Hasil tersebut menunjukkan bahwa total pendapatan Magelang bertambah dari Rp225.000 menjadi Rp525.000 setelah batch kedua diproses.</p><p>Hal ini terjadi karena Spark mempertahankan state atau kondisi agregasi sebelumnya dan menggabungkannya dengan data baru.</p><h4>3.7 Menghentikan Streaming Query</h4><p>Streaming query akan terus berjalan sampai dihentikan secara eksplisit.</p><p>Oleh karena itu, setelah proses pengujian selesai, streaming query harus dihentikan.</p><p>Kode program:</p><pre>query.stop()<br>print(&quot;Streaming query dihentikan. Status aktif:&quot;, query.isActive)</pre><p>Penjelasan:</p><ul><li>query.stop() digunakan untuk menghentikan proses streaming.</li><li>query.isActive digunakan untuk memeriksa apakah streaming query masih berjalan.</li></ul><h4>3.8 Agregasi Berbasis Window Waktu</h4><p>Selain mengelompokkan data berdasarkan kolom tertentu, Spark Structured Streaming juga mendukung pengelompokan berdasarkan rentang waktu.</p><p>Pada tahap ini, data akan dikelompokkan berdasarkan window waktu satu menit.</p><p><strong>A. Mendefinisikan Skema dengan Timestamp</strong></p><p>Untuk melakukan agregasi berdasarkan waktu, diperlukan kolom bertipe Timestamp.</p><p>Kode program:</p><pre>skema_dengan_waktu = StructType([<br>    StructField(&quot;trx_id&quot;, StringType(), True),<br>    StructField(&quot;kota&quot;, StringType(), True),<br>    StructField(&quot;pendapatan&quot;, IntegerType(), True),<br>    StructField(&quot;waktu_transaksi&quot;, TimestampType(), True),<br>])</pre><p>Penjelasan:</p><p>Skema tersebut memiliki empat kolom:</p><ol><li>trx_id untuk menyimpan ID transaksi.</li><li>kota untuk menyimpan nama kota.</li><li>pendapatan untuk menyimpan nilai transaksi.</li><li>waktu_transaksi untuk menyimpan waktu terjadinya transaksi.</li></ol><p>Kolom waktu_transaksi menggunakan tipe Timestamp agar Spark dapat melakukan pengelompokan berdasarkan rentang waktu.</p><p><strong>B. Membuat Folder Simulasi Kedua</strong></p><p>Selanjutnya, buat folder baru untuk simulasi streaming berbasis waktu.</p><p>Kode program:</p><pre>folder_stream2 = &quot;simulasi_stream_waktu&quot;<br>shutil.rmtree(folder_stream2, ignore_errors=True)<br>os.makedirs(folder_stream2, exist_ok=True)</pre><p>Folder ini akan digunakan sebagai sumber data untuk agregasi window waktu.</p><p><strong>C. Membuat Streaming DataFrame</strong></p><p>Kode program:</p><pre>df_stream2 = spark.readStream \<br>    .format(&quot;csv&quot;) \<br>    .schema(skema_dengan_waktu) \<br>    .option(&quot;header&quot;, True) \<br>    .load(folder_stream2)</pre><p>Perintah tersebut digunakan untuk membaca file CSV yang masuk ke folder simulasi menggunakan mekanisme streaming.</p><p><strong>D. Membuat Agregasi Window Waktu</strong></p><p>Selanjutnya, lakukan pengelompokan berdasarkan window waktu satu menit.</p><p>Kode program:</p><pre>agregasi_window = df_stream2.groupBy(<br>    window(col(&quot;waktu_transaksi&quot;), &quot;1 minute&quot;)<br>).agg(<br>    spark_sum(&quot;pendapatan&quot;).alias(&quot;total_pendapatan&quot;),<br>    count(&quot;trx_id&quot;).alias(&quot;jumlah_transaksi&quot;)<br>)</pre><p>Penjelasan:</p><ol><li>groupBy() digunakan untuk mengelompokkan data.</li><li>window() digunakan untuk menentukan rentang waktu satu menit.</li><li>col(&quot;waktu_transaksi&quot;) menentukan kolom waktu yang digunakan.</li><li>spark_sum(&quot;pendapatan&quot;) menghitung total pendapatan dalam setiap window.</li><li>count(&quot;trx_id&quot;) menghitung jumlah transaksi dalam setiap window.</li></ol><p><strong>E. Menjalankan Streaming Query Window</strong></p><p>Kode program:</p><pre>query2 = agregasi_window.writeStream \<br>    .outputMode(&quot;complete&quot;) \<br>    .format(&quot;memory&quot;) \<br>    .queryName(&quot;hasil_window&quot;) \<br>    .start()<br><br>print(&quot;Streaming query window waktu dimulai.&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/321/1*ileAMXw-q2SOlmMnBGxw0Q.png" /></figure><p>Hasil agregasi akan disimpan dalam memory sink dengan nama tabel hasil_window.</p><p><strong>F. Mengirim Data dengan Timestamp</strong></p><p>Setelah streaming query berjalan, tambahkan data transaksi dengan waktu saat ini.</p><p>Kode program:</p><pre>from datetime import datetime<br><br># Mengirim data dengan timestamp saat ini<br>waktu_sekarang = datetime.now()<br>pd.DataFrame({<br>    &quot;trx_id&quot;: [&quot;W1&quot;, &quot;W2&quot;],<br>    &quot;kota&quot;: [&quot;Semarang&quot;, &quot;Solo&quot;],<br>    &quot;pendapatan&quot;: [120000, 180000],<br>    &quot;waktu_transaksi&quot;: [waktu_sekarang.strftime(&quot;%Y-%m-%d %H:%M:%S&quot;)] * 2,<br>}).to_csv(f&quot;{folder_stream2}/batch_w1.csv&quot;, index=False)<br><br>time.sleep(6)<br>spark.sql(&quot;SELECT window.start, window.end, total_pendapatan, jumlah_transaksi FROM hasil_window&quot;).show(truncate=False)</pre><p>Data yang dikirim terdiri dari:</p><p><strong>Data yang dikirim terdiri dari:</strong></p><p><strong>W1</strong></p><ul><li>Kota: Semarang</li><li>Pendapatan: Rp120.000</li></ul><p><strong>W2</strong></p><ul><li>Kota: Solo</li><li>Pendapatan: Rp180.000</li></ul><p>Kedua transaksi menggunakan waktu yang sama sehingga akan masuk ke window waktu satu menit yang sama.</p><p>Hasil yang ditampilkan:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/601/1*iZoMgYPESIfX7TDgVnu7DQ.png" /></figure><p>Hasil query juga menampilkan kolom window.start dan window.end yang menunjukkan batas awal dan akhir dari rentang waktu satu menit.</p><p><strong>G. Menghentikan Query dan SparkSession</strong></p><p>Setelah seluruh proses selesai, hentikan streaming query kedua dan tutup SparkSession.</p><p>Kode program:</p><pre>query2.stop()<br><br>spark.stop()<br>print(&quot;Seluruh streaming query dihentikan.&quot;)<br>print(&quot;SparkSession ditutup.&quot;)</pre><p>Perintah tersebut digunakan untuk menghentikan proses streaming dan menutup sesi Spark.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/471/1*1Bp85wKNAgmwYxH4qdFYNA.png" /></figure><h3>4. LATIHAN MANDIRI</h3><h4>4.1 Persiapan Latihan</h4><p>Pada latihan mandiri, dilakukan pengolahan data streaming berdasarkan kategori dengan menghitung nilai rata-rata pendapatan.</p><p>Langkah pertama adalah membuat SparkSession dan folder latihan.</p><p>Kode program:</p><pre>spark = SparkSession.builder.appName(&quot;Latihan10&quot;).master(&quot;local[*]&quot;).getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br>spark.conf.set(&quot;spark.sql.shuffle.partitions&quot;, &quot;4&quot;)<br><br>folder_latihan = &quot;latihan10_stream&quot;<br>shutil.rmtree(folder_latihan, ignore_errors=True)<br>os.makedirs(folder_latihan, exist_ok=True)<br><br>skema_latihan = StructType([<br>    StructField(&quot;trx_id&quot;, StringType(), True),<br>    StructField(&quot;kategori&quot;, StringType(), True),<br>    StructField(&quot;pendapatan&quot;, IntegerType(), True),<br>])<br>print(&quot;Siap untuk latihan. Folder:&quot;, folder_latihan)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/377/1*5YIInPBKrib5QHhQsT7sbg.png" /></figure><h4>4.2 Soal 1 — Membuat Agregasi Rata-Rata Pendapatan</h4><p>Soal:</p><p>Definisikan readStream dari folder latihan10_stream menggunakan skema_latihan, kemudian buat agregasi berdasarkan kategori yang menghitung rata-rata pendapatan menggunakan fungsi avg.</p><p>Kode jawaban:</p><pre>from pyspark.sql.functions import avg<br><br>df_latihan = spark.readStream \<br>    .schema(skema_latihan) \<br>    .option(&quot;header&quot;, True) \<br>    .csv(folder_latihan)<br><br>hasil_latihan = df_latihan.groupBy(&quot;kategori&quot;) \<br>    .agg(avg(&quot;pendapatan&quot;).alias(&quot;rata_rata_pendapatan&quot;))<br><br>query = hasil_latihan.writeStream \<br>    .outputMode(&quot;complete&quot;) \<br>    .format(&quot;memory&quot;) \<br>    .queryName(&quot;latihan_agg&quot;) \<br>    .start()<br><br>print(&quot;Streaming query latihan berhasil dijalankan.&quot;)</pre><p>Penjelasan:</p><ol><li>spark.readStream digunakan untuk membaca data secara streaming.</li><li>.schema(skema_latihan) menggunakan skema yang sudah didefinisikan pada persiapan latihan.</li><li>.csv(folder_latihan) membaca berkas CSV dari folder latihan10_stream.</li><li>.groupBy(&quot;kategori&quot;) mengelompokkan data berdasarkan kategori.</li><li>avg(&quot;pendapatan&quot;) menghitung rata-rata pendapatan, bukan total atau jumlah pendapatan.</li><li>.queryName(&quot;latihan_agg&quot;) memberikan nama query sesuai instruksi.</li><li>.format(&quot;memory&quot;) memungkinkan hasil agregasi ditampilkan melalui spark.sql() pada Soal 2 dan Soal 3.</li><li>.outputMode(&quot;complete&quot;) menampilkan keseluruhan hasil agregasi setiap kali ada pembaruan data.</li></ol><h4>4.3 Soal 2 — Mengirim Batch Pertama</h4><p>Soal:</p><p>Kirim sebuah file CSV yang berisi minimal tiga baris data ke folder latihan, kemudian tampilkan hasil agregasinya.</p><p>Kode jawaban:</p><pre>import pandas as pd<br>import time<br><br># Membuat data batch pertama<br>data_batch1 = pd.DataFrame([<br>    [&quot;T001&quot;, &quot;Elektronik&quot;, 300000],<br>    [&quot;T002&quot;, &quot;Elektronik&quot;, 500000],<br>    [&quot;T003&quot;, &quot;Makanan&quot;, 100000]<br>], columns=[&quot;trx_id&quot;, &quot;kategori&quot;, &quot;pendapatan&quot;])<br><br># Menyimpan data ke folder streaming<br>data_batch1.to_csv(<br>    os.path.join(folder_latihan, &quot;batch1.csv&quot;),<br>    index=False<br>)<br><br># Memberikan waktu untuk proses streaming<br>time.sleep(5)<br><br># Menampilkan hasil agregasi<br>spark.sql(&quot;SELECT * FROM latihan_agg&quot;).show()</pre><p>Hasil yang ditampilkan:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/308/1*LCi6fI5QsEqiiuZVKgKL3w.png" /></figure><p>Penjelasan:</p><p>Pada pengujian pertama, dibuat tiga data transaksi yang terdiri dari dua transaksi kategori Elektronik dan satu transaksi kategori Makanan.</p><p>Data tersebut disimpan dalam file batch1.csv ke dalam folder latihan10_stream. Setelah file dibuat, Spark Structured Streaming akan mendeteksi dan memproses file tersebut.</p><p>Perintah time.sleep(5) digunakan untuk memberikan jeda agar proses streaming memiliki waktu untuk membaca dan memproses data sebelum hasilnya ditampilkan.</p><h4>4.4 Soal 3 — Mengirim Batch Kedua</h4><p>Soal:</p><p>Kirim batch kedua dengan kategori yang sama seperti salah satu kategori pada batch pertama. Kemudian amati perubahan nilai rata-rata pendapatannya.</p><p>Kode jawaban:</p><pre># Membuat data batch kedua<br>data_batch2 = pd.DataFrame([<br>    [&quot;T004&quot;, &quot;Elektronik&quot;, 700000],<br>    [&quot;T005&quot;, &quot;Makanan&quot;, 300000]<br>], columns=[&quot;trx_id&quot;, &quot;kategori&quot;, &quot;pendapatan&quot;])<br><br># Menyimpan data batch kedua<br>data_batch2.to_csv(<br>    os.path.join(folder_latihan, &quot;batch2.csv&quot;),<br>    index=False<br>)<br><br># Memberikan waktu untuk proses streaming<br>time.sleep(5)<br><br># Menampilkan hasil agregasi terbaru<br>spark.sql(&quot;SELECT * FROM latihan_agg&quot;).show()</pre><p>Hasil yang ditampilkan:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/308/1*nzBcZJffyUVFYTPlsUC-5g.png" /></figure><p>Penjelasan:</p><p>Pada pengujian kedua, ditambahkan dua transaksi baru dengan kategori yang sama seperti kategori pada batch pertama, yaitu Elektronik dan Makanan.</p><p>Data tersebut disimpan dalam file batch2.csv. Setelah file masuk ke folder streaming, Spark akan membaca transaksi baru dan memperbarui hasil agregasi berdasarkan seluruh data yang telah diproses.</p><h3>4.5 Soal 4 — Refleksi</h3><p>Soal:</p><p>Mengapa Spark Structured Streaming mewajibkan skema didefinisikan secara eksplisit menggunakan StructType, sementara pemrosesan batch dapat menggunakan inferSchema=True?</p><p>Jawaban:</p><p><em>Spark Structured Streaming membutuhkan skema yang sudah ditentukan karena data yang masuk diproses secara bertahap. Jadi, Spark perlu mengetahui nama dan tipe data setiap kolom sejak awal agar bisa membaca dan mengolah data dengan benar.</em></p><p><em>Berbeda dengan pemrosesan batch, yang bisa menggunakan </em><em>inferSchema=True untuk menebak tipe data dari file yang tersedia. Pada streaming, data bisa terus bertambah saat proses sedang berjalan. Karena itu, kita perlu menggunakan </em><em>StructType agar struktur datanya sudah jelas sejak awal.</em></p><p>Setelah seluruh latihan selesai, hentikan streaming query dan SparkSession:</p><pre>query.stop()<br>spark.stop()</pre><h3>5. TUGAS MANDIRI — STUDI KASUS KOPI NUSANTARA</h3><h4>5.1 Deskripsi Tugas</h4><p>Pada tugas mandiri ini, digunakan studi kasus sebuah usaha bernama Kopi Nusantara.</p><p>Manajemen Kopi Nusantara ingin membangun dashboard pemantauan pesanan secara real-time untuk mengetahui performa setiap cabang.</p><p>Sistem yang dibuat akan menggunakan Spark Structured Streaming untuk membaca data pesanan yang masuk secara bertahap, menghitung total pendapatan, serta mengelompokkan transaksi berdasarkan cabang dan waktu.</p><p>Tugas ini terdiri dari lima bagian, yaitu:</p><p>A. Menyiapkan Streaming Source.<br>B. Agregasi per Cabang.<br>C. Agregasi Berbasis Window Waktu.<br>D. Menguji dengan Data Simulasi.<br>E. Sink Berbasis Berkas.</p><h4>5.2 Bagian A — Menyiapkan Streaming Source</h4><p>Langkah pertama adalah membuat SparkSession dan mendefinisikan skema data pesanan.</p><p>Kode program:</p><pre>import os<br>import shutil<br>import time<br>import pandas as pd<br><br>from pyspark.sql import SparkSession<br>from pyspark.sql.types import (<br>    StructType,<br>    StructField,<br>    StringType,<br>    IntegerType,<br>    TimestampType<br>)<br>from pyspark.sql.functions import col, sum, count, window<br><br># Membuat SparkSession<br>spark = SparkSession.builder \<br>    .appName(&quot;Tugas10_KopiNusantara&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br><br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br>spark.conf.set(&quot;spark.sql.shuffle.partitions&quot;, &quot;4&quot;)<br><br>print(&quot;SparkSession berhasil dibuat.&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/219/1*jaLebA45gRmAAOsyqcn27w.png" /></figure><pre># Membuat folder simulasi streaming<br>folder_stream = &quot;tugas10_stream&quot;<br><br>shutil.rmtree(folder_stream, ignore_errors=True)<br>os.makedirs(folder_stream, exist_ok=True)<br><br># Mendefinisikan skema data pesanan<br>skema_pesanan = StructType([<br>    StructField(&quot;pesanan_id&quot;, StringType(), True),<br>    StructField(&quot;nama_cabang&quot;, StringType(), True),<br>    StructField(&quot;nama_menu&quot;, StringType(), True),<br>    StructField(&quot;qty&quot;, IntegerType(), True),<br>    StructField(&quot;harga_satuan&quot;, IntegerType(), True),<br>    StructField(&quot;waktu_pesan&quot;, TimestampType(), True)<br>])<br><br># Membaca data menggunakan readStream<br>df_stream = spark.readStream \<br>    .schema(skema_pesanan) \<br>    .option(&quot;header&quot;, True) \<br>    .option(&quot;timestampFormat&quot;, &quot;yyyy-MM-dd HH:mm:ss&quot;) \<br>    .csv(folder_stream)<br><br>print(&quot;Folder streaming berhasil disiapkan:&quot;, folder_stream)<br>df_stream.printSchema()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/390/1*rS0cUOv5xZH7EKcuMqQymw.png" /></figure><p><strong>Penjelasan:</strong></p><p>Pertama, folder tugas10_stream dibuat sebagai tempat masuknya data pesanan secara bertahap. Folder tersebut dikosongkan terlebih dahulu agar tidak ada data lama yang ikut terbaca ketika program dijalankan kembali.</p><p>Selanjutnya, StructType digunakan untuk menentukan struktur data pesanan. Setiap kolom diberikan tipe data yang sesuai, termasuk TimestampType() untuk menyimpan waktu pemesanan.</p><p>Perintah spark.readStream digunakan untuk membaca file CSV yang nantinya dimasukkan ke folder tugas10_stream. Dengan demikian, Spark dapat mendeteksi dan memproses file baru secara otomatis selama proses streaming berjalan.</p><h4>5.3 Bagian B — Agregasi per Cabang</h4><p>Pada bagian ini, kita diminta menghitung total pendapatan dan jumlah pesanan dari setiap cabang Kopi Nusantara.</p><p>Perhitungan pendapatan dilakukan dengan mengalikan jumlah pesanan (qty) dengan harga satuan (harga_satuan). Hasil perkalian tersebut disimpan dalam kolom baru bernama total_harga.</p><p>Kode program:</p><pre># Membuat kolom turunan total_harga<br>df_stream_harga = df_stream.withColumn(<br>    &quot;total_harga&quot;,<br>    col(&quot;qty&quot;) * col(&quot;harga_satuan&quot;)<br>)<br><br># Mengelompokkan data berdasarkan nama cabang<br>agregasi_cabang = df_stream_harga.groupBy(&quot;nama_cabang&quot;) \<br>    .agg(<br>        sum(&quot;total_harga&quot;).alias(&quot;total_pendapatan&quot;),<br>        count(&quot;*&quot;).alias(&quot;jumlah_pesanan&quot;)<br>    )<br><br># Menjalankan streaming query<br>query1 = agregasi_cabang.writeStream \<br>    .outputMode(&quot;complete&quot;) \<br>    .format(&quot;memory&quot;) \<br>    .queryName(&quot;agregasi_cabang&quot;) \<br>    .start()<br>spark.sql(&quot;SELECT * FROM agregasi_cabang&quot;).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/302/1*vr-zqmLa7YDk4IA4bMGmHQ.png" /></figure><p><strong>Penjelasan:</strong></p><p>Pada bagian pertama, withColumn() digunakan untuk menambahkan kolom baru bernama total_harga. Nilainya diperoleh dari hasil perkalian antara qty dan harga_satuan.</p><p>Setelah itu, groupBy(&quot;nama_cabang&quot;) digunakan untuk mengelompokkan seluruh pesanan berdasarkan nama cabang.</p><p>Fungsi sum(&quot;total_harga&quot;) digunakan untuk menghitung total pendapatan setiap cabang, sedangkan count(&quot;*&quot;) digunakan untuk menghitung jumlah pesanan yang masuk.</p><p>Hasil agregasi kemudian dijalankan menggunakan streaming query dengan sink memory dan nama query agregasi_cabang. Mode complete digunakan agar seluruh hasil agregasi ditampilkan kembali setiap kali terdapat data baru.</p><p>Dengan demikian, manajemen Kopi Nusantara dapat memantau total pendapatan dan jumlah pesanan dari setiap cabang secara berkala.</p><h4>5.4 Bagian C — Agregasi Berbasis Window Waktu</h4><p>Pada bagian ini, kita diminta membuat streaming query kedua yang menghitung total pendapatan berdasarkan window waktu selama 2 menit.</p><p>Untuk menjalankan query kedua, kita perlu mendefinisikan ulang readStream dari folder tugas10_stream. Hal ini diperbolehkan karena satu sumber data dapat dibaca oleh beberapa streaming query secara bersamaan.Pada bagian ini, kita diminta membuat streaming query kedua yang menghitung total pendapatan berdasarkan window waktu selama 2 menit.</p><p>Untuk menjalankan query kedua, kita perlu mendefinisikan ulang readStream dari folder tugas10_stream. Hal ini diperbolehkan karena satu sumber data dapat dibaca oleh beberapa streaming query secara bersamaan.</p><p>Kode program:</p><pre># Membaca ulang sumber data streaming<br>df_window = spark.readStream \<br>    .schema(skema_pesanan) \<br>    .option(&quot;header&quot;, True) \<br>    .option(&quot;timestampFormat&quot;, &quot;yyyy-MM-dd HH:mm:ss&quot;) \<br>    .csv(folder_stream)<br><br># Membuat kolom total_harga<br>df_window_harga = df_window.withColumn(<br>    &quot;total_harga&quot;,<br>    col(&quot;qty&quot;) * col(&quot;harga_satuan&quot;)<br>)<br><br># Agregasi berdasarkan window waktu 2 menit<br>agregasi_waktu = df_window_harga.groupBy(<br>    window(col(&quot;waktu_pesan&quot;), &quot;2 minutes&quot;)<br>).agg(<br>    sum(&quot;total_harga&quot;).alias(&quot;total_pendapatan&quot;)<br>)<br><br># Menjalankan streaming query kedua<br>query2 = agregasi_waktu.writeStream \<br>    .outputMode(&quot;complete&quot;) \<br>    .format(&quot;memory&quot;) \<br>    .queryName(&quot;agregasi_waktu&quot;) \<br>    .start()<br><br>spark.sql(&quot;SELECT * FROM agregasi_waktu&quot;).show(truncate=False)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/172/1*zSc_xcG7c0wLekYs_dHQmQ.png" /></figure><p>Penjelasan:</p><ul><li>Pada bagian ini, readStream didefinisikan kembali untuk membaca data dari folder yang sama. Data tersebut kemudian ditambahkan kolom total_harga menggunakan perhitungan jumlah pesanan dikalikan harga satuan.</li><li>Perbedaan utama dari bagian sebelumnya terletak pada penggunaan fungsi window(). Fungsi tersebut digunakan untuk mengelompokkan data berdasarkan rentang waktu tertentu.</li><li>Pengaturan window(col(&quot;waktu_pesan&quot;), &quot;2 minutes&quot;) berarti Spark akan mengelompokkan transaksi ke dalam interval waktu selama 2 menit berdasarkan kolom waktu_pesan.</li><li>Selanjutnya, fungsi sum(&quot;total_harga&quot;) digunakan untuk menghitung total pendapatan dalam setiap window waktu.</li><li>Hasilnya disimpan menggunakan sink memory dengan nama query agregasi_waktu.</li></ul><h4>5.5 Bagian D — Menguji dengan Data Simulasi</h4><p>Pada bagian ini, kita diminta mengirimkan minimal tiga batch data ke folder tugas10_stream. Setiap batch harus berupa file CSV baru dan diberikan jeda waktu menggunakan time.sleep().</p><p>Data simulasi menggunakan tiga cabang Kopi Nusantara, yaitu Magelang, Solo, dan Yogyakarta.</p><p><strong>A. Mengirim Batch Pertama</strong></p><p>Kode program:</p><pre>from datetime import datetime, timedelta<br><br>batch1 = pd.DataFrame([<br>    [&quot;P001&quot;, &quot;Magelang&quot;, &quot;Kopi Susu&quot;, 2, 18000, &quot;2026-11-11 09:00:10&quot;],<br>    [&quot;P002&quot;, &quot;Magelang&quot;, &quot;Americano&quot;, 1, 20000, &quot;2026-11-11 09:00:30&quot;],<br>    [&quot;P003&quot;, &quot;Solo&quot;, &quot;Cappuccino&quot;, 1, 28000, &quot;2026-11-11 09:01:00&quot;]<br>], columns=[<br>    &quot;pesanan_id&quot;,<br>    &quot;nama_cabang&quot;,<br>    &quot;nama_menu&quot;,<br>    &quot;qty&quot;,<br>    &quot;harga_satuan&quot;,<br>    &quot;waktu_pesan&quot;<br>])<br><br>batch1.to_csv(<br>    f&quot;{folder_stream}/batch1.csv&quot;,<br>    index=False<br>)<br><br>time.sleep(5)<br><br>query1.processAllAvailable()<br>query2.processAllAvailable()<br><br>spark.sql(&quot;SELECT * FROM agregasi_cabang&quot;).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/294/1*NscRRmY1Jf7s6i55Nzh0jA.png" /></figure><p>Data batch pertama dibuat menggunakan Pandas DataFrame, kemudian disimpan dalam bentuk CSV dengan nama batch1.csv.</p><p>Setelah file dibuat, program menunggu selama lima detik menggunakan time.sleep(5). Selanjutnya, processAllAvailable() digunakan untuk memastikan data yang tersedia sudah diproses oleh streaming query.</p><p>Perintah SQL kemudian digunakan untuk menampilkan hasil agregasi berdasarkan cabang.</p><p><strong>B. Mengirim Batch Kedua</strong></p><p>Kode program:</p><pre># Data kedua<br>batch2 = pd.DataFrame([<br>    [&quot;P004&quot;, &quot;Yogyakarta&quot;, &quot;Matcha Latte&quot;, 2, 25000, &quot;2026-11-11 09:02:10&quot;],<br>    [&quot;P005&quot;, &quot;Magelang&quot;, &quot;Kopi Hitam&quot;, 3, 15000, &quot;2026-11-11 09:02:30&quot;],<br>    [&quot;P006&quot;, &quot;Solo&quot;, &quot;Espresso&quot;, 1, 20000, &quot;2026-11-11 09:03:00&quot;]<br>], columns=[<br>    &quot;pesanan_id&quot;,<br>    &quot;nama_cabang&quot;,<br>    &quot;nama_menu&quot;,<br>    &quot;qty&quot;,<br>    &quot;harga_satuan&quot;,<br>    &quot;waktu_pesan&quot;<br>])<br><br>batch2.to_csv(<br>    f&quot;{folder_stream}/batch2.csv&quot;,<br>    index=False<br>)<br><br>time.sleep(5)<br><br>query1.processAllAvailable()<br>query2.processAllAvailable()<br><br>spark.sql(&quot;SELECT * FROM agregasi_cabang&quot;).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/298/1*QNkD4SoyPpvKsOcz6Liutg.png" /></figure><p>Batch kedua disimpan dengan nama batch2.csv agar tidak menimpa file sebelumnya. Setelah file dimasukkan ke folder streaming, Spark akan membaca data baru tersebut dan memperbarui hasil agregasi.</p><p><strong>C. Mengirim Batch Ketiga</strong></p><p>Kode program:</p><pre>batch3 = pd.DataFrame([<br>    [&quot;P007&quot;, &quot;Magelang&quot;, &quot;Caramel Latte&quot;, 1, 45000, &quot;2026-11-11 09:04:10&quot;],<br>    [&quot;P008&quot;, &quot;Yogyakarta&quot;, &quot;Latte&quot;, 1, 20000, &quot;2026-11-11 09:04:30&quot;]<br>], columns=[<br>    &quot;pesanan_id&quot;,<br>    &quot;nama_cabang&quot;,<br>    &quot;nama_menu&quot;,<br>    &quot;qty&quot;,<br>    &quot;harga_satuan&quot;,<br>    &quot;waktu_pesan&quot;<br>])<br><br>batch3.to_csv(<br>    f&quot;{folder_stream}/batch3.csv&quot;,<br>    index=False<br>)<br><br>time.sleep(5)<br><br>query1.processAllAvailable()<br>query2.processAllAvailable()<br><br>spark.sql(&quot;SELECT * FROM agregasi_cabang&quot;).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/292/1*6IqWTka9H5Vit8l923U4vg.png" /></figure><p>Pada batch ketiga, dua data transaksi baru dimasukkan ke folder tugas10_stream. Setelah menunggu beberapa detik, Spark memproses file tersebut dan memperbarui hasil agregasi.</p><p>Dengan menggunakan nama file yang berbeda pada setiap batch, seluruh transaksi dapat dibaca sebagai data baru tanpa menimpa file sebelumnya.</p><h4>5.6 Bagian E — Sink Berbasis Berkas</h4><p>Pada tahap ini, dilakukan pengujian penyimpanan data streaming ke dalam format Parquet menggunakan fitur File Sink pada Apache Spark Structured Streaming. Tujuannya adalah untuk membuktikan bahwa data pesanan yang diterima secara streaming dapat disimpan ke dalam media penyimpanan berbasis file sehingga dapat dibaca dan digunakan kembali untuk proses analisis data.</p><p>Sebelum menjalankan proses penyimpanan, seluruh streaming query yang masih aktif dihentikan terlebih dahulu untuk menghindari konflik proses. Selanjutnya, folder output dan checkpoint lama dihapus agar pengujian dapat dimulai dengan kondisi yang bersih. Folder output digunakan sebagai tempat penyimpanan file Parquet, sedangkan folder checkpoint berfungsi untuk mencatat perkembangan pemrosesan data oleh Spark.</p><p>Setelah persiapan selesai, dibuat streaming query ketiga dengan menggunakan writeStream dan format parquet. Query tersebut membaca data dari df_stream, kemudian menyimpannya ke direktori tugas10_output dengan mode append. Mode ini memungkinkan data baru ditambahkan ke penyimpanan tanpa menghapus data yang telah tersimpan sebelumnya.</p><p>Untuk menguji proses tersebut, dibuat batch data baru yang berisi satu pesanan, yaitu P009 dari cabang Magelang dengan menu Kopi Susu. Data kemudian disimpan dalam bentuk file CSV ke folder tugas10_stream agar dapat dideteksi dan diproses oleh streaming query.</p><p>Kode program:</p><pre># 1. Menghentikan seluruh streaming query yang masih aktif<br>for query in spark.streams.active:<br>    query.stop()<br><br>print(&quot;Semua streaming query berhasil dihentikan.&quot;)<br><br># 2. Menghapus folder output dan checkpoint lama<br>shutil.rmtree(&quot;tugas10_output&quot;, ignore_errors=True)<br>shutil.rmtree(&quot;tugas10_checkpoint_baru&quot;, ignore_errors=True)<br><br># Membuat folder output<br>os.makedirs(&quot;tugas10_output&quot;, exist_ok=True)<br><br>print(&quot;Folder output dan checkpoint siap digunakan.&quot;)<br><br># 3. Membuat streaming query ketiga<br>query3 = df_stream.writeStream \<br>    .format(&quot;parquet&quot;) \<br>    .option(&quot;path&quot;, &quot;tugas10_output&quot;) \<br>    .option(&quot;checkpointLocation&quot;, &quot;tugas10_checkpoint_baru&quot;) \<br>    .outputMode(&quot;append&quot;) \<br>    .start()<br><br>print(&quot;Streaming query ketiga berhasil dijalankan.&quot;)<br><br># 4. Membuat batch data baru<br>data_batch4 = [<br>    (&quot;P009&quot;, &quot;Magelang&quot;, &quot;Kopi Susu&quot;, 1, 18000, &quot;2026-11-11 09:05:10&quot;)<br>]<br><br>df_batch4 = pd.DataFrame(<br>    data_batch4,<br>    columns=[<br>        &quot;pesanan_id&quot;,<br>        &quot;nama_cabang&quot;,<br>        &quot;nama_menu&quot;,<br>        &quot;qty&quot;,<br>        &quot;harga_satuan&quot;,<br>        &quot;waktu_pesan&quot;<br>    ]<br>)<br><br># Menyimpan batch ke folder streaming<br>df_batch4.to_csv(<br>    &quot;tugas10_stream/batch4.csv&quot;,<br>    index=False<br>)<br><br>print(&quot;Batch 4 berhasil dibuat.&quot;)<br><br># 5. Menunggu dan memproses data streaming<br>time.sleep(5)<br>query3.processAllAvailable()<br><br>print(&quot;Data berhasil diproses.&quot;)<br><br># 6. Memeriksa file Parquet yang dihasilkan<br>print(&quot;\nDaftar file dalam folder output:&quot;)<br>print(os.listdir(&quot;tugas10_output&quot;))<br><br># 7. Membaca kembali data Parquet<br>df_hasil = spark.read.parquet(&quot;tugas10_output&quot;)<br><br>print(&quot;\nHasil pembacaan data Parquet:&quot;)<br>df_hasil.show(truncate=False)<br><br># 8. Menghentikan streaming query<br>query3.stop()<br><br>print(&quot;Streaming query ketiga berhasil dihentikan.&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/893/1*mU5tHXl7vKI-zf91tiLkiw.png" /></figure><p>Setelah batch data baru dikirimkan, Spark diberikan waktu untuk mendeteksi file tersebut. Selanjutnya, metode processAllAvailable() digunakan untuk memastikan seluruh data yang tersedia telah diproses oleh streaming query. Hasil penyimpanan kemudian diperiksa menggunakan perintah ls untuk melihat file-file yang terbentuk di dalam direktori tugas10_output.</p><p>Tahap berikutnya adalah membaca kembali data yang telah disimpan menggunakan perintah spark.read.parquet(). Data tersebut kemudian ditampilkan menggunakan metode show() untuk memastikan bahwa proses penyimpanan dan pembacaan kembali berhasil dilakukan.</p><p>Berdasarkan proses tersebut, dapat diketahui bahwa Apache Spark Structured Streaming mampu menerima data baru dari sumber CSV dan menyimpannya ke dalam format Parquet secara berkelanjutan. Format Parquet memiliki keunggulan dalam penyimpanan kolumnar sehingga efisien untuk kebutuhan pembacaan dan analisis data berukuran besar.</p><h4>F. Menghentikan Seluruh Streaming Query</h4><p>Setelah seluruh pengujian selesai, hentikan semua streaming query yang masih berjalan.</p><p>Kode program:</p><pre>query1.stop()<br>query2.stop()<br>query3.stop()<br><br>spark.stop()<br><br>print(&quot;Seluruh streaming query berhasil dihentikan.&quot;)<br>print(&quot;SparkSession ditutup.&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/293/1*OSXE4YaWdifjTVUG-Wg0Nw.png" /></figure><h3>6. Kesimpulan</h3><p>Berdasarkan praktikum yang telah dilakukan, dapat disimpulkan bahwa:</p><ol><li>Batch Processing merupakan metode pengolahan data yang dilakukan terhadap sekumpulan data yang telah tersedia, sedangkan Stream Processing mengolah data secara berkelanjutan ketika data baru masuk.</li><li>Spark Structured Streaming merupakan fitur Apache Spark yang memungkinkan pemrosesan data streaming menggunakan DataFrame API.</li><li>Penggunaan readStream memungkinkan Spark membaca data baru secara inkremental dari sumber streaming.</li><li>Skema data pada streaming berbasis file harus didefinisikan secara eksplisit menggunakan StructType.</li><li>Fungsi agregasi seperti sum(), count(), dan avg() dapat digunakan untuk mengolah data streaming berdasarkan kelompok tertentu.</li><li>Fungsi window() memungkinkan pengelompokan data berdasarkan rentang waktu tertentu.</li><li>Memory sink dapat digunakan untuk menyimpan hasil sementara yang dapat diakses melalui Spark SQL.</li><li>File sink dengan format Parquet memungkinkan hasil pemrosesan streaming disimpan dan dibaca kembali sebagai DataFrame batch.</li><li>Spark Structured Streaming dapat diterapkan pada sistem pemantauan transaksi dan penjualan seperti studi kasus Kopi Nusantara.</li></ol><p>Melalui praktikum ini, pemahaman mengenai pemrosesan data streaming menggunakan PySpark menjadi lebih baik, terutama dalam membangun streaming query, melakukan agregasi, serta menyimpan hasil pemrosesan ke dalam format Parquet.</p><h3>GitHub</h3><p><a href="https://github.com/manggalaayudha/Praktikum-BigData/tree/4fb5fcdc940e7f88dece08e856cde920f3d0b1c7/Pertemuan-10">https://github.com/manggalaayudha/Praktikum-BigData/tree/4fb5fcdc940e7f88dece08e856cde920f3d0b1c7/Pertemuan-10</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=562f0299fb1c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PBO: Interface]]></title>
            <link>https://medium.com/@bagusmanggalayudha/pbo-interface-6bc751290a4c?source=rss-2518abaf0d61------2</link>
            <guid isPermaLink="false">https://medium.com/p/6bc751290a4c</guid>
            <category><![CDATA[netbeans]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[interfaces]]></category>
            <dc:creator><![CDATA[Bagus Manggala Yudha]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 01:26:39 GMT</pubDate>
            <atom:updated>2026-11-04T01:29:59.172Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x9X3Gjx7s-Cm22u2LXbh2w.png" /></figure><p><strong>Halo Semuanya!</strong></p><p>Saya Bagus Manggala Yudha, mahasiswa Teknologi Informasi di Universitas Tidar. Pada Praktikum Pemrograman Berorientasi Objek kali ini, kita akan mempelajari tentang Interface pada bahasa pemrograman Java di software NetBeans.</p><h3>1. PENDAHULUAN</h3><h4>1.1 Tujuan Praktikum</h4><p>Tujuan dari praktikum ini adalah:</p><ol><li>Memahami konsep dan tujuan penggunaan interface dalam Pemrograman Berorientasi Objek (PBO).</li><li>Mampu membuat dan mengimplementasikan interface pada kelas Java.</li><li>Memahami penggunaan keyword implements dalam mengimplementasikan interface.</li><li>Memahami konsep inheritance pada interface.</li><li>Mampu menggunakan interface untuk menciptakan abstraksi yang dapat diterapkan pada berbagai kelas.</li><li>Memahami penerapan multiple interface dalam bahasa pemrograman Java.</li></ol><h4>1.2 Dasar Teori</h4><p><strong>A. Pengertian Interface</strong></p><p>Interface merupakan salah satu konsep dalam Pemrograman Berorientasi Objek (PBO) yang berfungsi sebagai kontrak atau aturan bagi kelas yang mengimplementasikannya.</p><p>Dalam Java, interface digunakan untuk mendefinisikan metode tanpa implementasi. Artinya, interface hanya menentukan metode apa saja yang harus dimiliki oleh sebuah kelas, sedangkan isi atau logika dari metode tersebut ditentukan oleh kelas yang mengimplementasikannya.</p><p>Interface memiliki kemiripan dengan kelas abstrak, tetapi keduanya mempunyai perbedaan. Interface lebih berfokus pada pendefinisian kontrak implementasi yang harus dipenuhi oleh suatu kelas.</p><p>Secara default:</p><ul><li>Metode dalam interface bersifat public dan abstract.</li><li>Variabel dalam interface bersifat public, static, dan final.</li><li>Interface tidak dapat dibuat objeknya secara langsung.</li></ul><p><strong>B. Mengimplementasikan Interface</strong></p><p>Untuk menggunakan interface pada sebuah kelas, Java menyediakan keyword implements.</p><p>Ketika sebuah kelas mengimplementasikan interface, kelas tersebut harus menyediakan implementasi untuk seluruh metode abstrak yang didefinisikan dalam interface.</p><p>Contoh deklarasi:</p><pre>interface Operasi {<br>    int hitung(int a, int b);<br>}</pre><pre>class Penjumlahan implements Operasi {<br>    @Override<br>    public int hitung(int a, int b) {<br>        return a + b;<br>    }<br>}</pre><p>Pada contoh tersebut, kelas Penjumlahan mengimplementasikan interface Operasi dan memberikan isi pada metode hitung().</p><p>Apabila sebuah kelas tidak mengimplementasikan seluruh metode abstrak dari interface, kelas tersebut harus dideklarasikan sebagai kelas abstrak.</p><p><strong>C. Inheritance pada Interface</strong></p><p>Inheritance pada interface merupakan konsep pewarisan yang memungkinkan sebuah interface mewarisi interface lainnya menggunakan keyword extends.</p><p>Dengan konsep ini, sebuah interface dapat memperoleh metode dari interface lain dan menggabungkannya dengan metode yang dimilikinya sendiri.</p><p>Selain itu, sebuah kelas juga dapat mengimplementasikan lebih dari satu interface sehingga memungkinkan penggunaan beberapa kontrak atau fungsi dalam satu kelas.</p><p><strong>D. Implementasi Multiple Interface</strong></p><p>Multiple interface merupakan kemampuan sebuah kelas untuk mengimplementasikan lebih dari satu interface sekaligus.</p><p>Dengan fitur ini, sebuah kelas dapat memiliki beberapa fungsi atau tanggung jawab yang berasal dari interface berbeda.</p><p>Contohnya, sebuah kelas dapat mengimplementasikan interface Pembayaran dan interface CetakStruk secara bersamaan.</p><p>Jika sebuah kelas juga mewarisi kelas lain, urutan penulisannya adalah extends terlebih dahulu, kemudian implements.</p><p><strong>E. Kegunaan</strong> Interface</p><p>Interface memiliki beberapa kegunaan dalam pengembangan program, yaitu:</p><ol><li>Menentukan standar metode yang harus dimiliki oleh kelas tertentu.</li><li>Membantu menciptakan abstraksi dalam program.</li><li>Mempermudah pengembangan program karena setiap kelas dapat memiliki implementasi metode yang berbeda.</li><li>Mendukung penggunaan multiple interface.</li><li>Meningkatkan fleksibilitas dan skalabilitas aplikasi.</li><li>Memungkinkan beberapa kelas memiliki kemampuan atau tanggung jawab yang sama meskipun implementasinya berbeda.</li></ol><p><strong>F. Karakteristik Interface</strong></p><p>Beberapa karakteristik interface dalam Java adalah:</p><ol><li><strong>Deklarasi Metode Tanpa Implementasi:</strong> Interface mendefinisikan metode tanpa memberikan isi implementasinya.</li><li><strong>Multiple Inheritance:</strong> Sebuah kelas dapat mengimplementasikan lebih dari satu interface.</li><li><strong>Keyword Implements:</strong> Kelas yang menggunakan interface harus menggunakan keyword implements.</li></ol><p><strong>G. Perbedaan Interface dan Kelas Abstrak</strong></p><p>Interface dan kelas abstrak memiliki beberapa persamaan, tetapi terdapat perbedaan dalam penggunaannya.</p><p>InterfaceKelas AbstrakMetode abstrak secara default bersifat publicDapat memiliki metode abstrak dan konkretMendukung multiple inheritance melalui implementasi beberapa interfacePewarisan kelas hanya mendukung satu superclass langsungTidak memiliki konstruktorDapat memiliki konstruktorDigunakan untuk menyusun kontrak implementasiDigunakan untuk generalisasi perilaku</p><h3>2. ALAT DAN BAHAN</h3><p>Alat dan bahan yang digunakan dalam praktikum ini adalah:</p><ol><li>Laptop atau komputer.</li><li>Koneksi internet.</li><li>Web Browser seperti Google Chrome, Mozilla Firefox, atau Microsoft Edge.</li><li>JDK (Java Development Kit).</li><li>NetBeans IDE sebagai aplikasi untuk menulis dan menjalankan program Java.</li></ol><h3>3. LANGKAH KERJA PRAKTIKUM</h3><h4>3.1 Persiapan</h4><p>Sebelum memulai praktikum, dilakukan beberapa persiapan sebagai berikut:</p><ol><li>Membuka aplikasi NetBeans IDE yang sudah terinstal pada komputer.</li><li>Membuat proyek baru dengan nama PraktikumPBO_10.</li><li>Membuat package baru dengan nama praktikum10.</li><li>Menyiapkan beberapa file Java yang akan digunakan dalam praktikum.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/325/1*8BxY5Sr3kvlHC4GlRVX7LQ.png" /></figure><h4>3.2 Membuat dan Mengimplementasikan Interface</h4><p>Pada praktikum ini dibuat sebuah program sederhana menggunakan interface dengan studi kasus operasi hitung.</p><p>Program terdiri dari tiga bagian utama, yaitu:</p><ul><li>Interface OperasiHitung.</li><li>Kelas Penjumlahan.</li><li>Kelas Pengurangan.</li></ul><p>Selain itu, terdapat kelas Main yang digunakan untuk menjalankan program.</p><p><strong>A. Membuat Interface OperasiHitung</strong></p><p>Langkah pertama adalah membuat sebuah interface bernama OperasiHitung.</p><p>Kode program:</p><pre>public interface OperasiHitung {<br>    int hitung(int a, int b);<br>}</pre><p>Penjelasan:</p><ol><li>public interface OperasiHitung digunakan untuk mendeklarasikan interface dengan nama OperasiHitung.</li><li>int hitung(int a, int b) merupakan metode yang menerima dua parameter bertipe integer.</li><li>Metode hitung() tidak memiliki implementasi karena hanya berfungsi sebagai kontrak bagi kelas yang menggunakannya.</li></ol><p>Interface ini nantinya akan diimplementasikan oleh kelas Penjumlahan dan Pengurangan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/343/1*CANGNg9iMK-GP0MXc5ahTg.png" /></figure><p><strong>B. Membuat Kelas Penjumlahan</strong></p><p>Selanjutnya, buat kelas bernama Penjumlahan yang mengimplementasikan interface OperasiHitung.</p><p>Kode program:</p><pre>public class Penjumlahan implements OperasiHitung {<br>    @Override<br>    public int hitung(int a, int b) {<br>        return a + b;<br>    }<br>}</pre><p>Penjelasan:</p><ol><li>implements OperasiHitung menunjukkan bahwa kelas Penjumlahan menggunakan interface OperasiHitung.</li><li>@Override menunjukkan bahwa metode hitung() merupakan implementasi dari metode yang didefinisikan dalam interface.</li><li>public int hitung(int a, int b) merupakan implementasi metode untuk melakukan operasi penjumlahan.</li><li>return a + b digunakan untuk mengembalikan hasil penjumlahan kedua bilangan.</li></ol><p>Dengan demikian, kelas Penjumlahan memberikan implementasi berupa operasi penjumlahan terhadap dua angka.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/514/1*p6mkgNjH8Ao0CECDLBZ1UQ.png" /></figure><p><strong>C. Membuat Kelas Pengurangan</strong></p><p>Selanjutnya, buat kelas bernama Pengurangan yang juga mengimplementasikan interface OperasiHitung.</p><p>Kode program:</p><pre>public class Pengurangan implements OperasiHitung {<br>    @Override<br>    public int hitung(int a, int b) {<br>        return a - b;<br>    }<br>}</pre><p>Penjelasan:</p><ol><li>implements OperasiHitung menunjukkan bahwa kelas Pengurangan mengimplementasikan interface OperasiHitung.</li><li>@Override digunakan untuk menandai implementasi ulang metode hitung().</li><li>return a - b digunakan untuk melakukan operasi pengurangan terhadap dua bilangan.</li></ol><p>Meskipun kelas Penjumlahan dan Pengurangan menggunakan interface yang sama, keduanya memiliki implementasi metode hitung() yang berbeda.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/514/1*SCWKEX-MxRMgQQCPe5yToA.png" /></figure><p><strong>D. Membuat Main Class</strong></p><p>Setelah interface dan kedua kelas selesai dibuat, langkah selanjutnya adalah membuat kelas utama bernama Main.</p><p>Kode program:</p><pre>public class Main {<br>    public static void main(String[] args) {<br>        // Objek Penjumlahan<br>        OperasiHitung penjumlahan = new Penjumlahan();<br>        System.out.println(&quot;Penjumlahan: &quot;<br>                + penjumlahan.hitung(10, 5));<br>        // Objek Pengurangan<br>        OperasiHitung pengurangan = new Pengurangan();<br>        System.out.println(&quot;Pengurangan: &quot;<br>                + pengurangan.hitung(10, 5));<br>    }<br>}</pre><p>Penjelasan:</p><ol><li>public static void main(String[] args) merupakan metode utama yang pertama kali dijalankan ketika program dieksekusi.</li><li>OperasiHitung penjumlahan = new Penjumlahan() membuat objek Penjumlahan menggunakan referensi bertipe OperasiHitung.</li><li>penjumlahan.hitung(10, 5) memanggil metode hitung() dari kelas Penjumlahan.</li><li>OperasiHitung pengurangan = new Pengurangan() membuat objek Pengurangan menggunakan referensi bertipe OperasiHitung.</li><li>pengurangan.hitung(10, 5) memanggil metode hitung() dari kelas Pengurangan.</li></ol><p>Penggunaan interface sebagai tipe referensi memungkinkan objek dari kelas berbeda diperlakukan melalui kontrak metode yang sama.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/527/1*LzAJR6zl-XITAWdRsZEKgg.png" /></figure><h4>3.3 Menjalankan Program</h4><p>Setelah seluruh kelas selesai dibuat, jalankan program melalui kelas Main.</p><p>Langkah-langkahnya:</p><ol><li>Pastikan seluruh file Java sudah berada dalam package praktikum10.</li><li>Klik kanan pada file Main.java.</li><li>Pilih menu Run File.</li><li>Perhatikan hasil keluaran program pada bagian Output.</li></ol><p>Output yang ditampilkan:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*PWu_JiMtYo9KrUNhV6CO1g.png" /></figure><p>Hasil tersebut menunjukkan bahwa interface OperasiHitung berhasil diimplementasikan oleh kedua kelas dengan fungsi yang berbeda.</p><h3>4. TUGAS MODUL</h3><h4>4.1 Studi Kasus: Sistem Pembayaran Toko</h4><p>Pada tugas modul ini dibuat sebuah program sistem pembayaran sederhana untuk sebuah toko yang menjual dua jenis produk, yaitu Elektronik dan Makanan.</p><p>Setiap jenis produk memiliki metode untuk menghitung pajak dengan persentase yang berbeda.</p><p>Ketentuan pajak yang digunakan:</p><ul><li>Produk Elektronik dikenakan pajak sebesar 10% dari harga.</li><li>Produk Makanan dikenakan pajak sebesar 5% dari harga.</li></ul><p>Program akan menggunakan interface bernama Pembayaran yang memiliki metode hitungPajak(double harga).</p><p>Kelas Elektronik dan Makanan kemudian mengimplementasikan interface tersebut dengan perhitungan pajak masing-masing.</p><h4>4.2 Membuat Interface Pembayaran</h4><p>Langkah pertama adalah membuat interface bernama Pembayaran.</p><p>Kode program:</p><pre>public interface Pembayaran {<br>    double hitungPajak(double harga);<br>}</pre><p>Penjelasan:</p><ol><li>public interface Pembayaran digunakan untuk membuat interface bernama Pembayaran.</li><li>double hitungPajak(double harga) merupakan metode untuk menghitung pajak berdasarkan harga produk.</li><li>Parameter harga menggunakan tipe data double agar dapat menerima nilai berupa bilangan desimal.</li></ol><p>Interface ini menjadi kontrak yang harus diimplementasikan oleh kelas Elektronik dan Makanan.</p><h4>4.3 Membuat Kelas Elektronik</h4><p>Selanjutnya, buat kelas Elektronik yang mengimplementasikan interface Pembayaran.</p><p>Kode program:</p><pre>public class Elektronik implements Pembayaran {<br>    @Override<br>    public double hitungPajak(double harga) {<br>        return harga * 0.10;<br>    }<br>}</pre><p>Penjelasan:</p><ol><li>implements Pembayaran menunjukkan bahwa kelas Elektronik menggunakan interface Pembayaran.</li><li>@Override digunakan untuk mengimplementasikan metode hitungPajak().</li><li>harga * 0.10 digunakan untuk menghitung pajak sebesar 10% dari harga produk elektronik.</li></ol><p>Sebagai contoh, jika harga produk elektronik adalah Rp1.000.000, maka pajaknya adalah Rp100.000.</p><h4>4.4 Membuat Kelas Makanan</h4><p>Selanjutnya, buat kelas Makanan yang juga mengimplementasikan interface Pembayaran.</p><p>Kode program:</p><pre>public class Makanan implements Pembayaran {<br>    @Override<br>    public double hitungPajak(double harga) {<br>        return harga * 0.05;<br>    }<br>}</pre><p>Penjelasan:</p><ol><li>implements Pembayaran menunjukkan bahwa kelas Makanan mengimplementasikan interface Pembayaran.</li><li>@Override digunakan untuk mengimplementasikan metode hitungPajak().</li><li>harga * 0.05 digunakan untuk menghitung pajak sebesar 5% dari harga produk makanan.</li></ol><p>Sebagai contoh, jika harga produk makanan adalah Rp100.000, maka pajaknya adalah Rp5.000.</p><h4>4.5 Membuat Main Class</h4><p>Setelah interface dan kedua kelas selesai dibuat, buat kelas utama untuk menjalankan program.</p><p>Kode program:</p><pre>public class Main {<br>    public static void main(String[] args) {<br>        // Membuat objek Elektronik<br>        Pembayaran elektronik = new Elektronik();<br>        double hargaElektronik = 1000000;<br>        System.out.println(&quot;Harga Elektronik: Rp&quot;<br>                + hargaElektronik);<br>        System.out.println(&quot;Pajak Elektronik: Rp&quot;<br>                + elektronik.hitungPajak(hargaElektronik));<br><br>        // Membuat objek Makanan<br>        Pembayaran makanan = new Makanan();<br>        double hargaMakanan = 100000;<br>        System.out.println(&quot;Harga Makanan: Rp&quot;<br>                + hargaMakanan);<br>        System.out.println(&quot;Pajak Makanan: Rp&quot;<br>                + makanan.hitungPajak(hargaMakanan));<br>    }<br>}</pre><p>Penjelasan:</p><ol><li>Pembayaran elektronik = new Elektronik() membuat objek Elektronik dengan referensi bertipe Pembayaran.</li><li>hargaElektronik = 1000000 menentukan harga produk elektronik sebesar Rp1.000.000.</li><li>elektronik.hitungPajak(hargaElektronik) memanggil metode untuk menghitung pajak elektronik sebesar 10%.</li><li>Pembayaran makanan = new Makanan() membuat objek Makanan dengan referensi bertipe Pembayaran.</li><li>hargaMakanan = 100000 menentukan harga produk makanan sebesar Rp100.000.</li><li>makanan.hitungPajak(hargaMakanan) memanggil metode untuk menghitung pajak makanan sebesar 5%.</li></ol><p>Contoh harga pada program digunakan untuk menguji perhitungan pajak dari masing-masing produk.</p><h4>4.6 Hasil Output Program</h4><p>Setelah seluruh kode selesai dibuat, jalankan program melalui kelas MainPembayaran.</p><p>Output yang ditampilkan:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/338/1*upXNspf9cnzNFAAyblL9dg.png" /></figure><p>Hasil tersebut menunjukkan bahwa program berhasil menghitung pajak berdasarkan jenis produk.</p><p>Produk elektronik dikenakan pajak sebesar 10%, sedangkan produk makanan dikenakan pajak sebesar 5%.</p><h3>5. PENUTUP</h3><h4>5.1 Kesimpulan</h4><p>Berdasarkan praktikum yang telah dilakukan, dapat disimpulkan bahwa:</p><ol><li>Interface merupakan salah satu konsep dalam Pemrograman Berorientasi Objek yang berfungsi sebagai kontrak atau aturan bagi kelas yang mengimplementasikannya.</li><li>Interface dalam Java dideklarasikan menggunakan keyword interface, sedangkan kelas yang menggunakannya harus menggunakan keyword implements.</li><li>Kelas yang mengimplementasikan interface wajib menyediakan implementasi untuk seluruh metode abstrak yang didefinisikan di dalamnya, kecuali kelas tersebut dideklarasikan sebagai abstract.</li><li>Interface memungkinkan beberapa kelas memiliki metode yang sama dengan implementasi yang berbeda.</li><li>Java mendukung implementasi multiple interface sehingga satu kelas dapat menggunakan lebih dari satu interface.</li><li>Interface dapat meningkatkan fleksibilitas, konsistensi, dan kemudahan pengembangan program.</li></ol><p>Melalui praktikum ini, pemahaman mengenai konsep interface dalam bahasa pemrograman Java menjadi lebih baik, terutama dalam penerapan abstraksi, implementasi metode, dan polymorphism.</p><h3>GitHub</h3><p><a href="https://github.com/manggalaayudha/Pemrograman-Berorientasi-Objek/tree/5af0dfad59fdb13565ad7c3656db1b894e37d8d2/Pertemuan%2010">https://github.com/manggalaayudha/Pemrograman-Berorientasi-Objek/tree/5af0dfad59fdb13565ad7c3656db1b894e37d8d2/Pertemuan%2010</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6bc751290a4c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jaringan Komputer: Pengenalan Mikrotik RB951 dan Winbox]]></title>
            <link>https://medium.com/@bagusmanggalayudha/jaringan-komputer-pengenalan-mikrotik-rb951-dan-winbox-576ec27a3494?source=rss-2518abaf0d61------2</link>
            <guid isPermaLink="false">https://medium.com/p/576ec27a3494</guid>
            <category><![CDATA[mikrotik]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[winbox]]></category>
            <dc:creator><![CDATA[Bagus Manggala Yudha]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 16:55:05 GMT</pubDate>
            <atom:updated>2026-11-03T16:55:05.679Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/840/0*RdQGG0seXCpyPp_g.png" /></figure><p><strong>Halo Semuanya!</strong></p><h3>1. Pendahuluan</h3><h4>1.1 Latar Belakang</h4><p>Hi, kami Excel Bagus Herlambang NPM <strong>0056 </strong>dan Bagus Manggala Yudha NPM <strong>0057</strong>, mahasiswa S1 Teknologi Informasi. Praktikum kali ini kami kerjakan berdua, jadi laporannya juga ditulis bersama. Materinya <strong>Pengenalan Mikrotik RB951 dan Winbox</strong> (Modul II).</p><p>Berbeda dari praktikum sebelumnya yang memakai simulasi Cisco Packet Tracer, kali ini kami bekerja langsung dengan perangkat fisik: router Mikrotik RB951 yang dikonfigurasi lewat aplikasi Winbox dari PC lab. Fokusnya mengenal perangkat dan melakukan konfigurasi dasar: nama router, akun login, alamat IP, sampai menguji koneksi dari PC lab ke router.</p><h4>1.2 Tujuan Praktikum</h4><ol><li>Mengenal fungsi dasar router Mikrotik RB951 dan peran Winbox.</li><li>Mengidentifikasi port dan interface pada Mikrotik.</li><li>Terhubung ke Mikrotik menggunakan Winbox.</li><li>Melakukan konfigurasi dasar jaringan lokal (LAN) pada Mikrotik.</li></ol><h4>1.3 Dasar Teori Singkat</h4><p><strong>MikroTik</strong> adalah perusahaan asal Latvia (SIA Mikrotīkls) yang mengembangkan perangkat dan sistem operasi untuk manajemen jaringan, terutama router. Produknya ada dua: <strong>RouterOS</strong>, yaitu sistem operasi berbasis Linux dengan fitur router, firewall, bandwidth management, hotspot, dan VPN, serta <strong>RouterBOARD</strong>, yaitu perangkat keras yang khusus menjalankan RouterOS. RB951 yang kami pakai punya 5 port Ethernet (ether1 sampai ether5) dan interface wireless 2,4 GHz.</p><p>WinBox adalah aplikasi berbasis GUI untuk mengonfigurasi MikroTik lewat jaringan lokal, tanpa harus memakai perintah CLI. WinBox bisa terhubung ke router lewat MAC address maupun IP address, jadi router tetap bisa diakses pertama kali meskipun IP-nya belum diatur.</p><h3>2. Metodologi</h3><h4>2.1 Alat dan Bahan</h4><ul><li>Router Mikrotik RB951 beserta adaptor daya</li><li>PC lab dengan port LAN aktif sebagai perangkat administrator</li><li>Kabel UTP Straight-Through</li><li>Aplikasi WinBox versi 3.43 (bawaan PC lab; versi terbarunya adalah WinBox 4.4)</li></ul><h4>2.2 Langkah Kerja</h4><p><strong>2.2.1 Persiapan dan Koneksi Fisik</strong></p><p>Router dihubungkan ke adaptor daya, lalu port <strong>ether1</strong> Mikrotik dihubungkan ke port LAN PC lab dengan kabel UTP Straight-Through.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*K6KRUX-wVMaSIsOa.png" /></figure><p><strong>2.2.2 Menjalankan Winbox</strong></p><p>Aplikasi Winbox dibuka. Winbox otomatis mendeteksi router Mikrotik di jaringan lewat MAC address dan menampilkannya di tab Neighbors. Kami memilih router RB951 dari daftar, lalu klik Connect.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/0*jsuVr0XIfGv0SRsM.png" /></figure><p><strong>2.2.3 Mengenal Antarmuka Winbox</strong></p><p>Setelah login, muncul jendela utama Winbox dengan menu di sisi kiri. Kami membuka menu <strong>Interfaces</strong> untuk melihat daftar port Ethernet dan wireless. Judul jendela pada screenshot ini juga menunjukkan tipe perangkatnya, yaitu RB951Ui-2HnD dengan RouterOS versi 6.48.4.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/0*RXlryQ0qgWBOQeEa.jpeg" /></figure><p>Kami juga membuka <strong>Quick Set</strong> untuk melihat konfigurasi jaringan dasar pada router.</p><p><strong>2.2.4 Mengatur Identitas Router</strong></p><p>Lewat menu <strong>System &gt; Identity</strong>, nama router kami ganti menjadi <strong>excel yudha</strong> (gabungan nama kami berdua), lalu klik Apply dan OK.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/0*V_x9mS9MzdkqgYM0.jpeg" /></figure><p><strong>2.2.5 Membuat User Login</strong></p><p>Di menu <strong>System &gt; Users</strong>, kami menambahkan user baru bernama <strong>adminlab</strong> dengan group <strong>full</strong> dan password sesuai petunjuk modul. Setelah itu kami logout dan login kembali memakai user tersebut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/0*lkMKmXc_-SSy9KE5.jpeg" /></figure><p><strong>2.2.6 Memberi IP Address</strong></p><p>Di menu <strong>IP &gt; Addresses</strong>, daftar alamat awalnya kosong (0 items), jadi kami menambahkan IP manual <strong>192.168.10.1/24</strong> pada interface <strong>ether1</strong>. Kolom Network terisi otomatis 192.168.10.0.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/0*B18ppoSBMr5ZB5kT.jpeg" /></figure><p><strong>2.2.7 Menguji Koneksi</strong></p><p>Agar satu subnet dengan Mikrotik, IP PC lab kami atur manual: IP address <strong>192.168.10.2</strong>, subnet mask <strong>255.255.255.0</strong>, gateway <strong>192.168.10.1</strong> (IP Mikrotik), dan DNS 8.8.8.8.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/496/0*5Zadf0ky-vTn9f7B.jpeg" /></figure><p>Terakhir, kami ping dari PC lab ke Mikrotik lewat Command Prompt:</p><pre>ping 192.168.10.1</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/0*mfyRGC6KSFXQ-MFs.jpeg" /></figure><h3>3. Hasil dan Analisis</h3><h4>3.1 Hasil</h4><ul><li>Winbox mendeteksi router sebagai <strong>RB951Ui-2HnD</strong> dengan RouterOS <strong>6.48.4</strong>.</li><li>Interface yang terdaftar: ether1 sampai ether5 (Ethernet) dan wlan1 (wireless).</li><li>Identitas router berhasil diganti menjadi <strong>excel yudha</strong>, dan login berhasil dengan user <strong>adminlab</strong> (group full).</li><li>IP address <strong>192.168.10.1/24</strong> berhasil ditambahkan pada ether1.</li><li>Ping dari PC lab (192.168.10.2) ke Mikrotik (192.168.10.1) berhasil 4 dari 4 paket (0% loss), waktu balasan 0–1 ms, TTL 64.</li></ul><h4>3.2 Analisis</h4><p>Ping berhasil karena PC lab dan Mikrotik berada dalam <strong>satu subnet 192.168.10.0/24</strong> dan tersambung langsung lewat kabel di ether1. Dengan mask 255.255.255.0, tiga oktet pertama (192.168.10) sama, dan hanya oktet terakhir yang membedakan perangkat. Gateway pada PC lab diisi IP Mikrotik supaya nantinya trafik ke luar jaringan lewat router.</p><p>Winbox bisa mengakses Mikrotik pertama kali walau IP-nya belum diatur, karena ia terhubung lewat <strong>MAC address</strong>, bukan IP. Karena itu, IP baru kami atur setelah login lewat WinBox, dan daftar alamat di IP &gt; Addresses masih kosong sebelumnya.</p><p>Balasan ping punya TTL <strong>64</strong>, berbeda dari TTL 255 pada balasan router Cisco di artikel Packet Tracer sebelumnya. Nilai TTL awal ditentukan oleh sistem operasi pengirimnya, dan RouterOS yang berbasis Linux memakai 64.</p><h3>4. Kesimpulan</h3><p>Dari praktikum ini, keempat tujuan tercapai. Kami mengenal Mikrotik RB951 sebagai RouterBoard yang menjalankan RouterOS dan Winbox sebagai aplikasi GUI untuk mengonfigurasinya. Port dan interface (ether1 sampai ether5 dan wlan1) berhasil diidentifikasi, kami terhubung ke router lewat Winbox, lalu melakukan konfigurasi dasar berupa identitas router, user login, dan IP address 192.168.10.1/24 pada ether1. Pengujian ping dari PC lab ke Mikrotik berhasil tanpa packet loss, yang menunjukkan konektivitas LAN dasar sudah berfungsi.</p><h3>5. Referensi dan Lampiran</h3><h3>Referensi</h3><ul><li>Modul Praktikum Jaringan Komputer — Modul II: Pengenalan Mikrotik. Program Studi Teknologi Informasi.</li><li>Dokumentasi MikroTik RouterOS dan Winbox</li></ul><h3>Lampiran</h3><p>Dokumentasi praktikum:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/590/0*EcaVRBXr9yIpb72B.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=576ec27a3494" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Big Data: Instalasi MongoDB & Integrasi dengan PySpark]]></title>
            <link>https://medium.com/@bagusmanggalayudha/big-data-instalasi-mongodb-integrasi-dengan-pyspark-453d273c0047?source=rss-2518abaf0d61------2</link>
            <guid isPermaLink="false">https://medium.com/p/453d273c0047</guid>
            <category><![CDATA[ubuntu]]></category>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[mongodb]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[pyspark]]></category>
            <dc:creator><![CDATA[Bagus Manggala Yudha]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 16:46:24 GMT</pubDate>
            <atom:updated>2026-11-03T16:46:24.772Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YePYuMOfCoPFsdJsPvcjkw.png" /></figure><p><strong>Halo Semuanya!</strong></p><p>Saya Bagus Manggala Yudha, mahasiswa Teknologi Informasi di Universitas Tidar. Pada Praktikum Big Data kali ini, kita akan mempelajari tentang Instalasi MongoDB &amp; Integrasi dengan PySpark.</p><h3>1. Pendahuluan</h3><p>Perkembangan teknologi informasi menyebabkan jumlah dan jenis data yang dihasilkan semakin beragam. Data tidak selalu berbentuk tabel dengan struktur yang tetap, tetapi dapat berupa dokumen yang memiliki atribut berbeda-beda. Oleh karena itu, diperlukan sistem basis data yang mampu menyimpan dan mengelola data dengan struktur fleksibel.</p><p>Salah satu teknologi yang dapat digunakan adalah MongoDB, yaitu basis data NoSQL yang menyimpan data dalam bentuk dokumen BSON yang menyerupai JSON. MongoDB memungkinkan setiap dokumen memiliki atribut yang berbeda tanpa harus menentukan seluruh kolom terlebih dahulu. Hal ini membuat MongoDB cocok digunakan untuk mengelola data yang memiliki struktur beragam.</p><p>Pada praktikum ini, mahasiswa mempelajari konsep NoSQL, instalasi MongoDB di Ubuntu, operasi CRUD menggunakan MongoDB Shell dan PyMongo, serta integrasi data MongoDB dengan PySpark. Integrasi tersebut memungkinkan data yang tersimpan dalam MongoDB dianalisis kembali menggunakan kemampuan pemrosesan data Apache Spark.</p><h3>2. Tujuan Praktikum</h3><p>Tujuan dari praktikum ini adalah:</p><ol><li>Memahami konsep basis data NoSQL dan perbedaannya dengan basis data relasional.</li><li>Mengetahui proses instalasi dan konfigurasi MongoDB di Ubuntu.</li><li>Mempraktikkan operasi CRUD (<em>Create, Read, Update, Delete</em>) menggunakan MongoDB Shell dan PyMongo.</li><li>Memahami cara menghubungkan Python dengan MongoDB.</li><li>Mengintegrasikan data MongoDB menjadi Spark DataFrame.</li><li>Melakukan analisis sederhana menggunakan PySpark berdasarkan data yang diperoleh dari MongoDB.</li></ol><h3>3. Dasar Teori</h3><h4>3.1 Basis Data NoSQL</h4><p>NoSQL merupakan jenis basis data yang tidak terbatas pada model relasional berbentuk tabel. NoSQL dapat menyimpan data dengan struktur yang lebih fleksibel sehingga sesuai untuk menangani data semi-terstruktur maupun data dengan atribut yang beragam.</p><p>MongoDB adalah salah satu contoh basis data NoSQL yang menggunakan model <em>document store</em>. Data disimpan dalam bentuk dokumen dan dikelompokkan ke dalam collection.</p><h4>3.2 Perbedaan SQL dan NoSQL</h4><p>Basis data relasional seperti MySQL menyimpan data dalam tabel dengan struktur kolom yang telah ditentukan. Sementara itu, MongoDB menyimpan data dalam dokumen yang memungkinkan setiap dokumen mempunyai atribut berbeda.</p><p>SQL cocok digunakan ketika data memiliki struktur yang relatif tetap dan memerlukan relasi antartabel yang jelas. Sebaliknya, NoSQL dapat menjadi pilihan ketika struktur data sering berubah atau setiap data memiliki atribut yang berbeda.</p><h4>3.3 MongoDB</h4><p>MongoDB menggunakan BSON (<em>Binary JSON</em>) untuk menyimpan dokumen. Beberapa istilah penting dalam MongoDB adalah:</p><ul><li><strong>Database:</strong> tempat untuk mengelompokkan collection.</li><li><strong>Collection:</strong> kumpulan dokumen yang fungsinya mirip dengan tabel pada basis data relasional.</li><li><strong>Document:</strong> satu unit data yang berbentuk pasangan atribut dan nilai.</li><li><strong>Field:</strong> atribut yang terdapat dalam dokumen.</li></ul><p>MongoDB memiliki skema fleksibel sehingga dokumen dalam collection yang sama tidak harus memiliki field yang identik.</p><h4>3.4 Operasi CRUD</h4><p>CRUD merupakan empat operasi dasar untuk mengelola data dalam basis data.</p><ol><li><strong>Create:</strong> menambahkan dokumen baru.</li><li><strong>Read:</strong> membaca atau menampilkan dokumen.</li><li><strong>Update:</strong> memperbarui data yang sudah tersimpan.</li><li><strong>Delete:</strong> menghapus dokumen dari collection.</li></ol><p>Dalam PyMongo, operasi tersebut dapat dilakukan menggunakan metode insert_one(), insert_many(), find(), find_one(), update_one(), update_many(), delete_one(), dan delete_many().</p><h4>3.5 PyMongo</h4><p>PyMongo merupakan driver Python yang digunakan untuk menghubungkan aplikasi Python dengan MongoDB. Dengan PyMongo, pengguna dapat melakukan operasi basis data melalui kode Python tanpa harus menjalankan seluruh perintah secara manual melalui MongoDB Shell.</p><h4>3.6 Integrasi MongoDB dengan PySpark</h4><p>PySpark merupakan antarmuka Python untuk Apache Spark yang digunakan dalam pemrosesan dan analisis data. Data dari MongoDB dapat diambil menggunakan PyMongo, diubah menjadi Pandas DataFrame, kemudian dikonversi menjadi Spark DataFrame.</p><p>Spark DataFrame memiliki struktur kolom dan tipe data yang perlu dikenali oleh Spark. Oleh karena itu, data yang berasal dari MongoDB terkadang perlu dibersihkan atau disesuaikan terlebih dahulu, terutama jika beberapa dokumen tidak memiliki field yang sama.</p><h3>4. Alat dan Bahan</h3><p>Alat dan bahan yang digunakan dalam praktikum ini meliputi:</p><ol><li>Sistem operasi Ubuntu 22.04.</li><li>MongoDB Community Server 8.0.</li><li>MongoDB Shell (mongosh).</li><li>Python pada environment bigdata.</li><li>Library PyMongo.</li><li>Library Pandas.</li><li>Apache Spark dan PySpark.</li><li>Jupyter Notebook.</li></ol><h3>5. Langkah Kerja dan Hasil Praktikum</h3><h4>5.1 Instalasi MongoDB</h4><p>Sebelum melakukan instalasi MongoDB, kita perlu melakukan instalasi curl dan gnupg terlebih dahulu menggunakan perintah:</p><pre>sudo apt update<br>sudo apt install -y curl gnupg</pre><ul><li><strong>curl</strong>: digunakan untuk mengunduh file, termasuk kunci GPG MongoDB.</li><li><strong>gnupg</strong>: menyediakan alat untuk mengelola dan memverifikasi kunci GPG agar sumber paket dapat diverifikasi.</li></ul><p>Setelah itu, lakukan:</p><p><strong>5.1.1 Impor kunci GPG resmi MongoDB</strong></p><p>Gunakan perintah:</p><pre>curl -fsSL https://pgp.mongodb.com/server-8.0.asc | \<br>   sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg --dearmor</pre><p><strong>5.1.2 Tambahkan repository MongoDB</strong></p><p>Untuk Ubuntu dengan versi 22.04 (Jammy), gunakan :</p><pre>echo &quot;deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/8.0 multiverse&quot; | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list</pre><p><strong>5.1.3 Perbarui daftar paket &amp; instal MongoDB</strong></p><p>Jalankan perintah:</p><pre>sudo apt update<br>sudo apt install -y mongodb-org</pre><p>Lalu tunggu hingga proses instalasi selesai.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/559/1*LrweOBSps4UrwAPQ9H-yaA.png" /></figure><p>Jika seperti ini, tandanya MongoDB sudah berhasil diinstal.</p><p><strong>5.1.4 Jalankan MongoDB sebagai service &amp; aktifkan agar otomatis menyala setiap boot</strong></p><p>Jalankan perintah:</p><pre>sudo systemctl start mongod<br>sudo systemctl enable mongod</pre><p>Jika berhasil, akan tampil output berupa:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/1*RtrLwuy7OdwzKzD71_FiOQ.png" /></figure><p><strong>5.1.5 Verifikasi MongoDB berjalan</strong></p><p>Verifikasi menggunakan perintah:</p><pre>sudo systemctl status mongod</pre><p>Jika tampil baris Activate: active (running) berwarna hijau seperti gambar di bawah, tandanya kita sudah berhasil.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/830/1*AXO-ncm8Z6DGVyjV5KBMgQ.png" /></figure><p>Lalu tekan q untuk keluar dari tampilan status.</p><p>Gunakan perintah mongod --version untuk memverifikasi versi yang kita gunakan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/631/1*oD9YFaJ6yi8-ckWfPTq0Uw.png" /></figure><h4>5.2 Operasi Dasar MongoDB Shell</h4><p>mongosh atau MongoDB shell adalah <em>command-line interface</em> resmi untuk berinteraksi langsung dengan MongoDB — mirip peran hdfs dfs untuk HDFS atau psql untuk PostgreSQL.</p><p>Masuk ke MongoDB shell dengan perintah berikut di terminal:</p><pre>mongosh</pre><p>Kita akan langsung masuk ke prompt interaktif test&gt; . Kita bisa menjalankan beberapa perintah, seperti:</p><ul><li>Berpindah/membuat database bernama “praktikum-bigdata”.</li></ul><pre>use praktikum_bigdata</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/301/1*WP70LZ3OTUcLFUgHdO0uPQ.png" /></figure><ul><li>Menyisipkan satu dokumen ke collection “produk”. Jika belum ada, akan secara otomatis dibuat.</li></ul><pre>db.produk.insertOne({ nama_produk: &quot;Kopi Susu&quot;, kategori: &quot;Minuman&quot;, harga: 18000, stok: 120 })</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d9g6iWLIrOYi1EL7jJ4KQg.png" /></figure><ul><li>Menampilkan seluruh dokumen pada collection “produk”.</li></ul><pre>db.produk.find()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/435/1*LK2iWwoClE1A0ZaGqzJA6w.png" /></figure><ul><li>Menampilkan dengan format yang lebih rapi.</li></ul><pre>db.produk.find().pretty()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/435/1*AIavamQg_jB071rMpBhdEg.png" /></figure><p>Lalu kita bisa keluar menggunakan exit.</p><h3>Melanjutkan di Jupyter Notebook</h3><p>Lakukan instalasi driver PyMongo di environment bigdata menggunakan perintah:</p><pre>conda activate bigdata<br>pip install pymongo</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bUdqJ1KInIXLDPt4izR0pw.png" /></figure><p>Verifikasi berkas instalan kita dengan menjalankan:</p><pre>python -c &quot;import pymongo; print(&#39;PyMongo&#39;, pymongo.version)&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RnhldlMjEBOqua-RZMTB0w.png" /></figure><p>Lalu jalankan Jupyter Notebook</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bjJSo95K8QuGaHSx4lURLQ.png" /></figure><h4>5.3 Mengkoneksikan Python ke MongoDB</h4><p>Jalankan perintah:</p><pre>from pymongo import MongoClient<br><br># Membuat koneksi ke MongoDB yang berjalan di localhost, port default 27017<br>client = MongoClient(&quot;mongodb://localhost:27017/&quot;)<br><br># Memilih (atau otomatis membuat) database<br>db = client[&quot;praktikum_bigdata&quot;]<br><br># Memilih (atau otomatis membuat) collection<br>koleksi_produk = db[&quot;produk&quot;]<br><br>print(&quot;Koneksi ke MongoDB berhasil!&quot;)<br>print(&quot;Daftar database yang ada:&quot;, client.list_database_names())</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/563/1*PptmNr2oY6r-iKEDZwVZ-A.png" /></figure><p>Jika pada output tidak terdapat error, tandanya koneksi PyMongo ke MongoDB sudah berhasil.</p><h4>5.4 Operasi CRUD menggunakan PyMongo</h4><p><strong>5.4.1 Create </strong>— Menyisipkan Dokumen</p><p>Operasi Create digunakan untuk menambahkan dokumen baru ke dalam collection.</p><pre>koleksi_produk.insert_one({<br>    &quot;nama_produk&quot;: &quot;Kopi Susu&quot;,<br>    &quot;kategori&quot;: &quot;Minuman&quot;,<br>    &quot;harga&quot;: 18000,<br>    &quot;stok&quot;: 120,<br>    &quot;tags&quot;: [&quot;best-seller&quot;, &quot;dingin&quot;]<br>})<br><br>koleksi_produk.insert_many([<br>    {&quot;nama_produk&quot;: &quot;Roti Bakar&quot;, &quot;kategori&quot;: &quot;Makanan&quot;, &quot;harga&quot;: 15000, &quot;stok&quot;: 45, &quot;tags&quot;: [&quot;hangat&quot;]},<br>    {&quot;nama_produk&quot;: &quot;Es Teh&quot;, &quot;kategori&quot;: &quot;Minuman&quot;, &quot;harga&quot;: 8000, &quot;stok&quot;: 200, &quot;tags&quot;: [&quot;dingin&quot;, &quot;murah&quot;]},<br>    {&quot;nama_produk&quot;: &quot;Kentang Goreng&quot;, &quot;kategori&quot;: &quot;Makanan&quot;, &quot;harga&quot;: 20000, &quot;stok&quot;: 60, &quot;tags&quot;: [&quot;gurih&quot;]},<br>    {&quot;nama_produk&quot;: &quot;Cappuccino&quot;, &quot;kategori&quot;: &quot;Minuman&quot;, &quot;harga&quot;: 25000, &quot;stok&quot;: 80, &quot;tags&quot;: [&quot;hangat&quot;, &quot;best-seller&quot;]},<br>])<br><br>print(&quot;Jumlah dokumen di collection &#39;produk&#39;:&quot;, koleksi_produk.count_documents({}))</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/328/1*5ZA2NFl3O4u46Pjab-bAAA.png" /></figure><ul><li>insert_one() : digunakan untuk menyisipkan satu dokumen.</li><li>insert_many() : digunakan untuk menyisipkan banyak dokumen sekaligus.</li><li><em>tambahan. </em>count_documents({}) : digunakan untuk menghitung jumlah dokumen.</li></ul><p>Pada model MongoDB, perbedaan jumlah isi tabel adalah hal yang wajar dan tidak berpengaruh pada apapun. Sebagai contoh, pada dokumen di atas terdapat tags yang jumlahnya berbeda-beda.</p><p><strong>5.4.2 Read </strong>— Membaca Dokumen</p><p>Untuk membaca dokumen, kita bisa menggunakan beberapa cara. Antara lain:</p><ul><li>find_one() : digunakan untuk mengambil satu dokumen pertama yang cocok.</li><li>find() : digunakan untuk mengambil semua dokumen yang cocok.</li><li>Filter dengan operator perbandingan.</li></ul><p>Contoh:</p><pre># find_one()<br>satu_produk = koleksi_produk.find_one({&quot;kategori&quot;: &quot;Minuman&quot;})<br>print(&quot;Satu produk kategori Minuman:&quot;, satu_produk)<br><br>print()<br><br># find()<br>print(&quot;Seluruh produk kategori Minuman:&quot;)<br>for p in koleksi_produk.find({&quot;kategori&quot;: &quot;Minuman&quot;}):<br>    print(f&quot;  - {p[&#39;nama_produk&#39;]} (Rp{p[&#39;harga&#39;]:,})&quot;)<br><br>print()<br><br># Filter dengan operator perbandingan: harga lebih dari 15000<br>print(&quot;Produk dengan harga &gt; 15000:&quot;)<br>for p in koleksi_produk.find({&quot;harga&quot;: {&quot;$gt&quot;: 15000}}):<br>    print(f&quot;  - {p[&#39;nama_produk&#39;]} (Rp{p[&#39;harga&#39;]:,})&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*F7_mxGSMcCim3RF3AsweNg.png" /></figure><p><strong>5.4.3 Update</strong> — Memperbarui Dokumen</p><ul><li>update_one() : digunakan untuk memperbarui satu dokumen pertama yang cocok.</li><li>update_many() : digunakan untuk memperbarui semua dokumen yang cocok (mirip replace all di Windows).</li><li>$inc : digunakan untuk mengubah nilai relatif (increment/decrement).</li></ul><p>Contoh:</p><pre># update_one() — memperbarui SATU dokumen pertama yang cocok<br>koleksi_produk.update_one(<br>    {&quot;nama_produk&quot;: &quot;Es Teh&quot;},<br>    {&quot;$set&quot;: {&quot;harga&quot;: 9000}}   # menaikkan harga Es Teh<br>)<br><br># update_many() — memperbarui SEMUA dokumen yang cocok<br># Contoh: mengurangi stok seluruh produk kategori Minuman sebanyak 5 (simulasi penjualan)<br>koleksi_produk.update_many(<br>    {&quot;kategori&quot;: &quot;Minuman&quot;},<br>    {&quot;$inc&quot;: {&quot;stok&quot;: -5}}   # $inc mengubah nilai relatif (increment/decrement)<br>)<br><br>print(&quot;Setelah update:&quot;)<br>for p in koleksi_produk.find({}, {&quot;_id&quot;: 0, &quot;nama_produk&quot;: 1, &quot;harga&quot;: 1, &quot;stok&quot;: 1}):<br>    print(f&quot;  - {p[&#39;nama_produk&#39;]}: harga=Rp{p[&#39;harga&#39;]:,}, stok={p[&#39;stok&#39;]}&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/330/1*7z3X-thpQKp640Ob00DOGA.png" /></figure><p><strong>5.4.4 Delete</strong> — Menghapus Dokumen</p><ul><li>delete_one() : digunakan untuk menghapus satu dokumen yang cocok.</li><li>delete_many({}) : digunakan untuk menghapus banyak data sekaligus.</li></ul><p>Contoh:</p><pre>koleksi_produk.delete_one({&quot;nama_produk&quot;: &quot;Kentang Goreng&quot;})<br><br>print(&quot;Jumlah dokumen tersisa:&quot;, koleksi_produk.count_documents({}))<br>print(&quot;Daftar produk tersisa:&quot;, [p[&quot;nama_produk&quot;] for p in koleksi_produk.find({}, {&quot;nama_produk&quot;: 1, &quot;_id&quot;: 0})])</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/542/1*eWuu2gAjVn2g3vwlna3Tog.png" /></figure><h4>5.5 Mengintegrasikan Data MongoDB ke Spark DataFrame</h4><pre>from pyspark.sql import SparkSession<br>import pandas as pd<br><br>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan9-MongoDBSpark&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br># Langkah 1: Ambil seluruh dokumen dari MongoDB sebagai list of dict<br>dokumen_mongo = list(koleksi_produk.find({}))<br><br># Langkah 2: Ubah menjadi pandas DataFrame<br>df_pandas = pd.DataFrame(dokumen_mongo)<br><br># Langkah 3: Tipe data khusus MongoDB (_id, dan kolom berisi list seperti &quot;tags&quot;)<br># perlu disesuaikan dulu agar Spark dapat membacanya dengan benar<br>df_pandas[&quot;_id&quot;] = df_pandas[&quot;_id&quot;].astype(str)<br>df_pandas[&quot;tags&quot;] = df_pandas[&quot;tags&quot;].apply(lambda x: &quot;, &quot;.join(x) if isinstance(x, list) else &quot;&quot;)<br><br># Langkah 4: Konversi ke Spark DataFrame<br>df_spark_produk = spark.createDataFrame(df_pandas)<br><br>df_spark_produk.printSchema()<br>df_spark_produk.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/557/1*8FlmwFGrxSCsjL0K9D86Kg.png" /></figure><p><strong>Hasil dan pembahasan:</strong></p><p>Data diambil dari MongoDB menggunakan PyMongo, kemudian diubah menjadi Pandas DataFrame sebelum dikonversi menjadi Spark DataFrame.</p><p>Field _id diubah menjadi string agar lebih mudah diproses oleh Spark. Sementara itu, field tags yang berbentuk list diubah menjadi teks dengan menggabungkan elemen-elemennya.</p><p>Proses penyesuaian tersebut diperlukan karena struktur dan tipe data yang diterima dari MongoDB tidak selalu langsung sesuai dengan kebutuhan Spark DataFrame.</p><h4>5.6 Analisis Data Menggunakan PySpark</h4><p>Setelah data berhasil dikonversi, analisis sederhana dilakukan untuk menghitung rata-rata harga dan jumlah produk berdasarkan kategori.</p><pre>from pyspark.sql.functions import avg, count<br><br># Contoh analisis sederhana: rata-rata harga &amp; jumlah produk per kategori<br>df_spark_produk.groupBy(&quot;kategori&quot;).agg(<br>    avg(&quot;harga&quot;).alias(&quot;rata_rata_harga&quot;),<br>    count(&quot;nama_produk&quot;).alias(&quot;jumlah_produk&quot;)<br>).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/329/1*RfIycFTiqLDfef8UUnMJ3A.png" /></figure><p><strong>Hasil dan pembahasan:</strong></p><p>Fungsi groupBy() mengelompokkan data berdasarkan kategori. Fungsi avg() menghitung rata-rata harga produk, sedangkan count() menghitung jumlah produk dalam setiap kategori.</p><p>Hasil analisis dapat digunakan untuk membandingkan harga rata-rata antara kategori Makanan dan Minuman. Jumlah produk juga dapat membantu mengetahui kategori yang memiliki lebih banyak data dalam collection.</p><p>Setelah seluruh proses selesai, SparkSession ditutup menggunakan:</p><pre>spark.stop()</pre><h4>6. Analisis dan Pembahasan Umum</h4><p>Berdasarkan praktikum yang dilakukan, MongoDB memiliki keunggulan dalam menyimpan data dengan struktur yang fleksibel. Setiap dokumen dapat memiliki atribut yang berbeda sehingga cocok untuk data yang terus berkembang atau berubah.</p><p>Operasi CRUD memberikan kemampuan untuk mengelola data mulai dari penambahan, pencarian, pembaruan, hingga penghapusan dokumen. Melalui PyMongo, operasi tersebut dapat dilakukan menggunakan Python sehingga lebih mudah diintegrasikan dengan program lain.</p><p>Integrasi dengan PySpark memungkinkan data MongoDB dianalisis menggunakan fungsi agregasi dan pengolahan data. Namun, terdapat tantangan ketika mengonversi dokumen MongoDB menjadi Spark DataFrame karena Spark memerlukan skema dan tipe data yang dapat dikenali secara konsisten.</p><p>Pada praktikum ini, data diambil menggunakan PyMongo, diubah menjadi Pandas DataFrame, kemudian dikonversi menjadi Spark DataFrame. Pendekatan tersebut sesuai untuk data berukuran sedang. Untuk data yang sangat besar, penggunaan MongoDB Spark Connector dapat dipertimbangkan agar pembacaan data dapat dilakukan secara terdistribusi.</p><h4>7. Latihan Mandiri</h4><p><strong>7.1 Soal 1 — Menambahkan Lima Dokumen</strong></p><pre>koleksi_produk.insert_many([<br>    {<br>        &quot;nama_produk&quot;: &quot;Matcha Latte&quot;,<br>        &quot;kategori&quot;: &quot;Minuman&quot;,<br>        &quot;harga&quot;: 22000,<br>        &quot;stok&quot;: 50<br>    },<br>    {<br>        &quot;nama_produk&quot;: &quot;Donat Cokelat&quot;,<br>        &quot;kategori&quot;: &quot;Makanan&quot;,<br>        &quot;harga&quot;: 12000,<br>        &quot;stok&quot;: 35<br>    },<br>    {<br>        &quot;nama_produk&quot;: &quot;Keripik Kentang&quot;,<br>        &quot;kategori&quot;: &quot;Snack&quot;,<br>        &quot;harga&quot;: 10000,<br>        &quot;stok&quot;: 80<br>    },<br>    {<br>        &quot;nama_produk&quot;: &quot;Brownies&quot;,<br>        &quot;kategori&quot;: &quot;Makanan&quot;,<br>        &quot;harga&quot;: 18000,<br>        &quot;stok&quot;: 25<br>    },<br>    {<br>        &quot;nama_produk&quot;: &quot;Air Mineral&quot;,<br>        &quot;kategori&quot;: &quot;Minuman&quot;,<br>        &quot;harga&quot;: 5000,<br>        &quot;stok&quot;: 100<br>    }<br>])<br><br>print(<br>    &quot;Jumlah dokumen:&quot;,<br>    koleksi_produk.count_documents({})<br>)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/1*Hiz4lzonVrdVF5fe0NZtjw.png" /></figure><p><strong>7.2 Soal 2 — Menampilkan Produk dengan Harga di Bawah Rp20.000</strong></p><pre>for p in koleksi_produk.find({<br>    &quot;harga&quot;: {&quot;$lt&quot;: 20000}<br>}):<br>    print(<br>        p[&quot;nama_produk&quot;],<br>        &quot;- Rp&quot;,<br>        p[&quot;harga&quot;]<br>    )</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/234/1*XwA89IqgRG3bIyhUYrXQfw.png" /></figure><p>Operator $lt berarti <em>less than</em> atau kurang dari.</p><p><strong>7.3 Soal 3 — Menambahkan Field Diskon ke Seluruh Dokumen</strong></p><pre>koleksi_produk.update_many(<br>    {},<br>    {&quot;$set&quot;: {&quot;diskon&quot;: 0}}<br>)<br><br>print(&quot;Field diskon berhasil ditambahkan.&quot;)<br><br>for p in koleksi_produk.find(<br>    {},<br>    {<br>        &quot;_id&quot;: 0,<br>        &quot;nama_produk&quot;: 1,<br>        &quot;diskon&quot;: 1<br>    }<br>):<br>    print(p)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/370/1*KsGaeZ9sBlrdIDNkwvOgKQ.png" /></figure><p><strong>7.4 Soal 4 — Refleksi Singkat</strong></p><blockquote>MongoDB cocok digunakan untuk menyimpan aktivitas pengguna pada aplikasi karena setiap aktivitas bisa memiliki data yang berbeda-beda. Misalnya, aktivitas login menyimpan informasi tentang perangkat yang digunakan, sedangkan aktivitas pembelian menyimpan informasi produk dan jumlah barang yang dibeli. Dengan struktur yang fleksibel, kedua jenis aktivitas tersebut bisa disimpan dalam satu collection meskipun memiliki field yang berbeda.</blockquote><h4>8. Tugas Mandiri — Studi Kasus Kopi Nusantara</h4><p><strong>8.1 A — Membangun Katalog Menu</strong></p><pre>from pymongo import MongoClient<br><br>client = MongoClient(&quot;mongodb://localhost:27017/&quot;)<br><br>db_kopi = client[&quot;kopi_nusantara&quot;]<br>koleksi_menu = db_kopi[&quot;menu&quot;]<br><br>koleksi_menu.delete_many({})<br><br>menu = [<br>    {<br>        &quot;nama_menu&quot;: &quot;Espresso&quot;,<br>        &quot;harga&quot;: 18000,<br>        &quot;kategori&quot;: &quot;Kopi&quot;,<br>        &quot;tingkat_kepahitan&quot;: 5,<br>        &quot;stok&quot;: 30<br>    },<br>    {<br>        &quot;nama_menu&quot;: &quot;Americano&quot;,<br>        &quot;harga&quot;: 20000,<br>        &quot;kategori&quot;: &quot;Kopi&quot;,<br>        &quot;tingkat_kepahitan&quot;: 4,<br>        &quot;stok&quot;: 35<br>    },<br>    {<br>        &quot;nama_menu&quot;: &quot;Cappuccino&quot;,<br>        &quot;harga&quot;: 25000,<br>        &quot;kategori&quot;: &quot;Kopi&quot;,<br>        &quot;tingkat_kepahitan&quot;: 3,<br>        &quot;stok&quot;: 25<br>    },<br>    {<br>        &quot;nama_menu&quot;: &quot;Cafe Latte&quot;,<br>        &quot;harga&quot;: 27000,<br>        &quot;kategori&quot;: &quot;Kopi&quot;,<br>        &quot;tingkat_kepahitan&quot;: 2,<br>        &quot;stok&quot;: 25<br>    },<br>    {<br>        &quot;nama_menu&quot;: &quot;Mocha&quot;,<br>        &quot;harga&quot;: 30000,<br>        &quot;kategori&quot;: &quot;Kopi&quot;,<br>        &quot;tingkat_kepahitan&quot;: 3,<br>        &quot;stok&quot;: 20<br>    },<br>    {<br>        &quot;nama_menu&quot;: &quot;Cold Brew&quot;,<br>        &quot;harga&quot;: 24000,<br>        &quot;kategori&quot;: &quot;Kopi&quot;,<br>        &quot;tingkat_kepahitan&quot;: 4,<br>        &quot;stok&quot;: 20<br>    },<br>    {<br>        &quot;nama_menu&quot;: &quot;Roti Bakar&quot;,<br>        &quot;harga&quot;: 18000,<br>        &quot;kategori&quot;: &quot;Makanan&quot;,<br>        &quot;pedas_level&quot;: 0,<br>        &quot;stok&quot;: 25<br>    },<br>    {<br>        &quot;nama_menu&quot;: &quot;Mie Goreng&quot;,<br>        &quot;harga&quot;: 22000,<br>        &quot;kategori&quot;: &quot;Makanan&quot;,<br>        &quot;pedas_level&quot;: 2,<br>        &quot;stok&quot;: 20<br>    },<br>    {<br>        &quot;nama_menu&quot;: &quot;Kentang Goreng&quot;,<br>        &quot;harga&quot;: 20000,<br>        &quot;kategori&quot;: &quot;Makanan&quot;,<br>        &quot;pedas_level&quot;: 0,<br>        &quot;stok&quot;: 30<br>    },<br>    {<br>        &quot;nama_menu&quot;: &quot;Nasi Ayam&quot;,<br>        &quot;harga&quot;: 30000,<br>        &quot;kategori&quot;: &quot;Makanan&quot;,<br>        &quot;pedas_level&quot;: 1,<br>        &quot;stok&quot;: 20<br>    },<br>    {<br>        &quot;nama_menu&quot;: &quot;Pisang Goreng&quot;,<br>        &quot;harga&quot;: 15000,<br>        &quot;kategori&quot;: &quot;Makanan&quot;,<br>        &quot;pedas_level&quot;: 0,<br>        &quot;stok&quot;: 25<br>    },<br>    {<br>        &quot;nama_menu&quot;: &quot;Roti Maryam&quot;,<br>        &quot;harga&quot;: 17000,<br>        &quot;kategori&quot;: &quot;Makanan&quot;,<br>        &quot;pedas_level&quot;: 0,<br>        &quot;stok&quot;: 15<br>    }<br>]<br><br>koleksi_menu.insert_many(menu)<br><br>print(<br>    &quot;Jumlah menu:&quot;,<br>    koleksi_menu.count_documents({})<br>)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/156/1*pCCOjblV8tVQ_UAQx6FbzA.png" /></figure><p><strong>8.2 B — Kueri Bertingkat</strong></p><pre>print(&quot;Seluruh menu kategori Kopi dengan tingkat_kepahitan di atas 3 :&quot;)<br>for menu in koleksi_menu.find(<br>    {<br>        &quot;kategori&quot;: &quot;Kopi&quot;,<br>        &quot;tingkat_kepahitan&quot;: {&quot;$gt&quot;: 3}<br>    },<br>    {<br>        &quot;_id&quot;: 0,<br>        &quot;nama_menu&quot;: 1,<br>        &quot;harga&quot;: 1,<br>        &quot;tingkat_kepahitan&quot;: 1<br>    }<br>):<br>    print(<br>        menu[&quot;nama_menu&quot;],<br>        menu[&quot;harga&quot;],<br>        menu[&quot;tingkat_kepahitan&quot;]<br>    )<br>print(&quot;\n&quot;)<br><br>print(&quot;Seluruh menu dengan harga di antara 15000 dan 30000 :&quot;)<br>for m in koleksi_menu.find({<br>    &quot;harga&quot;: {<br>        &quot;$gte&quot;: 15000,<br>        &quot;$lte&quot;: 30000<br>    }<br>}):<br>    print(m[&quot;nama_menu&quot;], m[&quot;harga&quot;])<br>print(&quot;\n&quot;)<br><br>print(&quot;Menu yang tidak memiliki field pedas_level sama sekali :&quot;)<br>for m in koleksi_menu.find({<br>    &quot;pedas_level&quot;: {&quot;$exists&quot;: False}<br>}):<br>    print(m[&quot;nama_menu&quot;], m[&quot;kategori&quot;])</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/461/1*MbigrVko0nDOXHfBJTX_RQ.png" /></figure><p><strong>8.3 C — Memperbarui Data</strong></p><pre>koleksi_menu.update_many(<br>    {},<br>    {&quot;$set&quot;: {&quot;status&quot;: &quot;Tersedia&quot;}}<br>)<br>        <br>koleksi_menu.update_one(<br>    {&quot;nama_menu&quot;: &quot;Espresso&quot;},<br>    {&quot;$set&quot;: {&quot;status&quot;: &quot;Habis&quot;}}<br>)<br><br>koleksi_menu.update_one(<br>    {&quot;nama_menu&quot;: &quot;Roti Bakar&quot;},<br>    {&quot;$set&quot;: {&quot;status&quot;: &quot;Habis&quot;}}<br>)<br><br>for m in koleksi_menu.find(<br>    {},<br>    {<br>        &quot;_id&quot;: 0,<br>        &quot;nama_menu&quot;: 1,<br>        &quot;status&quot;: 1<br>    }<br>):<br>    print(m)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/394/1*X46Ll7gsdH3nx4oeQRXXIw.png" /></figure><p><strong>8.4 D — Integrasi MongoDB dengan PySpark</strong></p><pre>from pyspark.sql import SparkSession<br>import pandas as pd<br><br>spark = SparkSession.builder \<br>    .appName(&quot;Tugas9-KopiNusantara&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br><br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br># Mengambil seluruh data dari collection menu<br>dokumen_menu = list(koleksi_menu.find({}))<br><br># Mengubah menjadi Pandas DataFrame<br>df_pandas = pd.DataFrame(dokumen_menu)<br><br># Menyesuaikan tipe data MongoDB<br>df_pandas[&quot;_id&quot;] = df_pandas[&quot;_id&quot;].astype(str)<br><br># Menghapus kolom _id jika tidak diperlukan<br>df_pandas = df_pandas.drop(columns=[&quot;_id&quot;])<br><br># Mengisi field kosong dengan None<br>df_pandas = df_pandas.astype(object).where(<br>    pd.notna(df_pandas), None<br>)<br><br># Konversi ke Spark DataFrame<br>df_spark_menu = spark.createDataFrame(df_pandas)<br><br># 1. Menampilkan struktur DataFrame<br>df_spark_menu.printSchema()<br><br># Menampilkan seluruh data<br>df_spark_menu.show(truncate=False)<br><br># 2. Menghitung rata-rata harga per kategori<br>from pyspark.sql.functions import avg<br><br>df_spark_menu.groupBy(&quot;kategori&quot;).agg(<br>    avg(&quot;harga&quot;).alias(&quot;rata_rata_harga&quot;)<br>).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/565/1*DAcMyNRd88DnphnLNdV1-w.png" /></figure><p><strong>9. Kesimpulan</strong></p><blockquote><em>Tantangan yang saya temui saat mengonversi data MongoDB menjadi Spark DataFrame adalah struktur dokumen yang tidak selalu seragam. Pada MongoDB, setiap dokumen dapat memiliki field yang berbeda sesuai dengan jenis datanya. Contohnya, menu dengan kategori Kopi memiliki field tingkat_kepahitan, sedangkan menu dengan kategori Makanan tidak memiliki field tersebut. Hal ini menjadi tantangan karena Spark DataFrame membutuhkan struktur kolom dan tipe data yang lebih seragam agar data dapat diproses dengan baik.</em></blockquote><blockquote><em>Untuk mengatasi masalah tersebut, saya menggunakan Pandas DataFrame sebagai perantara sebelum data dikonversi ke Spark DataFrame. Selain itu, saya melakukan penyesuaian tipe data pada kolom _id menjadi string dan menangani nilai yang kosong dengan mengubahnya menjadi None atau null. Dengan cara ini, dokumen yang memiliki field berbeda tetap dapat digabungkan ke dalam satu DataFrame tanpa harus menghilangkan data yang tersedia.</em></blockquote><h3>GitHub</h3><p><a href="https://github.com/manggalaayudha/Praktikum-BigData/tree/95e109df9dcb68a983c6ce630a7d5aaf355af497/Pertemuan-9">https://github.com/manggalaayudha/Praktikum-BigData/tree/95e109df9dcb68a983c6ce630a7d5aaf355af497/Pertemuan-9</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=453d273c0047" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PBO: Abstraksi dan Kelas Abstrak]]></title>
            <link>https://medium.com/@bagusmanggalayudha/pbo-abstraksi-dan-kelas-abstrak-19665c984601?source=rss-2518abaf0d61------2</link>
            <guid isPermaLink="false">https://medium.com/p/19665c984601</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[netbeans]]></category>
            <category><![CDATA[abstraction]]></category>
            <dc:creator><![CDATA[Bagus Manggala Yudha]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 14:55:52 GMT</pubDate>
            <atom:updated>2026-11-04T01:21:51.236Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x9X3Gjx7s-Cm22u2LXbh2w.png" /></figure><p><strong>Halo Semuanya!</strong></p><p>Saya Bagus Manggala Yudha, mahasiswa Teknologi Informasi di Universitas Tidar. Pada Praktikum Pemrograman Berorientasi Objek kali ini, kita akan mempelajari tentang Abstraksi dan Kelas Abstrak pada bahasa pemrograman Java di software NetBeans.</p><h3>1. PENDAHULUAN</h3><h3>1.1 Tujuan Praktikum</h3><p>Tujuan dari praktikum ini adalah:</p><ol><li>Memahami konsep abstraksi dalam Pemrograman Berorientasi Objek (PBO).</li><li>Memahami pengertian dan fungsi kelas abstrak dalam Java.</li><li>Mengetahui perbedaan metode abstrak dan metode biasa.</li><li>Mampu mengimplementasikan kelas abstrak menggunakan bahasa pemrograman Java.</li><li>Memahami penerapan inheritance (pewarisan) dan overriding pada kelas abstrak.</li></ol><h3>1.2 Dasar Teori</h3><h3>A. Pengertian Abstraksi</h3><p>Abstraksi merupakan salah satu pilar utama dalam Pemrograman Berorientasi Objek (PBO). Abstraksi bertujuan untuk menyembunyikan detail implementasi dan hanya menampilkan fungsionalitas penting dari suatu objek.</p><p>Dengan adanya abstraksi, sistem yang kompleks dapat dibagi menjadi bagian-bagian yang lebih sederhana sehingga lebih mudah dipahami dan dikelola.</p><p>Dalam konsep abstraksi, kita lebih berfokus pada apa yang dapat dilakukan oleh suatu objek daripada bagaimana cara objek tersebut melakukannya.</p><p>Contohnya adalah objek kendaraan. Pengguna hanya perlu mengetahui bahwa kendaraan dapat berjalan, tanpa harus memahami secara detail bagaimana mesin internal kendaraan tersebut bekerja.</p><h3>B. Pengertian Kelas Abstrak</h3><p>Kelas abstrak (Abstract Class) merupakan kelas yang tidak dapat dibuat objeknya secara langsung. Kelas ini digunakan sebagai cetak biru (blueprint) bagi kelas lain yang mewarisinya.</p><p>Kelas abstrak dapat memiliki dua jenis metode, yaitu:</p><ol><li><strong>Metode Abstrak:</strong> Metode yang hanya memiliki deklarasi tanpa implementasi atau isi metode.</li><li><strong>Metode Biasa:</strong> Metode yang memiliki implementasi atau isi program seperti metode pada umumnya.</li></ol><p>Dalam Java, kelas abstrak dideklarasikan menggunakan kata kunci abstract.</p><p>Contoh deklarasi kelas abstrak:</p><pre>abstract class Kendaraan {<br>    abstract void berjalan();<br>    void info() {<br>        System.out.println(&quot;Ini adalah kendaraan.&quot;);<br>    }<br>}</pre><p>Pada contoh tersebut, metode berjalan() merupakan metode abstrak yang harus diimplementasikan oleh kelas turunannya. Sementara itu, metode info() merupakan metode biasa yang sudah memiliki implementasi.</p><h3>C. Karakteristik Kelas Abstrak</h3><p>Kelas abstrak memiliki beberapa karakteristik, yaitu:</p><ol><li>Tidak dapat dibuat objeknya secara langsung menggunakan keyword new.</li><li>Dapat memiliki metode abstrak dan metode biasa.</li><li>Dapat diwariskan kepada kelas lain menggunakan keyword extends.</li><li>Subclass yang bukan kelas abstrak wajib mengimplementasikan seluruh metode abstrak yang diwariskan.</li><li>Dapat digunakan sebagai dasar untuk membangun struktur kelas yang lebih terorganisasi.</li></ol><h3>D. Inheritance dan Method Overriding</h3><p><strong>Inheritance (Pewarisan)</strong> merupakan konsep dalam PBO yang memungkinkan sebuah kelas memperoleh atribut dan metode dari kelas lain.</p><p>Dalam Java, inheritance menggunakan keyword extends.</p><p>Sementara itu, <strong>Method Overriding</strong> merupakan proses ketika kelas turunan membuat kembali implementasi metode yang diwariskan dari kelas induk.</p><p>Dalam penerapan kelas abstrak, method overriding digunakan untuk memberikan implementasi terhadap metode abstrak yang sebelumnya hanya dideklarasikan pada kelas induk.</p><h3>2. ALAT DAN BAHAN</h3><p>Alat dan bahan yang digunakan dalam praktikum ini adalah:</p><ol><li>Laptop atau komputer.</li><li>Koneksi internet.</li><li>Web Browser seperti Google Chrome, Mozilla Firefox, atau Microsoft Edge.</li><li>JDK (Java Development Kit).</li><li>NetBeans IDE sebagai aplikasi untuk menulis dan menjalankan program Java.</li></ol><h3>3. LANGKAH KERJA PRAKTIKUM</h3><h3>3.1 Persiapan</h3><p>Sebelum memulai praktikum, dilakukan beberapa persiapan sebagai berikut:</p><ol><li>Membuka aplikasi NetBeans IDE yang sudah terinstal pada komputer.</li><li>Membuat proyek baru dengan nama PraktikumPBO_9.</li><li>Membuat package baru dengan nama praktikum9.</li><li>Menyiapkan beberapa kelas Java yang akan digunakan dalam praktikum.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/315/1*YAC-YpOu8obwy3DiVySldQ.png" /></figure><h3>3.2 Studi Kasus: Kendaraan</h3><p>Pada praktikum ini dibuat sebuah program sederhana menggunakan konsep abstraksi dengan studi kasus kendaraan.</p><p>Program terdiri dari tiga kelas utama, yaitu:</p><ul><li>Kelas abstrak Kendaraan.</li><li>Kelas turunan Mobil.</li><li>Kelas turunan Sepeda.</li></ul><p>Selain itu, terdapat kelas Main yang digunakan untuk menjalankan program.</p><h3>A. Membuat Kelas Abstrak Kendaraan</h3><p>Langkah pertama adalah membuat kelas abstrak bernama Kendaraan.</p><p>Kode program:</p><pre>abstract class Kendaraan {<br>    // Metode abstrak<br>    abstract void berjalan();<br>    // Metode dengan implementasi<br>    void info() {<br>        System.out.println(&quot;Ini adalah kendaraan.&quot;);<br>    }<br>}</pre><p>Penjelasan:</p><ol><li>abstract class Kendaraan digunakan untuk mendeklarasikan kelas abstrak bernama Kendaraan.</li><li>abstract void berjalan() merupakan metode abstrak yang tidak memiliki implementasi.</li><li>void info() merupakan metode biasa yang memiliki implementasi untuk menampilkan informasi kendaraan.</li></ol><p>Kelas Kendaraan tidak dapat dibuat objeknya secara langsung karena merupakan kelas abstrak.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/544/1*yMWB7Fbdb0tWAYyMqCMTbQ.png" /></figure><h3>B. Membuat Kelas Turunan Mobil</h3><p>Selanjutnya, buat kelas bernama Mobil yang mewarisi kelas Kendaraan.</p><p>Kode program:</p><pre>class Mobil extends Kendaraan {<br>    @Override<br>    void berjalan() {<br>        System.out.println(&quot;Mobil sedang berjalan dengan cepat.&quot;);<br>    }<br>}</pre><p>Penjelasan:</p><ol><li>extends Kendaraan menunjukkan bahwa kelas Mobil merupakan turunan dari kelas Kendaraan.</li><li>@Override menunjukkan bahwa metode berjalan() merupakan implementasi ulang dari metode yang diwariskan.</li><li>Metode berjalan() diimplementasikan untuk menampilkan informasi bahwa mobil sedang berjalan dengan cepat.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/658/1*Oht0PQUApMHsIo5rYmmSpg.png" /></figure><h3>C. Membuat Kelas Turunan Sepeda</h3><p>Selanjutnya, buat kelas bernama Sepeda yang juga mewarisi kelas Kendaraan.</p><p>Kode program:</p><pre>class Sepeda extends Kendaraan {<br>    @Override<br>    void berjalan() {<br>        System.out.println(&quot;Sepeda sedang berjalan dengan pelan.&quot;);<br>    }<br>}</pre><p>Penjelasan:</p><ol><li>extends Kendaraan digunakan agar kelas Sepeda mewarisi kelas Kendaraan.</li><li>@Override digunakan untuk mengimplementasikan kembali metode abstrak berjalan().</li><li>Metode berjalan() menampilkan informasi bahwa sepeda sedang berjalan dengan pelan.</li></ol><p>Dengan demikian, kelas Mobil dan Sepeda memiliki implementasi metode berjalan() yang berbeda meskipun berasal dari kelas induk yang sama.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/658/1*45vK31Q76FSjtsydwDghPg.png" /></figure><h3>D. Membuat Main Class</h3><p>Setelah kelas Kendaraan, Mobil, dan Sepeda selesai dibuat, langkah selanjutnya adalah membuat kelas utama bernama Main.</p><p>Kode program:</p><pre>public class Main {<br>    public static void main(String[] args) {<br>        Kendaraan mobil = new Mobil();<br>        Kendaraan sepeda = new Sepeda();<br>        mobil.berjalan();<br>        mobil.info();<br>        sepeda.berjalan();<br>        sepeda.info();<br>    }<br>}</pre><p>Penjelasan:</p><ol><li>public static void main(String[] args) merupakan metode utama yang pertama kali dijalankan ketika program dieksekusi.</li><li>Kendaraan mobil = new Mobil() membuat objek Mobil dengan referensi bertipe Kendaraan.</li><li>Kendaraan sepeda = new Sepeda() membuat objek Sepeda dengan referensi bertipe Kendaraan.</li><li>mobil.berjalan() memanggil metode berjalan() milik kelas Mobil.</li><li>sepeda.berjalan() memanggil metode berjalan() milik kelas Sepeda.</li><li>info() digunakan untuk menampilkan informasi kendaraan dari kelas induk.</li></ol><p>Penggunaan referensi bertipe Kendaraan untuk menampung objek Mobil dan Sepeda merupakan salah satu penerapan polymorphism dalam Java.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/469/1*3RhUKOsUUuUN0oof-x5vEA.png" /></figure><h3>3.3 Menjalankan Program</h3><p>Setelah seluruh kelas selesai dibuat, jalankan program melalui kelas Main.</p><p>Langkah-langkahnya:</p><ol><li>Pastikan seluruh kelas sudah berada dalam package praktikum9.</li><li>Klik kanan pada file Main.java.</li><li>Pilih menu Run File.</li><li>Perhatikan hasil keluaran program pada bagian Output.</li></ol><p>Output yang ditampilkan:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/528/1*zT1dUboCbSdvFyni4BScEQ.png" /></figure><p>Hasil tersebut menunjukkan bahwa setiap kelas turunan berhasil mengimplementasikan metode abstrak berjalan() dengan perilaku yang berbeda.</p><h3>3.4 Pengujian Membuat Objek dari Kelas Abstrak</h3><p>Pada tahap ini dilakukan pengujian untuk mengetahui apakah kelas abstrak Kendaraan dapat dibuat objeknya secara langsung.</p><p>Contoh kode:</p><pre>Kendaraan kendaraan = new Kendaraan();</pre><p>Jika kode tersebut dijalankan, program akan menghasilkan error karena kelas abstrak tidak dapat diinstansiasi secara langsung.</p><p>Hal ini terjadi karena kelas abstrak hanya berfungsi sebagai blueprint atau cetak biru bagi kelas turunannya.</p><p>Untuk membuat objek, kita harus menggunakan kelas turunan seperti Mobil atau Sepeda yang telah mengimplementasikan metode abstrak dari kelas Kendaraan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/891/1*mHXgd3XKgMSYs1RrjTj81g.png" /></figure><h3>4. TUGAS MODUL 9</h3><h3>4.1 Studi Kasus: Hewan</h3><p>Pada tugas modul ini, dibuat sebuah program menggunakan konsep kelas abstrak dengan studi kasus hewan.</p><p>Program memiliki satu kelas abstrak bernama Hewan dan dua kelas turunan, yaitu Kucing dan Anjing.</p><p>Setiap kelas turunan harus mengimplementasikan metode abstrak suara() sesuai dengan karakteristik hewan masing-masing.</p><h3>4.2 Membuat Kelas Abstrak Hewan</h3><p>Buat kelas abstrak dengan nama Hewan.</p><p>Kode program:</p><pre>abstract class Hewan {<br>   abstract void suara();<br>}</pre><p>Penjelasan:</p><ol><li>abstract class Hewan digunakan untuk membuat kelas abstrak bernama Hewan.</li><li>abstract void suara() merupakan metode abstrak yang nantinya harus diimplementasikan oleh setiap kelas turunannya.</li></ol><p>Kelas Hewan tidak dapat dibuat objeknya secara langsung.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/289/1*9AXQmG9TGgfisGjHqmdvxw.png" /></figure><h3>4.3 Membuat Kelas Kucing</h3><p>Selanjutnya, buat kelas Kucing yang mewarisi kelas Hewan.</p><p>Kode program:</p><pre>class Kucing extends Hewan {<br>    @Override<br>    void suara() {<br>        System.out.println(&quot;Kucing mengeluarkan suara: Meong&quot;);<br>    }<br>}</pre><p>Penjelasan:</p><p>Kelas Kucing mewarisi kelas Hewan dan mengimplementasikan metode suara() menggunakan method overriding.</p><p>Ketika metode suara() dipanggil, program akan menampilkan suara khas kucing, yaitu Meong.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*j4uv4y1bI7x8PyCmg6bEkw.png" /></figure><h3>4.4 Membuat Kelas Anjing</h3><p>Buat kelas Anjing yang juga mewarisi kelas Hewan.</p><p>Kode program:</p><pre>class Anjing extends Hewan {<br>    @Override<br>    void suara() {<br>        System.out.println(&quot;Anjing mengeluarkan suara: Guk Guk&quot;);<br>    }<br>}</pre><p>Penjelasan:</p><p>Kelas Anjing mengimplementasikan metode suara() dari kelas Hewan.</p><p>Ketika metode suara() dipanggil, program akan menampilkan suara khas anjing, yaitu Guk Guk.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*UtUDixsUKoJQN5xhUwG_cA.png" /></figure><h3>4.5 Membuat Main Class</h3><p>Setelah kedua kelas turunan selesai dibuat, buat kelas utama untuk menjalankan program.</p><p>Kode program:</p><pre>public class MainHewan {<br>    public static void main(String[] args) {<br>        Hewan kucing = new Kucing();<br>        Hewan anjing = new Anjing();<br>        kucing.suara();<br>        anjing.suara();<br>    }<br>}</pre><p>Penjelasan:</p><ol><li>Hewan kucing = new Kucing() membuat objek Kucing dengan referensi bertipe Hewan.</li><li>Hewan anjing = new Anjing() membuat objek Anjing dengan referensi bertipe Hewan.</li><li>kucing.suara() memanggil implementasi metode suara() dari kelas Kucing.</li><li>anjing.suara() memanggil implementasi metode suara() dari kelas Anjing.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/432/1*Q3gfyzlWzwyfzgZ_ajA-Dg.png" /></figure><h3>4.6 Hasil Output Program</h3><p>Setelah seluruh kode selesai dibuat, jalankan program melalui kelas MainHewan.</p><p>Output yang ditampilkan:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/565/1*EtAZCmEof0DOaVa-4he2oQ.png" /></figure><p>Hasil tersebut menunjukkan bahwa kelas Kucing dan Anjing berhasil mengimplementasikan metode abstrak suara() dengan keluaran yang berbeda.</p><h3>5. PENUTUP</h3><h3>5.1 Kesimpulan</h3><p>Berdasarkan praktikum yang telah dilakukan, dapat disimpulkan bahwa:</p><ol><li>Abstraksi merupakan salah satu konsep utama dalam Pemrograman Berorientasi Objek yang bertujuan menyembunyikan detail implementasi dan hanya menampilkan fungsionalitas penting suatu objek.</li><li>Kelas abstrak merupakan kelas yang tidak dapat diinstansiasi secara langsung dan digunakan sebagai blueprint bagi kelas turunannya.</li><li>Kelas abstrak dapat memiliki metode abstrak tanpa implementasi dan metode biasa yang sudah memiliki implementasi.</li><li>Kelas turunan wajib mengimplementasikan metode abstrak dari kelas induknya apabila kelas turunan tersebut bukan merupakan kelas abstrak.</li><li>Method overriding memungkinkan kelas turunan memberikan implementasi metode yang berbeda sesuai kebutuhan.</li><li>Konsep abstraksi dapat diterapkan dalam berbagai kasus, seperti kendaraan dan hewan, sehingga program menjadi lebih terstruktur dan mudah dikembangkan.</li></ol><p>Melalui praktikum ini, pemahaman mengenai konsep abstraksi dan kelas abstrak dalam bahasa pemrograman Java menjadi lebih baik, terutama dalam penerapan inheritance, method overriding, dan polymorphism.</p><h3>GitHub</h3><p><a href="https://github.com/manggalaayudha/Pemrograman-Berorientasi-Objek/tree/5af0dfad59fdb13565ad7c3656db1b894e37d8d2/Pertemuan%209">https://github.com/manggalaayudha/Pemrograman-Berorientasi-Objek/tree/5af0dfad59fdb13565ad7c3656db1b894e37d8d2/Pertemuan%209</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=19665c984601" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jaringan Komputer: VLAN]]></title>
            <link>https://medium.com/@bagusmanggalayudha/jaringan-komputer-vlan-4e2e220aed55?source=rss-2518abaf0d61------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e2e220aed55</guid>
            <category><![CDATA[cisco-packet-tracer]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[vlan-routing]]></category>
            <dc:creator><![CDATA[Bagus Manggala Yudha]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 16:14:26 GMT</pubDate>
            <atom:updated>2026-11-02T16:14:26.404Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*quWSe_tothaHC8zgrK7gCg.png" /></figure><p><strong>Halo Semuanya!</strong></p><p>Saya Bagus Manggala Yudha, mahasiswa Teknologi Informasi di Universitas Tidar. Pada Praktikum Jaringan Komputer kali ini, kita akan mempelajari tentang VLAN.</p><h3>1. PENDAHULUAN</h3><h3>1.1 Tujuan Praktikum</h3><p>Praktikum ini bertujuan untuk:</p><ol><li>Memahami konsep dasar Virtual Local Area Network (VLAN).</li><li>Mengetahui fungsi dan manfaat penggunaan VLAN dalam jaringan komputer.</li><li>Memahami cara kerja VLAN dalam membagi jaringan menjadi beberapa segmen.</li><li>Mampu membuat dan mengonfigurasi VLAN pada perangkat switch menggunakan Cisco Packet Tracer.</li><li>Mengetahui cara menguji konektivitas antarperangkat dalam VLAN yang sama maupun berbeda.</li></ol><h3>1.2 Dasar Teori</h3><h3>A. Pengertian VLAN</h3><p>Virtual Local Area Network (VLAN) merupakan suatu model jaringan yang memungkinkan pembagian jaringan secara virtual tanpa harus memperhatikan lokasi fisik perangkat. Dengan VLAN, sebuah jaringan dapat dibagi menjadi beberapa segmen jaringan yang berbeda meskipun perangkat-perangkat tersebut terhubung pada switch yang sama.</p><p>VLAN memberikan fleksibilitas dalam pengelolaan jaringan karena administrator dapat mengelompokkan perangkat berdasarkan kebutuhan organisasi, departemen, atau kelompok tertentu.</p><h3>B. Fungsi dan Manfaat VLAN</h3><p>Beberapa manfaat penggunaan VLAN dalam jaringan komputer adalah:</p><ol><li><strong>Security:</strong> Meningkatkan keamanan data dengan memisahkan jaringan berdasarkan segmen tertentu sehingga lalu lintas data dapat dibatasi.</li><li><strong>Cost Reduction:</strong> Mengurangi biaya pengembangan jaringan karena penggunaan infrastruktur jaringan dapat lebih efisien.</li><li><strong>Higher Performance:</strong> Mengurangi lalu lintas paket yang tidak diperlukan dengan membagi jaringan menjadi beberapa broadcast domain yang lebih kecil.</li><li><strong>Broadcast Storm Mitigation:</strong> Mengurangi kemungkinan terjadinya broadcast storm dengan membatasi penyebaran broadcast pada setiap VLAN.</li><li><strong>Improved IT Staff Efficiency:</strong> Mempermudah administrator dalam mengelola dan memelihara jaringan.</li><li><strong>Simpler Project or Application Management:</strong> Mempermudah pengelompokan pengguna dan perangkat jaringan berdasarkan kebutuhan organisasi.</li></ol><h3>C. Cara Kerja VLAN</h3><p>VLAN bekerja dengan cara mengelompokkan perangkat jaringan ke dalam beberapa segmen logis. Pengelompokan tersebut dapat dilakukan berdasarkan port switch, MAC Address, tipe protokol, alamat IP subnet, maupun aplikasi yang digunakan.</p><p>Switch yang mendukung VLAN akan menyimpan informasi konfigurasi VLAN dan menentukan ke mana data harus diteruskan berdasarkan keanggotaan VLAN setiap port.</p><p>Perangkat yang berada dalam VLAN yang sama dapat berkomunikasi secara langsung. Sementara itu, komunikasi antar-VLAN membutuhkan perangkat Layer 3 seperti router yang dikonfigurasi untuk menangani routing antar-VLAN.</p><h3>D. Tipe-Tipe VLAN</h3><p>VLAN dapat diklasifikasikan berdasarkan beberapa metode berikut:</p><p><strong>1. Berdasarkan Port</strong></p><p>Keanggotaan VLAN ditentukan berdasarkan port yang digunakan pada switch. Setiap port dikonfigurasi untuk menjadi anggota VLAN tertentu.</p><p><strong>2. Berdasarkan MAC Address</strong></p><p>Keanggotaan VLAN ditentukan berdasarkan MAC Address dari perangkat yang terhubung ke jaringan.</p><p><strong>3. Berdasarkan Tipe Protokol</strong></p><p>VLAN dikelompokkan berdasarkan protokol jaringan yang digunakan, misalnya IP dan IPX.</p><p><strong>4. Berdasarkan Alamat Subnet IP</strong></p><p>Pengelompokan VLAN dilakukan berdasarkan alamat subnet IP yang digunakan oleh perangkat.</p><p><strong>5. Berdasarkan Aplikasi atau Kombinasi Lain</strong></p><p>VLAN dapat ditentukan berdasarkan aplikasi yang dijalankan atau kombinasi dari beberapa metode pengelompokan.</p><h3>1.3 Alat dan Bahan</h3><p>Alat dan bahan yang digunakan dalam praktikum ini adalah:</p><ol><li>Laptop atau komputer.</li><li>Aplikasi Cisco Packet Tracer.</li><li>Empat buah PC sebagai end device.</li><li>Satu buah switch Cisco 2960.</li><li>Kabel jaringan Copper Straight-Through.</li></ol><h3>2. LANGKAH KERJA PRAKTIKUM</h3><h3>2.1 Membuat Topologi Jaringan</h3><p>Langkah pertama adalah membuka aplikasi Cisco Packet Tracer dan membuat topologi jaringan menggunakan empat buah PC dan satu buah switch Cisco 2960.</p><p>Topologi dibagi menjadi dua kelompok VLAN, yaitu:</p><ul><li>VLAN 10: PC0 dan PC1.</li><li>VLAN 20: PC2 dan PC3.</li></ul><p>Masing-masing PC dihubungkan ke switch menggunakan kabel straight.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*hdsSJqfM3zqOpAYm9xo1tQ.png" /></figure><h3>2.2 Konfigurasi IP Address</h3><p>Setelah membuat topologi, setiap PC diberikan alamat IP sesuai dengan kelompok VLAN masing-masing. Di praktikum kali ini, kita akan menggunakan ip</p><p>VLAN 10 : 10.10.57.10 dan 10.10.57.11</p><p>VLAN 20 : 20.20.57.20 dan 20.20.57.21</p><p>Langkah konfigurasi:</p><ol><li>Klik perangkat PC yang akan dikonfigurasi.</li><li>Pilih menu Desktop.</li><li>Pilih IP Configuration.</li><li>Masukkan IP Address sesuai tabel.</li><li>Masukkan Subnet Mask.</li><li>Lakukan langkah yang sama pada seluruh PC.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/1*8_8U347eRYwZGuFmewqM2g.png" /><figcaption>PC0</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/668/1*eQHjCFY7uNiOz_uKBnDBhQ.png" /><figcaption>PC1</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/660/1*C1_U6afBM19E8sUblpB9HQ.png" /><figcaption>PC2</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/673/1*DqMqMpvAgzQbGgQdpylNGQ.png" /><figcaption>PC3</figcaption></figure><h3>2.3 Masuk ke Konfigurasi Switch</h3><p>Setelah seluruh PC mendapatkan IP Address, langkah berikutnya adalah melakukan konfigurasi pada switch.</p><ol><li>Klik perangkat Switch0.</li><li>Pilih menu CLI.</li><li>Masukkan perintah berikut:</li></ol><pre>Switch&gt; enable<br>Switch# configure terminal</pre><p>Perintah enable digunakan untuk masuk ke mode privileged EXEC, sedangkan configure terminal digunakan untuk masuk ke mode konfigurasi global.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GRIdMsV_GdqgicuGttoARQ.png" /></figure><h3>2.4 Membuat VLAN 10 dan VLAN 20</h3><p>Selanjutnya, buat dua VLAN yang akan digunakan dalam topologi jaringan.</p><p>Masukkan perintah berikut:</p><pre>Switch(config)# vlan 10<br>Switch(config-vlan)# name vlan10<br>Switch(config-vlan)# exit</pre><pre>Switch(config)# vlan 20<br>Switch(config-vlan)# name vlan20<br>Switch(config-vlan)# exit</pre><p>Keterangan:</p><ul><li>vlan 10 digunakan untuk membuat VLAN dengan ID 10.</li><li>name vlan10 digunakan untuk memberikan nama VLAN 10.</li><li>vlan 20 digunakan untuk membuat VLAN dengan ID 20.</li><li>name vlan20 digunakan untuk memberikan nama VLAN 20.</li><li>exit digunakan untuk keluar dari mode konfigurasi VLAN.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rMjl6etr5Z1_RO6BdhPgwA.png" /></figure><h3>2.5 Mengatur Port Switch ke VLAN</h3><p>Setelah VLAN berhasil dibuat, setiap port switch perlu dikonfigurasi agar perangkat yang terhubung masuk ke VLAN yang sesuai.</p><p>Konfigurasi port untuk VLAN 10:</p><pre>Switch(config)# interface fa0/1<br>Switch(config-if)# switchport access vlan 10<br>Switch(config-if)# exit</pre><pre>Switch(config)# interface fa0/2<br>Switch(config-if)# switchport access vlan 10<br>Switch(config-if)# exit</pre><p>Konfigurasi port untuk VLAN 20:</p><pre>Switch(config)# interface fa0/3<br>Switch(config-if)# switchport access vlan 20<br>Switch(config-if)# exit</pre><pre>Switch(config)# interface fa0/4<br>Switch(config-if)# switchport access vlan 20<br>Switch(config-if)# exit</pre><p>Keterangan:</p><ul><li>Port FastEthernet 0/1 dan 0/2 dimasukkan ke VLAN 10.</li><li>Port FastEthernet 0/3 dan 0/4 dimasukkan ke VLAN 20.</li><li>switchport access vlan digunakan untuk menentukan VLAN yang menjadi anggota suatu port.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*skDxw-0cu04J_IMRQaC23A.png" /></figure><p>2.6 Memeriksa Konfigurasi VLAN</p><p>Setelah seluruh konfigurasi selesai, lakukan pemeriksaan untuk memastikan VLAN sudah berhasil dibuat dan setiap port telah masuk ke VLAN yang benar.</p><p>Gunakan perintah berikut:</p><pre>Switch# show vlan</pre><p>Perintah tersebut akan menampilkan daftar VLAN, status VLAN, serta port yang menjadi anggota setiap VLAN.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/667/1*ha2yoWj7bmBgk9rinzyDXA.png" /></figure><h3>2.7 Pengujian Konektivitas Menggunakan Ping</h3><p>Tahap terakhir adalah melakukan pengujian konektivitas menggunakan perintah ping pada masing-masing PC.</p><p>Pengujian dilakukan untuk mengetahui apakah perangkat dalam VLAN yang sama dapat saling berkomunikasi dan apakah perangkat dari VLAN berbeda dapat berkomunikasi secara langsung.</p><p><strong>Pengujian pertama: PC0 ke PC1</strong></p><p>Kedua perangkat berada dalam VLAN 10.</p><pre>ping 10.10.57.11</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/652/1*sF5NQbtxhLaS0pHDITMixg.png" /></figure><p>Hasil yang ditampilkan adalah berhasil karena kedua perangkat berada dalam VLAN yang sama.</p><p><strong>Pengujian kedua: PC2 ke PC3</strong></p><p>Kedua perangkat berada dalam VLAN 20.</p><pre>ping 20.20.57.21</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/1*5mJewdlUQynPsRH3O7E02A.png" /></figure><p>Hasil yang ditampilkan adalah berhasil karena kedua perangkat berada dalam VLAN yang sama.</p><p><strong>Pengujian ketiga: PC0 ke PC2</strong></p><p>Kedua perangkat berada dalam VLAN berbeda, yaitu VLAN 10 dan VLAN 20.</p><pre>ping 20.20.57.20</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/1*GwOhVvJzL2sGutAzNoJ8dA.png" /></figure><p>Hasil yang ditampilkan adalah gagal karena belum terdapat konfigurasi routing antar-VLAN.</p><h3>3. HASIL DAN PEMBAHASAN</h3><h3>3.1 Hasil Praktikum</h3><p>Berdasarkan praktikum yang telah dilakukan menggunakan Cisco Packet Tracer, jaringan berhasil dibagi menjadi dua kelompok VLAN, yaitu VLAN 10 dan VLAN 20.</p><p>VLAN 10 terdiri dari PC0 dan PC1 yang terhubung melalui port Fa0/1 dan Fa0/2. Sementara itu, VLAN 20 terdiri dari PC2 dan PC3 yang terhubung melalui port Fa0/3 dan Fa0/4.</p><p>Setiap perangkat telah diberikan alamat IP sesuai dengan kelompok VLAN masing-masing. Konfigurasi VLAN dapat diperiksa melalui perintah show vlan pada switch.</p><p>Pengujian konektivitas dilakukan menggunakan perintah ping untuk memastikan komunikasi antarperangkat berjalan sesuai dengan konfigurasi VLAN.</p><h3>3.2 Analisis Praktikum</h3><p>Dari hasil konfigurasi dan pengujian, dapat diketahui bahwa VLAN berfungsi untuk membagi satu jaringan fisik menjadi beberapa jaringan virtual yang berbeda.</p><p>PC0 dan PC1 dapat berkomunikasi karena berada dalam VLAN yang sama, yaitu VLAN 10. Begitu juga dengan PC2 dan PC3 yang berada dalam VLAN 20.</p><p>Namun, komunikasi antara PC yang berada dalam VLAN berbeda tidak dapat dilakukan secara langsung karena masing-masing VLAN memiliki broadcast domain yang berbeda.</p><p>Hal tersebut menunjukkan bahwa konfigurasi VLAN pada switch berhasil melakukan pemisahan jaringan berdasarkan kelompok yang telah ditentukan.</p><p>Untuk memungkinkan komunikasi antar-VLAN, diperlukan perangkat Layer 3 seperti router yang dikonfigurasi untuk menangani proses routing antar-VLAN.</p><h3>4. PENUTUP</h3><h3>4.1 Kesimpulan</h3><p>Berdasarkan praktikum yang telah dilakukan, dapat disimpulkan bahwa:</p><ol><li>VLAN merupakan teknologi jaringan yang memungkinkan pembagian jaringan secara virtual tanpa harus bergantung pada lokasi fisik perangkat.</li><li>VLAN dapat meningkatkan keamanan, efisiensi, dan kinerja jaringan dengan membagi jaringan menjadi beberapa broadcast domain.</li><li>Pembuatan VLAN pada switch Cisco 2960 dapat dilakukan melalui CLI menggunakan perintah vlan dan konfigurasi port menggunakan switchport access vlan.</li><li>Perangkat yang berada dalam VLAN yang sama dapat saling berkomunikasi secara langsung.</li><li>Perangkat yang berada dalam VLAN berbeda tidak dapat berkomunikasi secara langsung tanpa adanya konfigurasi routing antar-VLAN.</li></ol><p>Dengan praktikum ini, pemahaman mengenai konsep VLAN dan penerapannya pada jaringan komputer menggunakan Cisco Packet Tracer menjadi lebih baik.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e2e220aed55" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Big Data: Studi Kasus Terintegrasi: Analisis Big Data End-to-End Menggunakan HDFS dan PySpark.]]></title>
            <link>https://medium.com/@bagusmanggalayudha/big-data-studi-kasus-terintegrasi-analisis-big-data-end-to-end-menggunakan-hdfs-dan-pyspark-f31850398715?source=rss-2518abaf0d61------2</link>
            <guid isPermaLink="false">https://medium.com/p/f31850398715</guid>
            <category><![CDATA[apache-spark]]></category>
            <category><![CDATA[ubuntu]]></category>
            <category><![CDATA[hadoop]]></category>
            <category><![CDATA[big-data]]></category>
            <dc:creator><![CDATA[Bagus Manggala Yudha]]></dc:creator>
            <pubDate>Fri, 09 Oct 2026 08:11:41 GMT</pubDate>
            <atom:updated>2026-10-09T08:11:41.503Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YePYuMOfCoPFsdJsPvcjkw.png" /></figure><p><strong>Halo Semuanya!</strong></p><p>Saya Bagus Manggala Yudha, mahasiswa Teknologi Informasi di Universitas Tidar. Pada Praktikum Big Data kali ini, kita akan mempelajari tentang Studi Kasus Terintegrasi: Analisis Big Data End-to-End Menggunakan HDFS dan PySpark.</p><h3>1. Pendahuluan</h3><p>Perkembangan teknologi informasi menyebabkan jumlah data yang dihasilkan semakin besar dan beragam. Oleh karena itu, diperlukan teknologi yang mampu menyimpan, mengolah, dan menganalisis data secara efisien. Salah satu teknologi yang dapat digunakan adalah Apache Hadoop dengan HDFS sebagai sistem penyimpanan terdistribusi serta Apache Spark melalui PySpark untuk melakukan pemrosesan dan analisis data.</p><p>Pada praktikum Pertemuan 7, dilakukan studi kasus pengolahan Big Data menggunakan data transaksi, data toko, dan data produk. Proses praktikum mencakup pembacaan data dari HDFS, penggabungan DataFrame, perhitungan total penjualan, penerapan window function untuk menentukan produk terlaris, serta penggunaan Spark SQL untuk menganalisis kontribusi penjualan. Hasil pengolahan kemudian disimpan dalam format Parquet agar dapat digunakan kembali untuk analisis lebih lanjut.</p><p>Melalui praktikum ini, mahasiswa diharapkan memahami penerapan proses pengolahan Big Data secara terintegrasi serta mampu menghasilkan informasi yang bermanfaat untuk mendukung pengambilan keputusan berdasarkan data.</p><h3>2. Tujuan Praktikum</h3><p>Praktikum ini bertujuan untuk memahami proses pengolahan data berskala besar secara menyeluruh menggunakan Hadoop Distributed File System (HDFS) dan PySpark. Mahasiswa mempelajari cara membaca data dari berbagai sumber, menggabungkan DataFrame, menerapkan window function, menjalankan Spark SQL, serta menyimpan hasil pengolahan ke dalam format Parquet. Selain itu, praktikum ini bertujuan melatih kemampuan menganalisis data untuk menghasilkan informasi yang dapat digunakan dalam pengambilan keputusan.</p><h3>3. Dasar Teori</h3><p><strong>a. Hadoop Distributed File System (HDFS)</strong></p><p>HDFS merupakan sistem penyimpanan terdistribusi yang digunakan untuk menyimpan data dalam jumlah besar. Pada praktikum ini, HDFS digunakan untuk menyimpan data transaksi, data toko, dan data produk sebelum diproses menggunakan PySpark.</p><p><strong>b. PySpark DataFrame</strong></p><p>PySpark adalah antarmuka Python untuk Apache Spark yang digunakan dalam pengolahan data berskala besar. DataFrame merupakan struktur data berbentuk tabel yang memiliki kolom dan baris. Melalui DataFrame, data dapat dibaca, digabungkan, dikelompokkan, dan dianalisis secara efisien.</p><p><strong>c. Join</strong></p><p>Join merupakan operasi untuk menggabungkan dua atau lebih DataFrame berdasarkan kolom yang saling berhubungan. Pada praktikum ini, data transaksi digabungkan dengan data toko menggunakan toko_id, kemudian digabungkan dengan data produk menggunakan product_id.</p><p><strong>d. Window Function</strong></p><p>Window function digunakan untuk melakukan perhitungan atau memberikan peringkat pada data dalam kelompok tertentu tanpa menggabungkan seluruh baris menjadi satu baris. Fungsi row_number() digunakan untuk menentukan tiga produk dengan penjualan tertinggi pada setiap toko.</p><p><strong>e. Spark SQL</strong></p><p>Spark SQL memungkinkan pengolahan data menggunakan perintah SQL secara langsung pada DataFrame yang telah didaftarkan sebagai temporary view. Pada praktikum ini, Spark SQL digunakan untuk menghitung total penjualan berdasarkan kota dan manajer toko.</p><p><strong>f. ETL dan Parquet</strong></p><p>ETL merupakan proses Extract, Transform, dan Load. Extract digunakan untuk mengambil data, Transform untuk mengolah data, sedangkan Load untuk menyimpan hasil pengolahan. Parquet adalah format penyimpanan kolumnar yang cocok untuk analisis data karena mendukung penyimpanan yang efisien dan partisi berdasarkan kolom tertentu.</p><h3>4. Alat dan Bahan</h3><ol><li>Sistem operasi Ubuntu.</li><li>Hadoop dan HDFS.</li><li>Apache Spark dan PySpark.</li><li>Python.</li><li>Jupyter Notebook.</li><li>Library NumPy dan Pandas.</li><li>Dataset transaksi, toko, dan produk dalam format CSV dan JSON.</li></ol><h3>5. Langkah Kerja</h3><p><strong>a. Membuat SparkSession</strong></p><p>Praktikum dimulai dengan mengimpor library yang diperlukan dan membuat SparkSession. SparkSession berfungsi sebagai titik awal untuk menjalankan operasi pengolahan data menggunakan PySpark.</p><pre>from pyspark.sql import SparkSession<br>from pyspark.sql.functions import col, sum as spark_sum, avg, count, row_number<br>from pyspark.sql.window import Window</pre><pre>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan7-StudiKasusTerintegrasi&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)</pre><pre>print(&quot;SparkSession siap. Versi Spark:&quot;, spark.version)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/290/1*AognSCg9BLxLRylCcaTZOA.png" /></figure><p><strong>b. Menyiapkan Dataset</strong></p><p>Dataset dibuat menggunakan NumPy dan Pandas, kemudian disimpan dalam tiga sumber, yaitu data toko dalam format JSON, data produk dalam format CSV, dan data transaksi dalam format CSV. Dataset transaksi terdiri dari 5.000 baris yang berisi ID transaksi, ID toko, ID produk, dan jumlah produk yang terjual.</p><pre>np.random.seed(77)<br><br># SUMBER 1: Data toko/cabang (JSON) — tabel referensi kecil<br>toko_list = [&quot;Toko Magelang&quot;, &quot;Toko Yogyakarta&quot;, &quot;Toko Semarang&quot;, &quot;Toko Solo&quot;]<br>data_toko = [<br>    {&quot;toko_id&quot;: i + 1, &quot;nama_toko&quot;: t, &quot;kota&quot;: t.split()[1], &quot;manager&quot;: np.random.choice([&quot;Rani&quot;, &quot;Joko&quot;, &quot;Sari&quot;, &quot;Bayu&quot;])}<br>    for i, t in enumerate(toko_list)<br>]<br>with open(&quot;data_toko.json&quot;, &quot;w&quot;) as f:<br>    for t in data_toko:<br>        f.write(json.dumps(t) + &quot;\n&quot;)<br><br># SUMBER 2: Data produk (CSV) — tabel referensi kecil<br>data_produk = [<br>    {&quot;product_id&quot;: i, &quot;nama_produk&quot;: f&quot;Produk-{i}&quot;,<br>     &quot;kategori&quot;: np.random.choice([&quot;Elektronik&quot;, &quot;Fashion&quot;, &quot;Makanan&quot;]),<br>     &quot;harga&quot;: int(np.random.choice([50000, 100000, 200000]))}<br>    for i in range(1, 21)<br>]<br>pd.DataFrame(data_produk).to_csv(&quot;data_produk.csv&quot;, index=False)<br><br># SUMBER 3: Data transaksi triwulan (CSV) — data utama, jauh lebih besar<br>n = 5000<br>data_transaksi = pd.DataFrame({<br>    &quot;trx_id&quot;: [f&quot;T{i}&quot; for i in range(n)],<br>    &quot;toko_id&quot;: np.random.randint(1, 5, size=n),<br>    &quot;product_id&quot;: np.random.randint(1, 21, size=n),<br>    &quot;qty&quot;: np.random.randint(1, 6, size=n),<br>})<br>data_transaksi.to_csv(&quot;data_transaksi_triwulan.csv&quot;, index=False)<br><br>print(&quot;Ketiga sumber data berhasil dibuat:&quot;)<br>print(f&quot;- data_toko.json              : {len(data_toko)} baris&quot;)<br>print(f&quot;- data_produk.csv             : {len(data_produk)} baris&quot;)<br>print(f&quot;- data_transaksi_triwulan.csv : {len(data_transaksi)} baris&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/318/1*SSEYJrNiSit20gK9N9THAQ.png" /></figure><p><strong>c. Mengunggah Dataset ke HDFS</strong></p><p>Ketiga dataset diunggah ke HDFS menggunakan perintah berikut.</p><pre>!hdfs dfs -mkdir -p /user/mahasiswa/pertemuan7/raw<br>!hdfs dfs -put -f data_transaksi_triwulan.csv /user/mahasiswa/pertemuan7/raw/<br>!hdfs dfs -put -f data_toko.json /user/mahasiswa/pertemuan7/raw/<br>!hdfs dfs -put -f data_produk.csv /user/mahasiswa/pertemuan7/raw/<br>!hdfs dfs -ls /user/mahasiswa/pertemuan7/raw</pre><p>Perintah tersebut digunakan untuk membuat direktori penyimpanan dan mengunggah dataset agar dapat dibaca oleh Spark.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/871/1*KpGlRwxTPwIzvfe-_BxfDQ.png" /></figure><p><strong>d. Membaca Dataset dari HDFS</strong></p><p>Data transaksi, toko, dan produk dibaca dari HDFS menggunakan PySpark.</p><pre>df_transaksi = spark.read.csv(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_transaksi_triwulan.csv&quot;,<br>    header=True, inferSchema=True<br>)<br>df_toko = spark.read.json(&quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_toko.json&quot;)<br>df_produk = spark.read.csv(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_produk.csv&quot;,<br>    header=True, inferSchema=True<br>)<br><br>print(&quot;Transaksi:&quot;, df_transaksi.count(), &quot;| Toko:&quot;, df_toko.count(), &quot;| Produk:&quot;, df_produk.count())</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/293/1*xwF97gbNUmBzgvj77jo6Kg.png" /></figure><p>Parameter header=True digunakan untuk membaca nama kolom dari baris pertama CSV, sedangkan inferSchema=True membantu Spark mengenali tipe data setiap kolom.</p><p><strong>e. Menggabungkan DataFrame dan Menghitung Penjualan</strong></p><p>Ketiga DataFrame digabungkan menggunakan operasi join. Setelah itu, dibuat kolom total_penjualan yang diperoleh dari perkalian jumlah produk terjual dengan harga produk.</p><pre>df_gabungan = df_transaksi.join(df_toko, on=&quot;toko_id&quot;, how=&quot;inner&quot;) \<br>                           .join(df_produk, on=&quot;product_id&quot;, how=&quot;inner&quot;)<br><br>df_gabungan = df_gabungan.withColumn(&quot;total_penjualan&quot;, col(&quot;qty&quot;) * col(&quot;harga&quot;))<br>df_gabungan.show(5)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/795/1*Hy1hnrHwxsyWFpSGl49_yw.png" /></figure><p>Hasil penggabungan memberikan informasi transaksi yang lebih lengkap karena mencakup data toko, produk, kategori, harga, jumlah produk, dan total penjualan.</p><p><strong>f. Menentukan Tiga Produk Terlaris per Toko</strong></p><p>Pada tahap ini, data dikelompokkan berdasarkan nama toko dan nama produk. Total penjualan setiap produk dihitung menggunakan sum(), kemudian diurutkan dan diberi peringkat menggunakan window function.</p><pre># Meringkas total penjualan per kombinasi toko + produk terlebih dahulu<br>ringkasan_produk_toko = df_gabungan.groupBy(&quot;nama_toko&quot;, &quot;nama_produk&quot;).agg(<br>    spark_sum(&quot;total_penjualan&quot;).alias(&quot;total_penjualan&quot;)<br>)<br><br># Menerapkan window function untuk mengambil top-3 produk pada setiap toko<br>window_toko = Window.partitionBy(&quot;nama_toko&quot;).orderBy(col(&quot;total_penjualan&quot;).desc())<br>top3_produk = ringkasan_produk_toko.withColumn(&quot;peringkat&quot;, row_number().over(window_toko)) \<br>                                    .filter(col(&quot;peringkat&quot;) &lt;= 3)<br><br>top3_produk.orderBy(&quot;nama_toko&quot;, &quot;peringkat&quot;).show(20)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*Osf8JGcTFBQRRgcsrlzcaQ.png" /></figure><p>Hasilnya menunjukkan tiga produk dengan total penjualan tertinggi pada setiap toko. Informasi tersebut dapat digunakan untuk mengetahui produk yang paling diminati pelanggan.</p><p><strong>g. Menganalisis Kontribusi Manajer Menggunakan Spark SQL</strong></p><p>DataFrame hasil penggabungan didaftarkan sebagai temporary view agar dapat diolah menggunakan Spark SQL.</p><pre>df_gabungan.createOrReplaceTempView(&quot;gabungan&quot;)<br><br>kontribusi_manager = spark.sql(&#39;&#39;&#39;<br>    SELECT kota, manager, SUM(total_penjualan) AS total_penjualan<br>    FROM gabungan<br>    GROUP BY kota, manager<br>    ORDER BY total_penjualan DESC<br>&#39;&#39;&#39;)<br>kontribusi_manager.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/267/1*tUW_tWkoeCQfN_LJFS6jCA.png" /></figure><p>Query tersebut menghitung total penjualan berdasarkan kota dan manajer, kemudian mengurutkannya dari nilai tertinggi. Hasilnya membantu membandingkan kontribusi setiap manajer berdasarkan penjualan yang dihasilkan.</p><p><strong>h. Menyimpan Hasil ke HDFS dalam Format Parquet</strong></p><p>Data hasil penggabungan disimpan dalam format Parquet dan dipartisi berdasarkan kategori produk.</p><pre>!hdfs dfs -mkdir -p /user/mahasiswa/pertemuan7/processed<br><br>df_gabungan.write.mode(&quot;overwrite&quot;).partitionBy(&quot;kategori&quot;).parquet(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/processed/laporan_triwulan&quot;<br>)<br><br>print(&quot;Laporan berhasil disimpan ke HDFS dalam format Parquet, terpartisi per kategori produk.&quot;)<br>!hdfs dfs -ls /user/mahasiswa/pertemuan7/processed/laporan_triwulan</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*QrfZ6YAZCXkWMlf1FGbEMw.png" /></figure><p>Penyimpanan ini merupakan tahap Load dalam proses ETL. Partisi berdasarkan kategori membantu pengorganisasian data dan dapat meningkatkan efisiensi pembacaan ketika analisis hanya membutuhkan kategori tertentu.</p><p><strong>i. Membuat Ringkasan Eksekutif</strong></p><p>Data Parquet dibaca kembali, kemudian digunakan untuk menghitung total penjualan triwulan, jumlah transaksi, dan rata-rata nilai penjualan per transaksi pada setiap toko.</p><pre>df_final = spark.read.parquet(&quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/processed/laporan_triwulan&quot;)<br><br>ringkasan_eksekutif = df_final.groupBy(&quot;nama_toko&quot;, &quot;kota&quot;, &quot;manager&quot;).agg(<br>    spark_sum(&quot;total_penjualan&quot;).alias(&quot;total_penjualan_triwulan&quot;),<br>    count(&quot;trx_id&quot;).alias(&quot;jumlah_transaksi&quot;),<br>    avg(&quot;total_penjualan&quot;).alias(&quot;rata_rata_nilai_transaksi&quot;)<br>).orderBy(col(&quot;total_penjualan_triwulan&quot;).desc())<br><br>ringkasan_eksekutif.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/1*EdFUtZ2NR2iG4CregwiImw.png" /></figure><p>Ringkasan eksekutif tersebut digunakan untuk membandingkan kinerja penjualan setiap toko berdasarkan tiga indikator utama.</p><h3>6. Hasil dan Pembahasan</h3><p>Berdasarkan rangkaian praktikum, pengolahan data dilakukan melalui beberapa tahapan yang saling berhubungan. Data transaksi, toko, dan produk disimpan di HDFS, kemudian dibaca menggunakan PySpark untuk diproses menjadi satu DataFrame gabungan.</p><p>Kolom total_penjualan diperoleh dari perkalian jumlah produk terjual dengan harga produk. Data tersebut kemudian dianalisis menggunakan groupBy() dan sum() untuk mengetahui total penjualan setiap produk pada masing-masing toko.</p><p>Window function dengan row_number() digunakan untuk menentukan tiga produk terlaris pada setiap toko. Sementara itu, Spark SQL digunakan untuk menghitung kontribusi penjualan berdasarkan kota dan manajer. Kedua metode tersebut memberikan informasi yang berbeda tetapi saling melengkapi dalam proses analisis.</p><p>Pada tahap akhir, hasil pengolahan disimpan dalam format Parquet yang dipartisi berdasarkan kategori produk. Data kemudian dibaca kembali untuk menghasilkan ringkasan eksekutif berisi total penjualan, jumlah transaksi, dan rata-rata nilai penjualan per transaksi.</p><p>Secara keseluruhan, praktikum menunjukkan bahwa HDFS, PySpark, Spark SQL, window function, dan Parquet dapat digunakan bersama untuk membangun alur analisis data yang terstruktur.</p><h3>7. Latihan Mandiri</h3><h4>7.1 Persiapan Data</h4><pre># Persiapan ulang untuk latihan<br>spark = SparkSession.builder.appName(&quot;Latihan7&quot;).master(&quot;local[*]&quot;).getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br>df_transaksi = spark.read.csv(&quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_transaksi_triwulan.csv&quot;, header=True, inferSchema=True)<br>df_toko = spark.read.json(&quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_toko.json&quot;)<br>df_produk = spark.read.csv(&quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_produk.csv&quot;, header=True, inferSchema=True)<br>df_gabungan = df_transaksi.join(df_toko, on=&quot;toko_id&quot;).join(df_produk, on=&quot;product_id&quot;)<br>df_gabungan = df_gabungan.withColumn(&quot;total_penjualan&quot;, col(&quot;qty&quot;) * col(&quot;harga&quot;))<br>print(&quot;Siap untuk latihan. Total baris:&quot;, df_gabungan.count())</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/290/1*UChQxody5rn3-Qkg-rVO0Q.png" /></figure><h4>7.2 Soal 1 — Menentukan Kategori dengan Jumlah Penjualan Tertinggi Menggunakan Spark SQL</h4><pre>from pyspark.sql.functions import col<br><br># Menggabungkan data transaksi dengan data toko<br>df_gabungan = df_transaksi.join(<br>    df_toko,<br>    on=&quot;toko_id&quot;,<br>    how=&quot;inner&quot;<br>)<br><br># Menggabungkan hasilnya dengan data produk<br>df_gabungan = df_gabungan.join(<br>    df_produk,<br>    on=&quot;product_id&quot;,<br>    how=&quot;inner&quot;<br>)<br><br># Menampilkan hasil penggabungan<br>df_gabungan.show(5)<br><br># Membuat temporary view<br>df_gabungan.createOrReplaceTempView(&quot;gabungan&quot;)<br><br># Menjalankan query Spark SQL<br>hasil_latihan1 = spark.sql(&quot;&quot;&quot;<br>    SELECT kategori, SUM(qty) AS total_qty<br>    FROM gabungan<br>    GROUP BY kategori<br>    ORDER BY total_qty DESC<br>&quot;&quot;&quot;)<br><br># Menampilkan hasil<br>hasil_latihan1.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/702/1*A34Qxl5eWYfMLLkwIi9zhQ.png" /></figure><h4>7.3 Soal 2 — Menentukan Toko dengan Penjualan Tertinggi pada Setiap Kategori</h4><pre>from pyspark.sql.functions import col, sum as spark_sum, rank<br>from pyspark.sql.window import Window<br><br># Menghitung total penjualan<br>df_gabungan = df_gabungan.withColumn(<br>    &quot;total_penjualan&quot;,<br>    col(&quot;qty&quot;) * col(&quot;harga&quot;)<br>)<br><br># Mengelompokkan data berdasarkan kategori dan nama toko<br>ringkasan_toko = df_gabungan.groupBy(<br>    &quot;kategori&quot;, &quot;nama_toko&quot;<br>).agg(<br>    spark_sum(&quot;total_penjualan&quot;).alias(&quot;total_penjualan&quot;)<br>)<br><br># Membuat window berdasarkan kategori<br>window_kategori = Window.partitionBy(<br>    &quot;kategori&quot;<br>).orderBy(<br>    col(&quot;total_penjualan&quot;).desc()<br>)<br><br># Memberikan peringkat pada setiap toko<br>hasil_soal2 = ringkasan_toko.withColumn(<br>    &quot;peringkat&quot;,<br>    rank().over(window_kategori)<br>)<br><br># Menampilkan hasil<br>hasil_soal2.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/399/1*HPeWRZp2vLRbmzEbz27Fqg.png" /></figure><h4>7.4 Soal 3 — Menyimpan Ringkasan Eksekutif ke HDFS</h4><pre>from pyspark.sql.functions import (<br>    sum as spark_sum,<br>    count as spark_count,<br>    avg as spark_avg,<br>    col<br>)<br><br>ringkasan_eksekutif = df_final.groupBy(<br>    &quot;nama_toko&quot;, &quot;kota&quot;, &quot;manager&quot;<br>).agg(<br>    spark_sum(&quot;total_penjualan&quot;).alias(&quot;total_penjualan_triwulan&quot;),<br>    spark_count(&quot;trx_id&quot;).alias(&quot;jumlah_transaksi&quot;),<br>    spark_avg(&quot;total_penjualan&quot;).alias(&quot;rata_rata_nilai_transaksi&quot;)<br>).orderBy(<br>    col(&quot;total_penjualan_triwulan&quot;).desc()<br>)<br><br># Menampilkan hasil<br>ringkasan_eksekutif.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/742/1*YchWsh4szaFElwNVCKi-JA.png" /></figure><h4>7.5 Soal 4 — Refleksi Menyeluruh</h4><blockquote>HDFS, Spark, dan Parquet memiliki fungsi yang saling melengkapi dalam ekosistem Big Data. HDFS digunakan sebagai <em>distributed storage</em> untuk menyimpan data dalam jumlah besar, sedangkan Spark melakukan pemrosesan data secara efisien melalui <em>in-memory processing</em>. Parquet merupakan format penyimpanan kolumnar yang membantu menghemat ruang dan mempercepat pembacaan kolom tertentu. Selain itu, partisi dapat membantu proses analisis ketika data difilter berdasarkan kategori tertentu. Kombinasi ketiganya membuat proses penyimpanan, pengolahan, dan analisis data menjadi lebih terstruktur.</blockquote><h3>8. Refleksi</h3><p>Melalui praktikum ini, saya memahami bahwa analisis Big Data tidak hanya dilakukan dengan mengolah data, tetapi juga membutuhkan proses penyimpanan dan pengelolaan data yang tepat. HDFS digunakan untuk menyimpan data, sedangkan PySpark membantu mengolah dan menggabungkan data dari berbagai sumber. Window function berguna untuk menentukan produk terlaris pada setiap toko, sementara Spark SQL mempermudah analisis menggunakan query SQL. Penyimpanan dalam format Parquet juga membantu mengorganisasi hasil pengolahan agar lebih efisien untuk digunakan kembali.</p><h3>9. Kesimpulan</h3><p>Praktikum Pertemuan 7 membahas penerapan alur analisis Big Data secara menyeluruh, mulai dari membaca data melalui HDFS hingga menghasilkan ringkasan penjualan menggunakan PySpark. Operasi join, window function, dan Spark SQL digunakan untuk menggabungkan data, menentukan produk terlaris, serta menganalisis kontribusi manajer. Hasil pengolahan disimpan dalam format Parquet dengan partisi berdasarkan kategori produk. Dengan demikian, praktikum ini memberikan pemahaman mengenai penerapan konsep Big Data untuk menghasilkan informasi yang mendukung pengambilan keputusan bisnis.</p><h3>GitHub</h3><p><a href="https://github.com/manggalaayudha/Praktikum-BigData/tree/69cbee08d998a6f73e7ff4accd7db022a5fe9134/Pertemuan-7">https://github.com/manggalaayudha/Praktikum-BigData/tree/69cbee08d998a6f73e7ff4accd7db022a5fe9134/Pertemuan-7</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f31850398715" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PBO: Polimorfisme]]></title>
            <link>https://medium.com/@bagusmanggalayudha/pbo-polimorfisme-dbcb6b97cad6?source=rss-2518abaf0d61------2</link>
            <guid isPermaLink="false">https://medium.com/p/dbcb6b97cad6</guid>
            <category><![CDATA[netbeans]]></category>
            <category><![CDATA[polimorfisme]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Bagus Manggala Yudha]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 14:35:18 GMT</pubDate>
            <atom:updated>2026-10-08T14:35:18.899Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x9X3Gjx7s-Cm22u2LXbh2w.png" /></figure><p><strong>Halo Semuanya!</strong></p><p>Saya Bagus Manggala Yudha, mahasiswa Teknologi Informasi di Universitas Tidar. Pada Praktikum Pemrograman Berorientasi Objek kali ini, kita akan mempelajari tentang Polimorfisme pada bahasa pemrograman Java di software NetBeans.</p><h3>Pendahuluan</h3><p>Pemrograman Berorientasi Objek (PBO) memiliki empat pilar utama, salah satunya adalah <strong>Polimorfisme</strong>. Polimorfisme berasal dari bahasa Yunani yang berarti <em>“banyak bentuk”</em>. Dalam dunia pemrograman Java, polimorfisme memungkinkan satu antarmuka (interface/superclass) digunakan oleh berbagai kelas turunan (<em>subclass</em>) dengan implementasi perilaku yang berbeda-beda.</p><p>Laporan praktikum ini membahas konsep Polimorfisme, perbedaan antara <strong>Method Overloading</strong> dan <strong>Method Overriding</strong>, serta implementasi studi kasus nyata berupa sistem kalkulasi diskon produk belanja.</p><h3>Dasar Teori</h3><h4>1. Polimorfisme</h4><p>Polimorfisme memungkinkan objek dari kelas turunan diperlakukan sebagai objek dari kelas induknya. Konsep ini dibagi menjadi dua jenis utama:</p><ul><li><strong>Compile-time Polymorphism (Static Polymorphism):</strong> Dicapai melalui <em>Method Overloading</em>.</li><li><strong>Runtime Polymorphism (Dynamic Polymorphism):</strong> Dicapai melalui <em>Method Overriding</em>.</li></ul><h4>2. Overloading vs Overriding</h4><ul><li><strong>Overloading:</strong> Memiliki beberapa metode dengan nama yang sama dalam <strong>satu kelas yang sama</strong>, namun memiliki parameter (jumlah atau tipe data) yang berbeda.</li><li><strong>Overriding:</strong> Kelas turunan (<em>subclass</em>) mendefinisikan ulang atau mengganti implementasi metode yang sudah ada pada kelas induk (<em>superclass</em>).</li></ul><h3>Praktikum</h3><h4>1. Persiapan</h4><ol><li>Buka NetBeans IDE pada perangkat laptop/komputer.</li><li>Buat proyek baru dengan nama PraktikumPBO_6.</li><li>Buat package baru bernama praktikum6.</li></ol><h4>2. Implementation of Overloading</h4><p>Pada langkah ini, kita membuat kelas Hewan yang memiliki metode makan() yang ter-overload (memiliki dua signature parameter berbeda).</p><p><strong>Kode Program </strong><strong>Hewan.java:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/682/1*_ZxG-IVX938k_byFijOMNA.png" /></figure><p><strong>Kode Program </strong><strong>Main.java:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/421/1*0n8ybR_gCwUdR1E73Z30dQ.png" /></figure><p><strong>Output:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/292/1*sXB3zKl3P-ozwqe-PmxGNg.png" /></figure><h4>3. Implementation of Overriding</h4><p>Membuat 2 kelas turunan dari kelas hewan dengan nama kucing dan anjing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/381/1*fAwww7z9hFzJGEUFiKR-Fw.png" /></figure><p>Memanggil metode suara() pada objek tersebut dan lihat bagaimana Java<br>menentukan metode yang sesuai berdasarkan objek nyata.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/439/1*KRxHIOLdwc6B-rq3utlNPA.png" /></figure><p><strong>Output:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/286/1*NupwFybLOCS6tFEkosbwQw.png" /></figure><h4>Analisis Hasil Praktikum:</h4><ul><li><strong>Overloading:</strong> Terbukti dari pemanggilan kucing.makan(&quot;ikan&quot;) dan kucing.makan(&quot;ikan&quot;, 2) yang mengeksekusi blok kode yang berbeda sesuai dengan argumen parameter yang dioperkan.</li><li><strong>Overriding:</strong> Ketika hewan.bersuara() dipanggil, sistem secara <em>runtime</em> memanggil metode bersuara() pada kelas Kucing (&quot;Meow&quot;) alih-alih kelas Hewan (&quot;Hewan bersuara&quot;).</li></ul><blockquote>Tugas</blockquote><p>Soal<br>●​ Buat kelas abstrak Produk dengan atribut nama dan harga.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/598/1*h3DjpZajHR1lR_9riXnMZQ.png" /></figure><p>●​ Buat kelas turunan Buku, Elektronik, dan Pakaian yang mewarisi kelas Produk.</p><p>●​ Override metode hitungDiskon() pada setiap kelas turunan untuk menghitung diskon yang berbeda-beda.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/431/1*EZmJLMEmH5pio0CdYvnWaw.png" /><figcaption>Buku.java</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/431/1*P2WAIfqC_qWSt9dN-LBN_A.png" /><figcaption>Elektronik.java</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/431/1*O79ogtH7wYZB4QCwBDuoGg.png" /><figcaption>Pakaian.java</figcaption></figure><p>●​ Buatlah sebuah kelas KeranjangBelanja yang menyimpan list of Produk dan memiliki metode untuk menghitung total harga setelah diskon.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/1*UqZfi1ftnzZfJawvxG_wjg.png" /><figcaption>KeranjangBelanja.java</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/766/1*pDHwYJ9j1u3PVN5vgwvcWQ.png" /><figcaption>Main.java</figcaption></figure><p><strong>Output:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*MGB0usL8jfyIy440URURBw.png" /></figure><h3>Kesimpulan</h3><p>Dari praktikum dan tugas yang telah dikerjakan, dapat disimpulkan bahwa:</p><ol><li><strong>Polimorfisme</strong> memungkinkan penulisan kode Java yang lebih fleksibel, reusabel, dan modular.</li><li><strong>Method Overloading</strong> terjadi pada satu kelas dengan parameter berbeda (ditentukan saat <em>compile-time</em>).</li><li><strong>Method Overriding</strong> terjadi ketika kelas turunan mengubah perilaku metode milik kelas induk (ditentukan saat <em>runtime</em>).</li><li>Penerapan kelas abstrak dan polimorfisme pada tugas KeranjangBelanja terbukti mempermudah pengelolaan objek berkategori beda (Buku, Elektronik, Pakaian) di dalam satu koleksi tipe induk Produk.</li></ol><h3>GitHub:</h3><p><a href="https://github.com/manggalaayudha/Pemrograman-Berorientasi-Objek/tree/381fec11589d8a10f3887d28f113f2acae2eb04e/Pertemuan%206">https://github.com/manggalaayudha/Pemrograman-Berorientasi-Objek/tree/381fec11589d8a10f3887d28f113f2acae2eb04e/Pertemuan%206</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dbcb6b97cad6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>