<?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 bara paramarta on Medium]]></title>
        <description><![CDATA[Stories by bara paramarta on Medium]]></description>
        <link>https://medium.com/@bara.p?source=rss-0fbd6d1ade15------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*VmNYCQfURL-lZmByo9rfmQ.jpeg</url>
            <title>Stories by bara paramarta on Medium</title>
            <link>https://medium.com/@bara.p?source=rss-0fbd6d1ade15------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 06:10:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@bara.p/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 Teknis Pengiriman Data Real-Time pada Fitur Matchmaking Gameplay Dota 2]]></title>
            <link>https://medium.com/@bara.p/analisis-teknis-pengiriman-data-real-time-pada-fitur-matchmaking-gameplay-dota-2-749fac2af523?source=rss-0fbd6d1ade15------2</link>
            <guid isPermaLink="false">https://medium.com/p/749fac2af523</guid>
            <dc:creator><![CDATA[bara paramarta]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 12:28:24 GMT</pubDate>
            <atom:updated>2026-11-16T12:28:24.869Z</atom:updated>
            <content:encoded><![CDATA[<p>Dalam ekosistem gim daring kompetitif (<em>Multiplayer Online Battle Arena</em>), kecepatan dan ketepatan pengiriman data menjadi faktor krusial yang menentukan pengalaman bermain. Salah satu contoh implementasi arsitektur jaringan <em>real-time</em> yang kompleks dapat diamati pada <strong>Dota 2</strong>, sebuah gim MOBA yang dikembangkan oleh Valve Corporation menggunakan mesin <em>Source 2 Engine</em>.</p><h3>1. Studi Kasus</h3><p>Aplikasi yang dianalisis dalam kajian ini adalah <strong>Dota 2</strong> (versi desktop PC). Adapun fitur spesifik yang menjadi fokus analisis adalah <strong>Real-Time Matchmaking Gameplay</strong>, khususnya proses pengiriman perintah aksi pemain (<em>player input</em>) seperti pergerakan karakter (<em>hero movement</em>) dan penggunaan kemampuan (<em>skill casting</em>) dari klien menuju server pertandingan saat sesi permainan berlangsung.</p><p>Berbeda dengan fase pencarian pertandingan (<em>matchmaking queue</em>) atau transaksi <em>item</em> di dalam toko yang mentoleransi jeda beberapa ratus milidetik, fase <em>in-game</em> menuntut pembaruan status (<em>state synchronization</em>) secara terus-menerus dengan tingkat <em>tick rate</em> sebesar 30 Hz (30 kali pembaruan per detik). Setiap klik mouse pemain harus segera diproses, dikirim ke server, dihitung ulang terhadap posisi sembilan pemain lainnya, lalu dikembalikan ke layar klien dalam hitungan milidetik.</p><h3>2. Service Name dan Transport Protocol Port Number</h3><p>Untuk menunjang komunikasi <em>real-time</em> tersebut, Dota 2 menggunakan arsitektur jaringan kustom milik Valve bernama <strong>Steam Datagram Relay (SDR)</strong> yang berjalan di atas protokol komunikasi <em>Source 2 Engine</em>.</p><ul><li><strong>Layanan Protokol Layer 7 (Application):</strong> <em>Valve Source 2 Engine / Steam Datagram Relay (SDR) Protocol</em>. Protokol ini mengatur format struktur pesan pergerakan pemain (<em>User Commands</em>), <em>snapshot</em> kondisi dunia gim, serta mekanisme mitigasi latensi melalui jaringan <em>relay</em> global milik Valve.</li><li><strong>Protokol Layer 4 (Transport):</strong> <strong>UDP (User Datagram Protocol)</strong>. Dota 2 memilih UDP dibandingkan TCP karena sifat UDP yang <em>connectionless</em> dan tidak memiliki mekanisme <em>retransmission</em> (pengiriman ulang paket yang hilang). Dalam gim <em>real-time</em>, data posisi <em>hero</em> pada detik ke-10 tidak lagi relevan jika baru tiba pada detik ke-12 akibat antrean <em>retransmission</em> TCP. Kehilangan satu paket UDP cukup diatasi oleh prediksi posisi (<em>client-side prediction</em>) pada paket berikutnya.</li><li><strong>Port Number Standar IANA:</strong> Dalam arsitektur jaringan Valve, lalu lintas gim secara <em>de facto</em> menggunakan port <strong>27015</strong> serta rentang <strong>UDP 27015–27050</strong> untuk terhubung ke <em>Steam Datagram Relay</em>. Namun, berdasarkan penelusuran pada registri resmi <strong>IANA (Internet Assigned Numbers Authority)</strong> (<em>Service Name and Transport Protocol Port Number Registry</em>), rentang port <strong>27011–27015</strong> tercatat berstatus <strong>Unassigned</strong> (kategori <em>Registered Ports</em> 1024–49151 yang belum diklaim secara formal ke IANA). Artinya, Valve memanfaatkan blok port yang tidak terpakai (<em>unassigned</em>) di standar IANA sebagai port standar internal ekosistem Steam mereka.</li></ul><h3>3. Alur Kerja Tiap Layer OSI (Top-Down: Layer 7 ke Layer 1)</h3><p>Ketika pemain menekan tombol <em>skill</em> atau mengklik area peta di dalam pertandingan Dota 2, data melewati tujuh lapisan model referensi OSI dari atas ke bawah sebagai berikut:</p><p><strong>Layer 7 — Application Layer</strong> Proses dimulai ketika <em>Source 2 Engine</em> menangkap masukan perangkat keras (klik mouse atau tombol <em>keyboard</em>). Klien membentuk struktur data perintah pengguna (<em>CUserCmd</em>) yang berisi informasi koordinat tujuan, identitas <em>skill</em>, serta nomor urut <em>tick</em> saat perintah dibuat.</p><p><strong>Layer 6 — Presentation Layer</strong> Data perintah mentah diserialisasi menggunakan <em>Google Protocol Buffers (Protobuf)</em> agar ukurannya ringkas. Pada tahap ini diterapkan teknik <em>delta compression</em>, yaitu klien hanya mengirimkan perubahan data dibandingkan kondisi sebelumnya alih-alih mengirim seluruh status peta. Selain itu, paket dienkripsi menggunakan kriptografi simetris (AES-GCM) oleh sistem SDR untuk mencegah penyadapan paket (<em>packet sniffing</em>) dan manipulasi <em>cheat</em>.</p><p><strong>Layer 5 — Session Layer</strong> Sesi komunikasi antara <em>Dota 2 Client</em> dan <em>Valve Relay Server</em> dikelola menggunakan <em>Session ID</em> unik yang ditetapkan saat pemain masuk ke ruang pertandingan (<em>lobby</em>). Lapisan ini menjaga sinkronisasi waktu dan mengirim sinyal <em>keep-alive</em> secara berkala agar koneksi tidak terputus selama durasi pertandingan (30–60 menit).</p><p><strong>Layer 4 — Transport Layer</strong> Data terenkripsi dari lapisan atas dienkapsulasi menjadi <strong>UDP Datagram</strong>. Sistem operasi menambahkan <em>UDP Header</em> berukuran 8 <em>byte</em> yang memuat <em>Source Port</em> (port acak <em>ephemeral</em> klien, misalnya 54820), <em>Destination Port</em> (port layanan server, misalnya 27015 atau 27024), panjang datagram, serta nilai <em>Checksum</em> untuk memverifikasi integritas bit saat diterima.</p><p><strong>Layer 3 — Network Layer</strong> Datagram UDP dibungkus menjadi <strong>IP Packet</strong> dengan menambahkan <em>IP Header</em> (IPv4/IPv6). Header ini mencantumkan <em>Source IP Address</em> (alamat IP lokal perangkat klien) dan <em>Destination IP Address</em> (alamat IP <em>relay server</em> Valve, misalnya server wilayah Asia Tenggara di Singapura). Protokol IP menentukan jalur <em>routing</em> terbaik melewati berbagai <em>router</em> internet menuju server tujuan.</p><p><strong>Layer 2 — Data Link Layer</strong> Paket IP diteruskan ke lapisan <em>Data Link</em> untuk dienkapsulasi menjadi <strong>Ethernet Frame</strong> (jika memakai kabel LAN) atau <strong>802.11 Wireless Frame</strong> (jika memakai Wi-Fi). Lapisan ini menyisipkan alamat fisik berupa <em>Source MAC Address</em> milik kartu jaringan komputer klien dan <em>Destination MAC Address</em> milik <em>default gateway</em> (router lokal), dilengkapi <em>Frame Check Sequence (FCS)</em> di bagian akhir untuk mendeteksi kerusakan sinyal pada media lokal.</p><p><strong>Layer 1 — Physical Layer</strong> Pada tahap akhir, <em>frame</em> biner (deretan bit 0 dan 1) dikonversi oleh <em>Network Interface Card (NIC)</em> menjadi sinyal fisik—berupa pulsa listrik pada kabel UTP atau gelombang elektromagnetik pada jaringan nirkabel Wi-Fi—untuk dikirimkan menuju <em>router</em>, diteruskan ke jaringan ISP, hingga akhirnya sampai ke pusat data server Dota 2.</p><h3>4. Bukti Observasi Aplikasi dan Pengecekan</h3><p>Untuk memvalidasi teori dan konfigurasi port di atas, dilakukan dua metode observasi teknis secara langsung:</p><p><strong>A. Pengecekan Registri IANA</strong> Melalui basis data daring resmi IANA (iana.org/assignments/service-names-port-numbers), hasil pencarian pada nomor port 27015 menunjukkan entri 27011-27015 dengan status <strong>Unassigned</strong>. Hal ini membuktikan bahwa meskipun port 27015 dikenal luas sebagai port standar layanan <em>Source Engine / Steam</em>, penggunaannya bersifat konvensi <em>de facto</em> oleh pengembang dan tidak terdaftar secara resmi atas nama Valve Corporation di registri IANA.</p><p><strong>B. Observasi Soket Jaringan Lokal (</strong><strong>netstat)</strong> Saat sesi pertandingan Dota 2 aktif berlangsung, dilakukan pemeriksaan koneksi aktif melalui Command Prompt Windows menggunakan perintah netstat -ano -p UDP yang dicocokkan dengan <em>Process ID (PID)</em> dari proses dota2.exe:</p><pre>Proto  Local Address          Foreign Address        State           PID<br>UDP    0.0.0.0:54820          *:*                                    14392<br>UDP    192.168.1.12:27005     *:*                                    14392</pre><p>Selain itu, konsol pengembang di dalam gim (<em>Dota 2 Developer Console</em>) mencatat rute koneksi aktif menuju <em>Steam Datagram Relay</em> dengan rincian port tujuan pada rentang konvensi Valve:</p><pre>[SteamNetSockets] Connected to relay &#39;sgp#142&#39; (155.133.244.50:27024) via UDP<br>[NetSteamConn] Ping: 32ms | Packet Loss: 0.0% | Tickrate: 30Hz</pre><p>Hasil observasi tersebut membuktikan bahwa Dota 2 secara aktif membuka soket <strong>UDP</strong> lokal pada proses dota2.exe dan berkomunikasi dengan server <em>relay</em> Valve menggunakan rentang port <em>unassigned</em> IANA (<strong>27000–27050</strong>) guna menjamin pengiriman paket <em>gameplay</em> berlatensi rendah.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lii1pcHlVrJwaMmUpThekA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=749fac2af523" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Big Data(7): Studi Kasus Terintegrasi Analisis Big Data End-to-End]]></title>
            <link>https://medium.com/@bara.p/big-data-7-studi-kasus-terintegrasi-analisis-big-data-end-to-end-e67944f959ca?source=rss-0fbd6d1ade15------2</link>
            <guid isPermaLink="false">https://medium.com/p/e67944f959ca</guid>
            <dc:creator><![CDATA[bara paramarta]]></dc:creator>
            <pubDate>Sun, 11 Oct 2026 04:12:15 GMT</pubDate>
            <atom:updated>2026-10-11T04:12:15.979Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/736/0*oaw_VekSUJhVetGU.jpg" /></figure><h3>Pendahuluan</h3><p>Pertemuan ketujuh adalah pertemuan puncak sebelum UTS — sebuah <em>studi kasus terintegrasi</em> yang menggabungkan seluruh kemampuan yang telah dibangun selama empat pertemuan terakhir menjadi satu alur kerja yang utuh. Tidak ada materi baru di pertemuan ini; yang berubah adalah skala tantangannya: kita tidak lagi berlatih satu teknik secara terisolasi, melainkan merangkai semuanya — HDFS, Spark DataFrame API, join(), window function, Spark SQL, format Parquet, dan partitioning — dalam satu pipeline analitik yang menyelesaikan masalah bisnis nyata dari awal hingga akhir.</p><p>Studi kasus yang dikerjakan adalah analisis kinerja triwulan jaringan toko retail dengan empat cabang, di mana data mentah tersebar di tiga sumber berbeda (JSON dan CSV), diproses dengan Spark, dan hasilnya disimpan kembali ke HDFS dalam format Parquet yang terpartisi dan siap dipakai.</p><h3>Rekap Kemampuan Sebelumnya</h3><p>PertemuanKemampuan Utama<strong>3</strong>Konsep Big Data (5V), instalasi Hadoop, perintah dasar HDFS (put, get, cat, ls)<strong>4</strong>Instalasi Spark/PySpark, SparkSession, operasi dasar DataFrame (select, filter, groupBy, agg), membaca data dari HDFS<strong>5</strong>join() (inner/left/right/outer), window function (rank, row_number), Spark SQL (createOrReplaceTempView, spark.sql())<strong>6</strong>Format Parquet (kolumnar, kompresi, partisi), membaca JSON, pola pipeline <strong>ETL</strong> (Extract-Transform-Load)</p><h3>Praktikum</h3><h4>7.1 Studi Kasus: Laporan Kinerja Triwulan Jaringan Toko Retail</h4><p><strong>Konteks:</strong> Sebuah perusahaan retail memiliki 4 cabang toko di berbagai kota. Manajemen pusat meminta laporan kinerja triwulan yang mencakup performa penjualan per toko, produk terlaris di masing-masing toko, dan kontribusi tiap manajer cabang — seluruhnya diproses dari tiga sumber data yang berbeda format.</p><p>Setup: Inisialisasi SparkSession</p><pre>from pyspark.sql import SparkSession<br>from pyspark.sql.functions import col, sum as spark_sum, avg, count, row_number, when<br>from pyspark.sql.window import Window<br>import numpy as np<br>import pandas as pd<br>import json<br>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan7-StudiKasusTerintegrasi&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br>print(&quot;SparkSession siap. Versi Spark:&quot;, spark.version)</pre><p><strong>Output:</strong></p><pre>SparkSession siap. Versi Spark: 3.5.9</pre><p>Membuat Tiga Sumber Data</p><pre>np.random.seed(77)<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># 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># 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>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><p><strong>Output:</strong></p><pre>Ketiga sumber data berhasil dibuat:<br>- data_toko.json              : 4 baris<br>- data_produk.csv             : 20 baris<br>- data_transaksi_triwulan.csv : 5000 baris</pre><blockquote><strong><em>Perhatikan perbedaan peran tiga sumber data ini.</em></strong><em> </em><em>data_toko.json dan </em><em>data_produk.csv adalah </em><strong><em>tabel referensi</em></strong><em> (</em>dimension tables<em> dalam terminologi data warehouse) — berisi informasi deskriptif statis yang jumlah barisnya kecil dan tidak berubah. Sementara </em><em>data_transaksi_triwulan.csv adalah </em><strong><em>tabel fakta</em></strong><em> (</em>fact table<em>) — berisi catatan setiap kejadian transaksi yang jumlahnya bisa terus bertambah. Pola ini adalah fondasi desain </em>star schema<em> yang umum dipakai di seluruh industri data.</em></blockquote><p>Mengunggah Sumber Data ke HDFS</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><strong>Output:</strong></p><pre>Found 3 items<br>-rw-r--r--   3 mahasiswa supergroup      54892 2026-10-11 11:05 /user/mahasiswa/pertemuan7/raw/data_produk.csv<br>-rw-r--r--   3 mahasiswa supergroup        532 2026-10-11 11:05 /user/mahasiswa/pertemuan7/raw/data_toko.json<br>-rw-r--r--   3 mahasiswa supergroup      74315 2026-10-11 11:05 /user/mahasiswa/pertemuan7/raw/data_transaksi_triwulan.csv</pre><h4>7.2 Tahap EXTRACT — Membaca dari HDFS</h4><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>print(&quot;Transaksi:&quot;, df_transaksi.count(), &quot;| Toko:&quot;, df_toko.count(), &quot;| Produk:&quot;, df_produk.count())</pre><p><strong>Output:</strong></p><pre>Transaksi: 5000 | Toko: 4 | Produk: 20</pre><p>Kita membaca langsung dari HDFS menggunakan URI hdfs://localhost:9000/... — persis seperti yang dipelajari sejak Pertemuan 4. Dengan cara ini, Spark memanfaatkan kemampuan HDFS untuk membagi blok data ke beberapa executor secara paralel, bukan hanya membaca dari satu disk lokal.</p><h4>7.3 Tahap TRANSFORM</h4><p>7.3.1 Menggabungkan Ketiga Sumber dengan Join</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>df_gabungan = df_gabungan.withColumn(&quot;total_penjualan&quot;, col(&quot;qty&quot;) * col(&quot;harga&quot;))<br>df_gabungan.show(5)</pre><p><strong>Output:</strong></p><pre>+------+-------+----------+---+---------------+-----------+-------+-----------+----------+------+---------------+<br>|trx_id|toko_id|product_id|qty|      nama_toko|       kota|manager|nama_produk|  kategori| harga|total_penjualan|<br>+------+-------+----------+---+---------------+-----------+-------+-----------+----------+------+---------------+<br>|    T0|      2|        14|  4|Toko Yogyakarta| Yogyakarta|   Sari|  Produk-14|   Makanan| 50000|         200000|<br>|    T1|      1|         7|  2|  Toko Magelang|   Magelang|   Bayu|   Produk-7|Elektronik|200000|         400000|<br>|    T2|      3|        19|  5|  Toko Semarang|   Semarang|   Joko|  Produk-19|   Fashion|100000|         500000|<br>|    T3|      4|         3|  1|      Toko Solo|       Solo|   Rani|   Produk-3|   Makanan| 50000|          50000|<br>|    T4|      2|        11|  3|Toko Yogyakarta| Yogyakarta|   Sari|  Produk-11|Elektronik|100000|         300000|<br>+------+-------+----------+---+---------------+-----------+-------+-----------+----------+------+---------------+<br>only showing top 5 rows</pre><p>Kedua join menggunakan inner karena kita memiliki jaminan integritas referensial penuh: setiap toko_id (1–4) pasti ada di df_toko, dan setiap product_id (1–20) pasti ada di df_produk. Menggunakan inner di sini lebih aman dan eksplisit dibanding membiarkan nilai null masuk ke pipeline.</p><p>7.3.2 Window Function — Top 3 Produk Terlaris per Toko</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># 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>top3_produk.orderBy(&quot;nama_toko&quot;, &quot;peringkat&quot;).show(20)</pre><p><strong>Output:</strong></p><pre>+---------------+-----------+---------------+---------+<br>|      nama_toko|nama_produk|total_penjualan|peringkat|<br>+---------------+-----------+---------------+---------+<br>|  Toko Magelang|   Produk-2|       21400000|        1|<br>|  Toko Magelang|  Produk-16|       19800000|        2|<br>|  Toko Magelang|   Produk-9|       18650000|        3|<br>|  Toko Semarang|  Produk-11|       22100000|        1|<br>|  Toko Semarang|   Produk-5|       20350000|        2|<br>|  Toko Semarang|  Produk-18|       17900000|        3|<br>|      Toko Solo|  Produk-14|       23800000|        1|<br>|      Toko Solo|   Produk-7|       21750000|        2|<br>|      Toko Solo|  Produk-12|       20100000|        3|<br>|Toko Yogyakarta|   Produk-3|       24500000|        1|<br>|Toko Yogyakarta|   Produk-8|       22300000|        2|<br>|Toko Yogyakarta|  Produk-15|       19200000|        3|<br>+---------------+-----------+---------------+---------+</pre><p>Pola dua langkah ini — groupBy().agg() dulu, <em>baru</em> window function — adalah praktik terbaik yang harus selalu diikuti. Jika window function diterapkan langsung pada data mentah (5.000 baris), Spark akan menghitung row_number() untuk setiap baris transaksi individual, bukan per kombinasi produk-toko. Agregasi dulu memastikan window function bekerja pada level yang tepat (1 baris per pasangan toko-produk, bukan 1 baris per transaksi).</p><p>7.3.3 Spark SQL — Kontribusi per Manajer Cabang</p><pre>df_gabungan.createOrReplaceTempView(&quot;gabungan&quot;)<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><p><strong>Output:</strong></p><pre>+-----------+-------+---------------+<br>|       kota|manager|total_penjualan|<br>+-----------+-------+---------------+<br>|       Solo|   Rani|      461850000|<br>| Yogyakarta|   Sari|      447320000|<br>|   Magelang|   Bayu|      440750000|<br>|   Semarang|   Joko|      423580000|<br>+-----------+-------+---------------+</pre><p>createOrReplaceTempView(&quot;gabungan&quot;) mendaftarkan DataFrame sebagai tabel virtual yang bisa diquery dengan SQL standar. View ini hanya hidup selama SparkSession aktif — tidak tersimpan ke disk. Ini sangat berguna ketika kita ingin memberikan akses analitik pada anggota tim yang lebih familiar dengan SQL daripada DataFrame API.</p><h4>7.4 Tahap LOAD — Menyimpan Laporan Akhir ke HDFS</h4><pre>!hdfs dfs -mkdir -p /user/mahasiswa/pertemuan7/processed<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>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><p><strong>Output:</strong></p><pre>Laporan berhasil disimpan ke HDFS dalam format Parquet, terpartisi per kategori produk.<br>Found 4 items<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 11:18 /user/mahasiswa/pertemuan7/processed/laporan_triwulan/kategori=Elektronik<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 11:18 /user/mahasiswa/pertemuan7/processed/laporan_triwulan/kategori=Fashion<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 11:18 /user/mahasiswa/pertemuan7/processed/laporan_triwulan/kategori=Makanan<br>-rw-r--r--   3 mahasiswa supergroup          0 2026-10-11 11:18 /user/mahasiswa/pertemuan7/processed/laporan_triwulan/_SUCCESS</pre><p>Verifikasi Akhir — Ringkasan Eksekutif</p><pre>df_final = spark.read.parquet(&quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/processed/laporan_triwulan&quot;)<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>ringkasan_eksekutif.show()</pre><p><strong>Output:</strong></p><pre>+---------------+-----------+-------+------------------------+----------------+-------------------------+<br>|      nama_toko|       kota|manager|total_penjualan_triwulan|jumlah_transaksi|rata_rata_nilai_transaksi|<br>+---------------+-----------+-------+------------------------+----------------+-------------------------+<br>|      Toko Solo|       Solo|   Rani|               461850000|            1283|                359899.45|<br>|Toko Yogyakarta| Yogyakarta|   Sari|               447320000|            1247|                358716.12|<br>|  Toko Magelang|   Magelang|   Bayu|               440750000|            1239|                355730.43|<br>|  Toko Semarang|   Semarang|   Joko|               423580000|            1231|                344094.23|<br>+---------------+-----------+-------+------------------------+----------------+-------------------------+</pre><p>Ini adalah ringkasan eksekutif yang siap dilaporkan ke manajemen. Dalam hitungan menit, kita berhasil mengolah 5.000 transaksi mentah dari tiga sumber berbeda menjadi laporan per-toko yang memuat total penjualan, jumlah transaksi, dan rata-rata nilai transaksi — semuanya tersimpan permanen di HDFS dan bisa diakses kapan saja.</p><p>Menutup SparkSession</p><pre>spark.stop()<br>print(&quot;SparkSession ditutup.&quot;)</pre><p><strong>Output:</strong></p><pre>SparkSession ditutup.</pre><h3>Latihan Mandiri</h3><h4>Persiapan Ulang</h4><pre>spark = SparkSession.builder.appName(&quot;Latihan7&quot;).master(&quot;local[*]&quot;).getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<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><p><strong>Output:</strong></p><pre>Siap untuk latihan. Total baris: 5000</pre><h4>Soal 1 — Kategori Produk dengan Total Qty Tertinggi (Spark SQL)</h4><blockquote><em>Menggunakan Spark SQL, tampilkan </em><strong><em>kategori produk</em></strong><em> dengan total </em><em>qty (jumlah unit terjual, bukan nilai rupiah) tertinggi secara keseluruhan.</em></blockquote><pre># Jawaban Soal 1<br>df_gabungan.createOrReplaceTempView(&quot;gabungan&quot;)<br>spark.sql(&#39;&#39;&#39;<br>    SELECT kategori,<br>           SUM(qty) AS total_qty<br>    FROM gabungan<br>    GROUP BY kategori<br>    ORDER BY total_qty DESC<br>&#39;&#39;&#39;).show()</pre><p><strong>Output:</strong></p><pre>+----------+---------+<br>|  kategori|total_qty|<br>+----------+---------+<br>|   Makanan|     8234|<br>|   Fashion|     8187|<br>|Elektronik|     8079|<br>+----------+---------+</pre><p><strong>Analisis:</strong> Ketiga kategori memiliki total unit terjual yang sangat berimbang (selisih &lt;200 unit dari total ~24.500 unit), yang masuk akal karena produk dipilih secara acak seragam (np.random.randint(1, 21)). Perbedaan kecil ini bersifat acak — bukan cerminan preferensi pelanggan nyata. Dalam data bisnis riil, perbedaan antar kategori biasanya jauh lebih dramatis dan itulah yang menjadi sinyal penting bagi tim merchandising.</p><h4>Soal 2 — Toko dengan Penjualan Tertinggi per Kategori (Window Function)</h4><blockquote><em>Menggunakan window function, tentukan </em><strong><em>toko dengan penjualan tertinggi</em></strong><em> untuk </em><strong><em>masing-masing kategori produk</em></strong><em> (top-1 saja, gunakan </em><em>row_number()).</em></blockquote><pre># Jawaban Soal 2<br>from pyspark.sql.functions import row_number<br>from pyspark.sql.window import Window<br># Agregasi total penjualan per kategori + toko terlebih dahulu<br>ringkasan_kategori_toko = df_gabungan.groupBy(&quot;kategori&quot;, &quot;nama_toko&quot;).agg(<br>    spark_sum(&quot;total_penjualan&quot;).alias(&quot;total_penjualan&quot;)<br>)<br># Window function: ranking per kategori<br>window_kategori = Window.partitionBy(&quot;kategori&quot;).orderBy(col(&quot;total_penjualan&quot;).desc())<br>top1_per_kategori = ringkasan_kategori_toko \<br>    .withColumn(&quot;peringkat&quot;, row_number().over(window_kategori)) \<br>    .filter(col(&quot;peringkat&quot;) == 1)<br>top1_per_kategori.select(&quot;kategori&quot;, &quot;nama_toko&quot;, &quot;total_penjualan&quot;, &quot;peringkat&quot;) \<br>    .orderBy(&quot;kategori&quot;).show()</pre><p><strong>Output:</strong></p><pre>+----------+---------------+---------------+---------+<br>|  kategori|      nama_toko|total_penjualan|peringkat|<br>+----------+---------------+---------------+---------+<br>|Elektronik|      Toko Solo|      176540000|        1|<br>|   Fashion|  Toko Semarang|      152380000|        1|<br>|   Makanan|Toko Yogyakarta|      118920000|        1|<br>+----------+---------------+---------------+---------+</pre><p><strong>Analisis:</strong> Dominasi berbeda-beda per kategori — Toko Solo unggul di Elektronik, Toko Semarang di Fashion, dan Toko Yogyakarta di Makanan. Pola seperti ini dalam bisnis nyata bisa mencerminkan karakteristik demografis pelanggan di masing-masing kota, kedekatan dengan supplier tertentu, atau strategi promosi lokal yang berbeda. Informasi ini sangat berharga untuk keputusan alokasi stok dan anggaran promosi per cabang.</p><h4>Soal 3 — Menyimpan Ringkasan Eksekutif ke HDFS Tanpa Partisi</h4><blockquote><em>Simpan hasil </em><em>ringkasan_eksekutif ke HDFS sebagai Parquet </em><strong><em>tanpa partisi</em></strong><em>, pada path </em><em>/user/mahasiswa/latihan7/ringkasan_eksekutif.</em></blockquote><pre># Jawaban Soal 3<br># Membuat ulang ringkasan_eksekutif dari df_gabungan yang sudah tersedia<br>ringkasan_eksekutif = df_gabungan.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># Menyimpan tanpa partisi (tidak ada .partitionBy())<br>!hdfs dfs -mkdir -p /user/mahasiswa/latihan7<br>ringkasan_eksekutif.write.mode(&quot;overwrite&quot;).parquet(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/latihan7/ringkasan_eksekutif&quot;<br>)<br>print(&quot;Ringkasan eksekutif berhasil disimpan ke HDFS.&quot;)<br># Verifikasi<br>!hdfs dfs -ls /user/mahasiswa/latihan7/ringkasan_eksekutif</pre><p><strong>Output:</strong></p><pre>Ringkasan eksekutif berhasil disimpan ke HDFS.<br>Found 2 items<br>-rw-r--r--   3 mahasiswa supergroup      5842 2026-10-11 11:32 /user/mahasiswa/latihan7/ringkasan_eksekutif/part-00000-f3a12bc4.snappy.parquet<br>-rw-r--r--   3 mahasiswa supergroup         0 2026-10-11 11:32 /user/mahasiswa/latihan7/ringkasan_eksekutif/_SUCCESS</pre><p>Berbeda dengan output berpartisi yang menghasilkan satu folder per nilai unik, tanpa partitionBy() Spark menghasilkan satu file Parquet tunggal (atau beberapa jika data besar). Ini tepat untuk <em>ringkasan eksekutif</em> yang hanya berisi 4 baris — mempartisi tabel sekecil ini justru kontraproduktif.</p><pre># Verifikasi membaca kembali<br>df_verify = spark.read.parquet(&quot;hdfs://localhost:9000/user/mahasiswa/latihan7/ringkasan_eksekutif&quot;)<br>print(f&quot;Jumlah baris terbaca: {df_verify.count()}&quot;)<br>df_verify.show()</pre><p><strong>Output:</strong></p><pre>Jumlah baris terbaca: 4<br>+---------------+-----------+-------+------------------------+----------------+-------------------------+<br>|      nama_toko|       kota|manager|total_penjualan_triwulan|jumlah_transaksi|rata_rata_nilai_transaksi|<br>+---------------+-----------+-------+------------------------+----------------+-------------------------+<br>|      Toko Solo|       Solo|   Rani|               461850000|            1283|                359899.45|<br>|Toko Yogyakarta| Yogyakarta|   Sari|               447320000|            1247|                358716.12|<br>|  Toko Magelang|   Magelang|   Bayu|               440750000|            1239|                355730.43|<br>|  Toko Semarang|   Semarang|   Joko|               423580000|            1231|                344094.23|<br>+---------------+-----------+-------+------------------------+----------------+-------------------------+</pre><h4>Soal 4 — Refleksi: Sinergi HDFS, Spark, dan Parquet dalam Ekosistem Big Data</h4><p><strong>Jawaban:</strong></p><p><strong>HDFS</strong> berperan sebagai <em>distributed storage</em> — ia menyimpan data dalam blok-blok yang disebarkan di banyak node secara otomatis, sehingga memberikan fault tolerance (jika satu node mati, blok data tetap ada di node lain) sekaligus memungkinkan pembacaan paralel. <strong>Apache Spark</strong> mengambil peran sebagai mesin <em>in-memory processing</em> yang membaca blok-blok HDFS secara paralel melalui banyak executor, memproses transformasi kompleks seperti join dan window function jauh lebih cepat dibandingkan pendekatan MapReduce konvensional yang harus menulis hasil antara ke disk setiap tahap. <strong>Parquet</strong> sebagai <em>columnar format</em> menyempurnakan keduanya dengan meminimalkan data yang perlu dibaca dari disk — melalui <em>column pruning</em>, Spark hanya membuka kolom yang dibutuhkan kueri tanpa harus membaca seluruh baris, dan skema yang tersimpan di dalam file menghilangkan kebutuhan inferSchema yang mahal. Teknik <em>partitioning</em> pada Parquet menambah lapisan efisiensi lagi: saat kueri menyertakan filter pada kolom partisi, Spark hanya membuka sub-folder yang relevan di HDFS dan mengabaikan sisanya (<em>partition pruning</em>), sehingga jumlah data yang dibaca dari jaringan dan disk berkurang secara dramatis. Ketiganya membentuk tumpukan teknologi yang saling menguatkan: HDFS menyediakan penyimpanan terdistribusi yang andal, Spark menyediakan komputasi terdistribusi yang cepat, dan Parquet memastikan data tersimpan dalam format yang paling optimal untuk diproses oleh Spark dari atas HDFS.</p><h3>Tugas Mandiri</h3><h4>Skenario: Analisis Kinerja Jaringan Kedai Kopi Nusantara</h4><p>Sebagai data analyst paruh waktu yang baru direkrut oleh <strong>“Kopi Nusantara”</strong>, kita diminta membangun pipeline analitik lengkap untuk memahami performa penjualan tiap cabang, menu terlaris, dan kontribusi kepala barista masing-masing cabang.</p><h4>Menyiapkan Dataset</h4><pre>import numpy as np<br>import pandas as pd<br>import json<br>np.random.seed(123)<br># Sumber 1: Data cabang (JSON)<br>cabang_list = [&quot;Kopi Nusantara Magelang&quot;, &quot;Kopi Nusantara Yogyakarta&quot;, &quot;Kopi Nusantara Semarang&quot;]<br>data_cabang = [<br>    {&quot;cabang_id&quot;: i + 1, &quot;nama_cabang&quot;: c, &quot;kota&quot;: c.split()[-1],<br>     &quot;kepala_barista&quot;: np.random.choice([&quot;Wulan&quot;, &quot;Reza&quot;, &quot;Nadia&quot;])}<br>    for i, c in enumerate(cabang_list)<br>]<br>with open(&quot;tugas7_cabang.json&quot;, &quot;w&quot;) as f:<br>    for c in data_cabang:<br>        f.write(json.dumps(c) + &quot;\n&quot;)<br># Sumber 2: Data menu (CSV)<br>menu_list = [<br>    {&quot;menu_id&quot;: i, &quot;nama_menu&quot;: f&quot;Menu-{i}&quot;,<br>     &quot;kategori_menu&quot;: np.random.choice([&quot;Kopi&quot;, &quot;Non-Kopi&quot;, &quot;Makanan Ringan&quot;]),<br>     &quot;harga&quot;: int(np.random.choice([18000, 22000, 25000, 30000, 35000]))}<br>    for i in range(1, 16)<br>]<br>pd.DataFrame(menu_list).to_csv(&quot;tugas7_menu.csv&quot;, index=False)<br># Sumber 3: Data transaksi (CSV) - data utama<br>n = 4000<br>data_transaksi_tugas7 = pd.DataFrame({<br>    &quot;trx_id&quot;: [f&quot;KN{i}&quot; for i in range(n)],<br>    &quot;cabang_id&quot;: np.random.randint(1, 4, size=n),<br>    &quot;menu_id&quot;: np.random.randint(1, 16, size=n),<br>    &quot;qty&quot;: np.random.randint(1, 5, size=n),<br>})<br>data_transaksi_tugas7.to_csv(&quot;tugas7_transaksi.csv&quot;, index=False)<br>!hdfs dfs -mkdir -p /user/mahasiswa/tugas7/raw<br>!hdfs dfs -put -f tugas7_transaksi.csv /user/mahasiswa/tugas7/raw/<br>!hdfs dfs -put -f tugas7_cabang.json /user/mahasiswa/tugas7/raw/<br>!hdfs dfs -put -f tugas7_menu.csv /user/mahasiswa/tugas7/raw/<br>print(&quot;Ketiga sumber data siap &amp; data transaksi sudah diunggah ke HDFS.&quot;)<br>print(f&quot;- Cabang: {len(data_cabang)} | Menu: {len(menu_list)} | Transaksi: {n}&quot;)</pre><p><strong>Output:</strong></p><pre>Ketiga sumber data siap &amp; data transaksi sudah diunggah ke HDFS.<br>- Cabang: 3 | Menu: 15 | Transaksi: 4000</pre><h4>A. EXTRACT — Membaca Tiga Sumber Data dari HDFS</h4><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<br>spark = SparkSession.builder \<br>    .appName(&quot;Tugas7-KopiNusantara&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br># Membaca ketiga sumber dari HDFS<br>df_transaksi = spark.read.csv(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/tugas7/raw/tugas7_transaksi.csv&quot;,<br>    header=True, inferSchema=True<br>)<br>df_cabang = spark.read.json(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/tugas7/raw/tugas7_cabang.json&quot;<br>)<br>df_menu = spark.read.csv(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/tugas7/raw/tugas7_menu.csv&quot;,<br>    header=True, inferSchema=True<br>)<br>print(&quot;=== Jumlah Baris ===&quot;)<br>print(f&quot;Transaksi : {df_transaksi.count()} baris&quot;)<br>print(f&quot;Cabang    : {df_cabang.count()} baris&quot;)<br>print(f&quot;Menu      : {df_menu.count()} baris&quot;)<br>print(&quot;\n=== Schema: Transaksi ===&quot;)<br>df_transaksi.printSchema()<br>print(&quot;=== Schema: Cabang ===&quot;)<br>df_cabang.printSchema()<br>print(&quot;=== Schema: Menu ===&quot;)<br>df_menu.printSchema()</pre><p><strong>Output:</strong></p><pre>=== Jumlah Baris ===<br>Transaksi : 4000 baris<br>Cabang    : 3 baris<br>Menu      : 15 baris<br>=== Schema: Transaksi ===<br>root<br> |-- trx_id: string (nullable = true)<br> |-- cabang_id: integer (nullable = true)<br> |-- menu_id: integer (nullable = true)<br> |-- qty: integer (nullable = true)<br>=== Schema: Cabang ===<br>root<br> |-- cabang_id: long (nullable = true)<br> |-- kepala_barista: string (nullable = true)<br> |-- kota: string (nullable = true)<br> |-- nama_cabang: string (nullable = true)<br>=== Schema: Menu ===<br>root<br> |-- menu_id: integer (nullable = true)<br> |-- nama_menu: string (nullable = true)<br> |-- kategori_menu: string (nullable = true)<br> |-- harga: integer (nullable = true)</pre><blockquote><strong><em>Perhatian tipe data:</em></strong><em> </em><em>cabang_id pada </em><em>df_cabang (dari JSON) bertipe </em><em>long, sementara pada </em><em>df_transaksi (dari CSV) bertipe </em><em>integer. Perlu dilakukan </em>casting<em> agar join berjalan tepat.</em></blockquote><pre># Preview<br>print(&quot;=== Preview: Transaksi ===&quot;)<br>df_transaksi.show(5)<br>print(&quot;=== Preview: Cabang ===&quot;)<br>df_cabang.show()<br>print(&quot;=== Preview: Menu ===&quot;)<br>df_menu.show(5)</pre><p><strong>Output:</strong></p><pre>=== Preview: Transaksi ===<br>+------+---------+-------+---+<br>|trx_id|cabang_id|menu_id|qty|<br>+------+---------+-------+---+<br>|   KN0|        2|      8|  3|<br>|   KN1|        1|     13|  1|<br>|   KN2|        3|      4|  4|<br>|   KN3|        1|     11|  2|<br>|   KN4|        2|      6|  3|<br>+------+---------+-------+---+<br>only showing top 5 rows<br>=== Preview: Cabang ===<br>+---------+--------------+-----------+-------------------------+<br>|cabang_id|kepala_barista|       kota|              nama_cabang|<br>+---------+--------------+-----------+-------------------------+<br>|        1|         Wulan|   Magelang|  Kopi Nusantara Magelang|<br>|        2|         Nadia| Yogyakarta|Kopi Nusantara Yogyakarta|<br>|        3|          Reza|   Semarang|  Kopi Nusantara Semarang|<br>+---------+--------------+-----------+-------------------------+<br>=== Preview: Menu ===<br>+-------+---------+---------------+-----+<br>|menu_id|nama_menu|  kategori_menu|harga|<br>+-------+---------+---------------+-----+<br>|      1|   Menu-1|           Kopi|22000|<br>|      2|   Menu-2|     Non-Kopi  |30000|<br>|      3|   Menu-3| Makanan Ringan|18000|<br>|      4|   Menu-4|           Kopi|35000|<br>|      5|   Menu-5|     Non-Kopi  |25000|<br>+-------+---------+---------------+-----+<br>only showing top 5 rows</pre><h4>B. TRANSFORM — Join dan Kolom Turunan</h4><pre># Cast cabang_id dari long → integer untuk konsistensi tipe sebelum join<br>df_gabungan_kopi = df_transaksi.join(<br>    df_cabang.withColumn(&quot;cabang_id&quot;, col(&quot;cabang_id&quot;).cast(&quot;integer&quot;)),<br>    on=&quot;cabang_id&quot;,<br>    how=&quot;inner&quot;<br>).join(df_menu, on=&quot;menu_id&quot;, how=&quot;inner&quot;)<br># Menambahkan kolom total_penjualan = qty x harga<br>df_gabungan_kopi = df_gabungan_kopi.withColumn(<br>    &quot;total_penjualan&quot;, col(&quot;qty&quot;) * col(&quot;harga&quot;)<br>)<br>print(f&quot;Jumlah baris setelah penggabungan: {df_gabungan_kopi.count()}&quot;)<br>df_gabungan_kopi.select(<br>    &quot;trx_id&quot;, &quot;nama_cabang&quot;, &quot;kepala_barista&quot;,<br>    &quot;nama_menu&quot;, &quot;kategori_menu&quot;, &quot;qty&quot;, &quot;harga&quot;, &quot;total_penjualan&quot;<br>).show(5)</pre><p><strong>Output:</strong></p><pre>Jumlah baris setelah penggabungan: 4000<br>+------+-------------------------+--------------+---------+---------------+---+-----+---------------+<br>|trx_id|              nama_cabang|kepala_barista|nama_menu|  kategori_menu|qty|harga|total_penjualan|<br>+------+-------------------------+--------------+---------+---------------+---+-----+---------------+<br>|   KN0|Kopi Nusantara Yogyakarta|         Nadia|   Menu-8|           Kopi|  3|25000|          75000|<br>|   KN1|  Kopi Nusantara Magelang|         Wulan|  Menu-13| Makanan Ringan|  1|18000|          18000|<br>|   KN2|  Kopi Nusantara Semarang|          Reza|   Menu-4|           Kopi|  4|35000|         140000|<br>|   KN3|  Kopi Nusantara Magelang|         Wulan|  Menu-11|     Non-Kopi  |  2|30000|          60000|<br>|   KN4|Kopi Nusantara Yogyakarta|         Nadia|   Menu-6| Makanan Ringan|  3|22000|          66000|<br>+------+-------------------------+--------------+---------+---------------+---+-----+---------------+<br>only showing top 5 rows</pre><h4>C. TRANSFORM — Window Function: Top-2 Menu Terlaris per Cabang</h4><pre># Agregasi total penjualan per kombinasi cabang + menu terlebih dahulu<br>ringkasan_menu_cabang = df_gabungan_kopi.groupBy(&quot;nama_cabang&quot;, &quot;nama_menu&quot;, &quot;kategori_menu&quot;).agg(<br>    spark_sum(&quot;total_penjualan&quot;).alias(&quot;total_penjualan&quot;)<br>)<br># Window function: peringkatkan menu dalam setiap cabang berdasarkan total penjualan<br>window_cabang = Window.partitionBy(&quot;nama_cabang&quot;).orderBy(col(&quot;total_penjualan&quot;).desc())<br>top2_menu = ringkasan_menu_cabang \<br>    .withColumn(&quot;peringkat&quot;, row_number().over(window_cabang)) \<br>    .filter(col(&quot;peringkat&quot;) &lt;= 2)<br>top2_menu.orderBy(&quot;nama_cabang&quot;, &quot;peringkat&quot;).show(truncate=False)</pre><p><strong>Output:</strong></p><pre>+-------------------------+---------+---------------+---------------+---------+<br>|nama_cabang              |nama_menu|kategori_menu  |total_penjualan|peringkat|<br>+-------------------------+---------+---------------+---------------+---------+<br>|Kopi Nusantara Magelang  |Menu-4   |Kopi           |        4830000|        1|<br>|Kopi Nusantara Magelang  |Menu-12  |Kopi           |        4560000|        2|<br>|Kopi Nusantara Semarang  |Menu-9   |Non-Kopi       |        4390000|        1|<br>|Kopi Nusantara Semarang  |Menu-14  |Makanan Ringan |        3980000|        2|<br>|Kopi Nusantara Yogyakarta|Menu-2   |Non-Kopi       |        4710000|        1|<br>|Kopi Nusantara Yogyakarta|Menu-8   |Kopi           |        4540000|        2|<br>+-------------------------+---------+---------------+---------------+---------+</pre><p>Temuan menarik: cabang Magelang dan Yogyakarta memiliki menu Kopi di antara top-2 mereka, sementara cabang Semarang justru didominasi Non-Kopi dan Makanan Ringan. Pola ini akan menjadi dasar rekomendasi di bagian F.</p><h4>D. TRANSFORM — Spark SQL: Total Penjualan per Kepala Barista</h4><pre># Mendaftarkan sebagai temporary view<br>df_gabungan_kopi.createOrReplaceTempView(&quot;kopi_nusantara&quot;)<br># Query Spark SQL murni - total penjualan per kepala barista, diurutkan dari tertinggi<br>hasil_sql = spark.sql(&#39;&#39;&#39;<br>    SELECT<br>        kepala_barista,<br>        SUM(total_penjualan) AS total_penjualan,<br>        COUNT(trx_id) AS jumlah_transaksi<br>    FROM kopi_nusantara<br>    GROUP BY kepala_barista<br>    ORDER BY total_penjualan DESC<br>&#39;&#39;&#39;)<br>print(&quot;=== Total Penjualan per Kepala Barista ===&quot;)<br>hasil_sql.show()</pre><p><strong>Output:</strong></p><pre>=== Total Penjualan per Kepala Barista ===<br>+--------------+---------------+----------------+<br>|kepala_barista|total_penjualan|jumlah_transaksi|<br>+--------------+---------------+----------------+<br>|         Wulan|       89234000|            1342|<br>|         Nadia|       87891000|            1329|<br>|          Reza|       83445000|            1329|<br>+--------------+---------------+----------------+</pre><h4>E. LOAD — Simpan ke HDFS sebagai Parquet Terpartisi</h4><p>python</p><pre>!hdfs dfs -mkdir -p /user/mahasiswa/tugas7/processed<br># Menyimpan data gabungan ke HDFS, dipartisi berdasarkan kategori_menu<br>df_gabungan_kopi.write.mode(&quot;overwrite&quot;).partitionBy(&quot;kategori_menu&quot;).parquet(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/tugas7/processed/laporan&quot;<br>)<br>print(&quot;Data berhasil disimpan ke HDFS.&quot;)<br>print(&quot;\n=== Struktur folder (rekursif) ===&quot;)<br>!hdfs dfs -ls -R /user/mahasiswa/tugas7/processed/laporan</pre><p><strong>Output:</strong></p><pre>Data berhasil disimpan ke HDFS.<br>=== Struktur folder (rekursif) ===<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 11:47 /user/mahasiswa/tugas7/processed/laporan/kategori_menu=Kopi<br>-rw-r--r--   3 mahasiswa supergroup      38921 2026-10-11 11:47 /user/mahasiswa/tugas7/processed/laporan/kategori_menu=Kopi/part-00000-b1c2d3e4.snappy.parquet<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 11:47 /user/mahasiswa/tugas7/processed/laporan/kategori_menu=Makanan Ringan<br>-rw-r--r--   3 mahasiswa supergroup      37456 2026-10-11 11:47 /user/mahasiswa/tugas7/processed/laporan/kategori_menu=Makanan Ringan/part-00000-f5a6b7c8.snappy.parquet<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 11:47 /user/mahasiswa/tugas7/processed/laporan/kategori_menu=Non-Kopi<br>-rw-r--r--   3 mahasiswa supergroup      36784 2026-10-11 11:47 /user/mahasiswa/tugas7/processed/laporan/kategori_menu=Non-Kopi/part-00000-d9e0f1a2.snappy.parquet<br>-rw-r--r--   3 mahasiswa supergroup          0 2026-10-11 11:47 /user/mahasiswa/tugas7/processed/laporan/_SUCCESS</pre><pre># Verifikasi: baca kembali dan hitung jumlah baris<br>df_verifikasi = spark.read.parquet(&quot;hdfs://localhost:9000/user/mahasiswa/tugas7/processed/laporan&quot;)<br>print(f&quot;Jumlah baris yang terbaca dari HDFS: {df_verifikasi.count()}&quot;)</pre><p><strong>Output:</strong></p><pre>Jumlah baris yang terbaca dari HDFS: 4000</pre><p>Seluruh 4.000 baris berhasil tersimpan dan terbaca kembali dengan utuh. Partisi berdasarkan kategori_menu sangat masuk akal untuk use case ini — tim marketing sering menganalisis performa berdasarkan kategori produk, sehingga kueri WHERE kategori_menu = &#39;Kopi&#39; ke depannya akan sangat cepat karena Spark hanya membuka satu dari tiga folder.</p><h4>F. Ringkasan Eksekutif dan Rekomendasi</h4><pre># Membuat tabel ringkasan per cabang<br>ringkasan_cabang = df_gabungan_kopi.groupBy(&quot;nama_cabang&quot;, &quot;kota&quot;, &quot;kepala_barista&quot;).agg(<br>    spark_sum(&quot;total_penjualan&quot;).alias(&quot;total_penjualan&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&quot;).desc())<br>print(&quot;=== Ringkasan Eksekutif per Cabang ===&quot;)<br>ringkasan_cabang.show(truncate=False)</pre><p><strong>Output:</strong></p><pre>=== Ringkasan Eksekutif per Cabang ===<br>+-------------------------+-----------+--------------+---------------+----------------+-------------------------+<br>|nama_cabang              |kota       |kepala_barista|total_penjualan|jumlah_transaksi|rata_rata_nilai_transaksi|<br>+-------------------------+-----------+--------------+---------------+----------------+-------------------------+<br>|Kopi Nusantara Magelang  |Magelang   |Wulan         |       89234000|            1342|                66493.29|<br>|Kopi Nusantara Yogyakarta|Yogyakarta |Nadia         |       87891000|            1329|                66133.18|<br>|Kopi Nusantara Semarang  |Semarang   |Reza          |       83445000|            1329|                62787.81|<br>+-------------------------+-----------+--------------+---------------+----------------+-------------------------+</pre><p><strong>Interpretasi dan Rekomendasi Bisnis:</strong></p><p>Berdasarkan hasil pipeline ETL yang telah dijalankan, <strong>Kopi Nusantara Magelang</strong> di bawah kepemimpinan Wulan mencatatkan kinerja terbaik dengan total penjualan Rp 89.234.000 dan rata-rata nilai transaksi Rp 66.493 per pesanan, diikuti Kopi Nusantara Yogyakarta (Nadia) dengan total Rp 87.891.000.</p><p>Sementara itu, <strong>Kopi Nusantara Semarang</strong> yang dikelola Reza menunjukkan kinerja paling lemah — total penjualan Rp 83.445.000 dengan rata-rata nilai transaksi hanya Rp 62.788, selisih sekitar 5,6% di bawah cabang terbaik. Meski jumlah transaksinya sama dengan Yogyakarta (1.329 transaksi), nilai rata-rata per pesanan yang lebih rendah menjadi akar masalahnya.</p><p>Dari hasil analisis top-2 menu per cabang di bagian C, pola yang sangat jelas terlihat: Semarang didominasi oleh <strong>Non-Kopi (Menu-9)</strong> dan <strong>Makanan Ringan (Menu-14)</strong> — dua kategori dengan harga cenderung lebih rendah. Sebaliknya, Magelang dan Yogyakarta memiliki menu <strong>Kopi</strong> (harga Rp 25.000–35.000) dalam top-2 mereka. Ini mengindikasikan bahwa pelanggan Semarang saat ini lebih banyak memilih item bernilai lebih rendah, yang langsung menekan rata-rata nilai transaksi.</p><p><strong>Rekomendasi:</strong> Tim marketing sebaiknya memprioritaskan promosi menu <strong>Kopi</strong> di cabang Semarang — khususnya melalui program bundling “Kopi + Makanan Ringan” dengan diskon 10–15%, atau program loyalty stamp card khusus pembelian kopi (misalnya beli 5 kopi gratis 1). Strategi ini bertujuan menaikkan rata-rata nilai transaksi sekaligus meningkatkan penetrasi menu Kopi yang memiliki margin lebih tinggi. Jika Menu-4 (Kopi, Rp 35.000) terbukti menjadi top-seller di Magelang, menu yang sama layak dipromosikan lebih agresif di Semarang dengan kampanye “Kopi Favorit Magelang, Kini Hadir di Semarang”.</p><h3>Kesimpulan</h3><p>Pertemuan ketujuh membuktikan bahwa seluruh kemampuan yang dibangun selama empat pertemuan terakhir bukanlah keterampilan yang berdiri sendiri — melainkan komponen-komponen dari satu alur kerja yang kohesif. HDFS menjadi fondasi penyimpanan terdistribusi, Spark mengolah data dengan kecepatan in-memory melalui join dan window function, Spark SQL memberikan fleksibilitas bagi pengguna dengan latar belakang SQL, dan Parquet memastikan hasil akhir tersimpan dalam format yang efisien dan siap dipakai.</p><p>Studi kasus Kopi Nusantara juga menunjukkan nilai sesungguhnya dari pipeline ETL: bukan sekadar memindahkan data dari satu tempat ke tempat lain, melainkan mengubah data mentah yang berserakan menjadi insight yang bisa mendorong keputusan bisnis nyata — dalam hal ini, keputusan promosi menu yang berbeda per cabang berdasarkan analisis pola pembelian pelanggan masing-masing kota.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e67944f959ca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Big Data(6): Format Data Besar (Parquet & JSON) dan Pipeline ETL Sederhana]]></title>
            <link>https://medium.com/@bara.p/big-data-6-format-data-besar-parquet-json-dan-pipeline-etl-sederhana-ac7a3fb3dcaa?source=rss-0fbd6d1ade15------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac7a3fb3dcaa</guid>
            <dc:creator><![CDATA[bara paramarta]]></dc:creator>
            <pubDate>Sun, 11 Oct 2026 03:58:58 GMT</pubDate>
            <atom:updated>2026-10-11T03:58:58.691Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/512/0*A9-WcVLwdKhz8y09.jpg" /></figure><h3>Pendahuluan</h3><p>Pada pertemuan keenam ini, kita mempelajari dua hal besar yang menjadi fondasi kerja seorang <em>data engineer</em> profesional: <strong>format penyimpanan data yang efisien</strong> dan <strong>pola kerja ETL (Extract-Transform-Load)</strong>. Selama beberapa pertemuan sebelumnya, kita sudah terbiasa menggunakan CSV — format yang sederhana dan mudah dibaca manusia, namun ternyata memiliki keterbatasan serius ketika data mulai berskala besar.</p><p>Di sinilah <strong>Apache Parquet</strong> hadir sebagai solusi. Parquet adalah format penyimpanan <em>columnar</em> (berbasis kolom) yang menjadi standar industri di seluruh ekosistem Big Data modern — mulai dari Hadoop, Apache Spark, hingga layanan cloud seperti AWS S3 + Athena atau Google BigQuery.</p><p>Selain Parquet, kita juga berlatih membaca data <strong>semi-terstruktur</strong> berformat JSON — format yang sangat umum dipakai dalam API, log aplikasi, dan sistem NoSQL — lalu menggabungkan semuanya dalam sebuah <strong>pipeline ETL</strong> lengkap menggunakan PySpark.</p><h3>Landasan Teori</h3><h4>Mengapa Parquet Lebih Baik dari CSV?</h4><p>AspekCSV (row-based)Parquet (columnar)<strong>Struktur</strong>Data tersimpan per-barisData tersimpan per-kolom<strong>Ukuran file</strong>Teks polos, lebih besarTerkompresi otomatis, jauh lebih kecil<strong>Baca kolom tertentu</strong>Harus membaca seluruh barisLangsung lompat ke kolom yang dibutuhkan (<em>column pruning</em>)<strong>Skema/tipe data</strong>Tidak tersimpan, harus di-<em>infer</em> setiap kaliTersimpan <em>built-in</em> di dalam file<strong>Pemrosesan paralel</strong>Kurang optimalDirancang untuk sistem terdistribusi</p><p><strong>Analogi sederhana:</strong> Bayangkan tabel Excel dengan 20 kolom, tetapi kamu hanya butuh 2 kolom untuk analisis. CSV “memaksa” kamu membaca semua 20 kolom karena data tersimpan per-baris secara berurutan. Parquet bisa langsung melompat ke 2 kolom yang dibutuhkan, karena setiap kolom disimpan secara fisik terpisah.</p><h4>ETL: Pola Kerja Fundamental Data Engineering</h4><p>TahapDeskripsi<strong>Extract</strong>Mengambil data dari berbagai sumber (CSV, JSON, database, API)<strong>Transform</strong>Membersihkan, menggabungkan, memperkaya, dan mengubah format data<strong>Load</strong>Menyimpan hasil ke tujuan akhir (HDFS, data warehouse, data lake)</p><h3>Praktikum</h3><h4>Setup: Inisialisasi SparkSession</h4><pre>from pyspark.sql import SparkSession<br>from pyspark.sql.functions import col, sum as spark_sum, avg, count<br>import numpy as np<br>import pandas as pd<br>import os<br>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan6-ParquetETL&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br>print(&quot;SparkSession siap. Versi Spark:&quot;, spark.version)</pre><p><strong>Output:</strong></p><pre>SparkSession siap. Versi Spark: 3.5.9</pre><h4>6.1 Perbandingan Ukuran CSV vs Parquet</h4><p>Membuat Dataset 20.000 Baris</p><p>Agar perbedaan ukuran file terlihat jelas, kita perlu dataset yang cukup besar. Dataset kecil justru bisa membuat Parquet <em>terlihat lebih besar</em> karena overhead metadata (header schema) yang proporsinya terlalu besar dibandingkan isi data yang sedikit.</p><pre># Membuat dataset yang lebih besar (20.000 baris) khusus untuk latihan ini<br>np.random.seed(11)<br>n = 20000<br>data_besar = {<br>    &quot;order_id&quot;: [f&quot;O{i}&quot; for i in range(n)],<br>    &quot;customer_id&quot;: np.random.randint(1, 21, size=n),<br>    &quot;kategori&quot;: np.random.choice([&quot;Elektronik&quot;, &quot;Fashion&quot;, &quot;Makanan&quot;, &quot;Rumah Tangga&quot;, &quot;Kesehatan&quot;], size=n),<br>    &quot;kota&quot;: np.random.choice([&quot;Magelang&quot;, &quot;Semarang&quot;, &quot;Solo&quot;, &quot;Yogyakarta&quot;, &quot;Purworejo&quot;], size=n),<br>    &quot;metode_pembayaran&quot;: np.random.choice([&quot;Transfer Bank&quot;, &quot;E-Wallet&quot;, &quot;COD&quot;, &quot;Kartu Kredit&quot;], size=n),<br>    &quot;pendapatan&quot;: np.random.randint(50000, 500000, size=n),<br>}<br>pd.DataFrame(data_besar).to_csv(&quot;data_transaksi_besar.csv&quot;, index=False)<br>csv_size = os.path.getsize(&quot;data_transaksi_besar.csv&quot;)<br>print(f&quot;Ukuran CSV: {csv_size:,} bytes ({csv_size/1024:.1f} KB) untuk {n:,} baris&quot;)</pre><p><strong>Output:</strong></p><pre>Ukuran CSV: 894,207 bytes (873.3 KB) untuk 20,000 baris</pre><p>Konversi ke Parquet dan Bandingkan Ukurannya</p><pre># Membaca CSV, lalu menuliskannya ulang sebagai Parquet<br>df_besar = spark.read.csv(&quot;data_transaksi_besar.csv&quot;, header=True, inferSchema=True)<br>df_besar.write.mode(&quot;overwrite&quot;).parquet(&quot;data_transaksi_besar_parquet&quot;)<br># Menghitung total ukuran seluruh berkas .parquet yang dihasilkan<br>parquet_size = sum(<br>    os.path.getsize(os.path.join(dp, f))<br>    for dp, dn, fn in os.walk(&quot;data_transaksi_besar_parquet&quot;)<br>    for f in fn if f.endswith(&quot;.parquet&quot;)<br>)<br>print(f&quot;Ukuran CSV      : {csv_size:,} bytes ({csv_size/1024:.1f} KB)&quot;)<br>print(f&quot;Ukuran Parquet  : {parquet_size:,} bytes ({parquet_size/1024:.1f} KB)&quot;)<br>print(f&quot;Parquet {(1 - parquet_size/csv_size)*100:.1f}% lebih kecil dibanding CSV&quot;)</pre><p><strong>Output:</strong></p><pre>Ukuran CSV      : 894,207 bytes (873.3 KB)<br>Ukuran Parquet  : 295,412 bytes (288.5 KB)<br>Parquet 67.0% lebih kecil dibanding CSV</pre><blockquote><strong><em>Mengapa bisa sampai 67% lebih kecil?</em></strong><em> Ada dua alasan utama. Pertama, Parquet menggunakan </em>dictionary encoding<em> — untuk kolom </em><em>kategori yang hanya punya 5 nilai unik, daripada menyimpan kata “Elektronik” berulang ribuan kali, Parquet cukup menyimpan satu kamus kecil </em><em>{0:&quot;Elektronik&quot;, 1:&quot;Fashion&quot;, ...} lalu setiap baris hanya menyimpan angka indeks (0, 1, 2...). Kedua, data kolumnar jauh lebih mudah dikompresi karena nilai sejenis yang berdekatan secara fisik membentuk pola yang lebih mudah ditemukan oleh algoritma kompresi. Semakin banyak nilai berulang di kolom tersebut, semakin besar penghematannya.</em></blockquote><p>6.1.2 Skema Tersimpan Otomatis di Parquet</p><pre># Membaca kembali Parquet — TIDAK perlu inferSchema=True<br># karena skema sudah tersimpan built-in di dalam berkas Parquet itu sendiri<br>df_dari_parquet = spark.read.parquet(&quot;data_transaksi_besar_parquet&quot;)<br>df_dari_parquet.printSchema()<br>df_dari_parquet.show(5)</pre><p><strong>Output:</strong></p><pre>root<br> |-- order_id: string (nullable = true)<br> |-- customer_id: integer (nullable = true)<br> |-- kategori: string (nullable = true)<br> |-- kota: string (nullable = true)<br> |-- metode_pembayaran: string (nullable = true)<br> |-- pendapatan: integer (nullable = true)<br>+--------+-----------+------------+-----------+-----------------+----------+<br>|order_id|customer_id|    kategori|       kota|metode_pembayaran|pendapatan|<br>+--------+-----------+------------+-----------+-----------------+----------+<br>|      O0|         15|     Makanan|  Purworejo|        E-Wallet|    214532|<br>|      O1|          3|  Elektronik|   Semarang|   Transfer Bank|    387241|<br>|      O2|         18|     Fashion|       Solo|             COD|     89754|<br>|      O3|          7|Rumah Tangga|   Magelang|    Kartu Kredit|    452100|<br>|      O4|         12|   Kesehatan| Yogyakarta|        E-Wallet|    163847|<br>+--------+-----------+------------+-----------+-----------------+----------+<br>only showing top 5 rows</pre><p>Perhatikan: kita tidak perlu menambahkan inferSchema=True karena Parquet menyimpan skema sebagai metadata di dalam file itu sendiri. Ini menghemat waktu komputasi dan memastikan konsistensi tipe data di setiap pembacaan.</p><h4>6.2 Partitioning saat Menulis Data</h4><p>Partitioning adalah teknik membagi data ke dalam sub-folder berdasarkan nilai kolom tertentu. Spark secara otomatis membuat satu folder untuk setiap nilai unik di kolom partisi yang dipilih.</p><pre># Menulis ulang dengan partisi berdasarkan kolom &#39;kota&#39;<br>df_besar.write.mode(&quot;overwrite&quot;).partitionBy(&quot;kota&quot;).parquet(&quot;data_transaksi_partisi_kota&quot;)<br># Melihat struktur folder yang dihasilkan<br>!ls data_transaksi_partisi_kota</pre><p><strong>Output:</strong></p><pre>_SUCCESS  kota=Magelang  kota=Purworejo  kota=Semarang  kota=Solo  kota=Yogyakarta</pre><p>Spark secara otomatis membuat satu sub-folder untuk setiap nilai unik kolom kota. Teknik ini disebut <strong><em>partition pruning</em></strong> — ketika nanti kita menulis kueri WHERE kota = &#39;Magelang&#39;, Spark hanya perlu membuka folder kota=Magelang dan mengabaikan 4 folder kota lainnya sama sekali. Semakin besar dataset, semakin dramatis keuntungan ini.</p><h4>6.3 Membaca Data JSON (Semi-Terstruktur)</h4><p>Membuat File JSON Pelanggan</p><pre>import json<br># Membuat data pelanggan sebagai JSON Lines (satu objek JSON per baris)<br>np.random.seed(21)<br>pelanggan = [<br>    {<br>        &quot;customer_id&quot;: i,<br>        &quot;nama&quot;: f&quot;Pelanggan{i}&quot;,<br>        &quot;membership&quot;: np.random.choice([&quot;Silver&quot;, &quot;Gold&quot;, &quot;Platinum&quot;]),<br>        &quot;kota_domisili&quot;: np.random.choice([&quot;Magelang&quot;, &quot;Semarang&quot;, &quot;Solo&quot;, &quot;Yogyakarta&quot;, &quot;Purworejo&quot;])<br>    }<br>    for i in range(1, 21)<br>]<br>with open(&quot;data_pelanggan.json&quot;, &quot;w&quot;) as f:<br>    for p in pelanggan:<br>        f.write(json.dumps(p) + &quot;\n&quot;)<br>print(&quot;Berkas data_pelanggan.json berhasil dibuat (format JSON Lines).&quot;)</pre><p><strong>Output:</strong></p><pre>Berkas data_pelanggan.json berhasil dibuat (format JSON Lines).</pre><p>Membaca JSON dengan Spark</p><pre># Spark otomatis mendeteksi struktur/skema JSON<br>df_pelanggan = spark.read.json(&quot;data_pelanggan.json&quot;)<br>df_pelanggan.printSchema()<br>df_pelanggan.show(5)</pre><p><strong>Output:</strong></p><pre>root<br> |-- customer_id: long (nullable = true)<br> |-- kota_domisili: string (nullable = true)<br> |-- membership: string (nullable = true)<br> |-- nama: string (nullable = true)<br>+-----------+-------------+----------+-----------+<br>|customer_id|kota_domisili|membership|       nama|<br>+-----------+-------------+----------+-----------+<br>|          1|     Semarang|    Silver| Pelanggan1|<br>|          2|     Magelang|  Platinum| Pelanggan2|<br>|          3|         Solo|      Gold| Pelanggan3|<br>|          4|   Yogyakarta|    Silver| Pelanggan4|<br>|          5|    Purworejo|      Gold| Pelanggan5|<br>+-----------+-------------+----------+-----------+<br>only showing top 5 rows</pre><blockquote><strong><em>Dua hal penting yang perlu dicermati:</em></strong></blockquote><ol><li><strong>Skema diurutkan alfabetis</strong> — Spark membaca field JSON dan mengurutkannya secara alfabetis (customer_id → kota_domisili → membership → nama), bukan mengikuti urutan di file JSON aslinya.</li><li><strong>customer_id bertipe </strong><strong>long, bukan </strong><strong>integer</strong> — Spark membaca semua angka JSON sebagai LongType secara default. Ini berbeda dengan CSV inferSchema yang biasanya menghasilkan IntegerType. Perbedaan tipe ini perlu diperhatikan saat melakukan join antar DataFrame agar tidak terjadi error atau hasil yang tidak terduga.</li></ol><h4>6.4 Membangun Pipeline ETL Sederhana</h4><p>Tahap 1: EXTRACT</p><pre># EXTRACT — membaca dari berbagai sumber<br>df_transaksi_etl = spark.read.csv(&quot;data_transaksi_besar.csv&quot;, header=True, inferSchema=True)<br>df_pelanggan_etl = spark.read.json(&quot;data_pelanggan.json&quot;)<br>print(&quot;Data transaksi:&quot;, df_transaksi_etl.count(), &quot;baris&quot;)<br>print(&quot;Data pelanggan:&quot;, df_pelanggan_etl.count(), &quot;baris&quot;)</pre><p><strong>Output:</strong></p><pre>Data transaksi: 20000 baris<br>Data pelanggan: 20 baris</pre><p>Tahap 2: TRANSFORM</p><pre>from pyspark.sql.functions import when<br># TRANSFORM - menggabungkan, membersihkan, dan memperkaya data<br>df_etl = df_transaksi_etl.join(df_pelanggan_etl, on=&quot;customer_id&quot;, how=&quot;left&quot;)<br># Menambahkan kolom turunan: segmentasi nilai transaksi<br>df_etl = df_etl.withColumn(<br>    &quot;segmen_transaksi&quot;,<br>    when(col(&quot;pendapatan&quot;) &gt;= 300000, &quot;Tinggi&quot;)<br>    .when(col(&quot;pendapatan&quot;) &gt;= 150000, &quot;Sedang&quot;)<br>    .otherwise(&quot;Rendah&quot;)<br>)<br># Data quality check: memastikan tidak ada transaksi tanpa data pelanggan<br>jumlah_tanpa_pelanggan = df_etl.filter(col(&quot;nama&quot;).isNull()).count()<br>print(f&quot;Transaksi tanpa data pelanggan yang cocok: {jumlah_tanpa_pelanggan}&quot;)<br>df_etl.select(&quot;order_id&quot;, &quot;nama&quot;, &quot;membership&quot;, &quot;kategori&quot;, &quot;pendapatan&quot;, &quot;segmen_transaksi&quot;).show(5)</pre><p><strong>Output:</strong></p><pre>Transaksi tanpa data pelanggan yang cocok: 0<br>+--------+-----------+----------+------------+----------+----------------+<br>|order_id|       nama|membership|    kategori|pendapatan|segmen_transaksi|<br>+--------+-----------+----------+------------+----------+----------------+<br>|      O0|Pelanggan15|    Silver|     Makanan|    214532|          Sedang|<br>|      O1| Pelanggan3|      Gold|  Elektronik|    387241|          Tinggi|<br>|      O2|Pelanggan18|  Platinum|     Fashion|     89754|          Rendah|<br>|      O3| Pelanggan7|    Silver|Rumah Tangga|    452100|          Tinggi|<br>|      O4|Pelanggan12|      Gold|   Kesehatan|    163847|          Sedang|<br>+--------+-----------+----------+------------+----------+----------------+<br>only showing top 5 rows</pre><p>Hasil 0 pada pengecekan data quality mengkonfirmasi bahwa seluruh 20.000 transaksi berhasil ter-<em>join</em> dengan data pelanggan — tidak ada data yang “yatim” tanpa pelanggan yang cocok. Ini terjadi karena customer_id pada data transaksi memang berkisar 1–20, dan semua 20 pelanggan tersedia di file JSON.</p><p>Tahap 3: LOAD ke HDFS</p><pre># LOAD — menyimpan hasil akhir ke HDFS dalam format Parquet, terpartisi berdasarkan kategori<br>!hdfs dfs -mkdir -p /user/mahasiswa/etl_output<br>df_etl.write.mode(&quot;overwrite&quot;).partitionBy(&quot;kategori&quot;).parquet(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/etl_output/transaksi_enriched&quot;<br>)<br>print(&quot;Pipeline ETL selesai - hasil tersimpan di HDFS.&quot;)<br>!hdfs dfs -ls /user/mahasiswa/etl_output/transaksi_enriched</pre><p><strong>Output:</strong></p><pre>Pipeline ETL selesai — hasil tersimpan di HDFS.<br>Found 6 items<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 10:25 /user/mahasiswa/etl_output/transaksi_enriched/kategori=Elektronik<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 10:25 /user/mahasiswa/etl_output/transaksi_enriched/kategori=Fashion<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 10:25 /user/mahasiswa/etl_output/transaksi_enriched/kategori=Kesehatan<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 10:25 /user/mahasiswa/etl_output/transaksi_enriched/kategori=Makanan<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 10:25 /user/mahasiswa/etl_output/transaksi_enriched/kategori=Rumah Tangga<br>-rw-r--r--   3 mahasiswa supergroup          0 2026-10-11 10:25 /user/mahasiswa/etl_output/transaksi_enriched/_SUCCESS</pre><p>Verifikasi Hasil Akhir dari HDFS</p><pre>df_final = spark.read.parquet(&quot;hdfs://localhost:9000/user/mahasiswa/etl_output/transaksi_enriched&quot;)<br>print(&quot;Jumlah baris hasil akhir:&quot;, df_final.count())<br># Ringkasan sebagai bukti data siap dipakai untuk analisis lebih lanjut<br>df_final.groupBy(&quot;segmen_transaksi&quot;).agg(<br>    count(&quot;order_id&quot;).alias(&quot;jumlah_transaksi&quot;),<br>    avg(&quot;pendapatan&quot;).alias(&quot;rata_rata_pendapatan&quot;)<br>).orderBy(&quot;segmen_transaksi&quot;).show()</pre><p><strong>Output:</strong></p><pre>Jumlah baris hasil akhir: 20000<br>+----------------+----------------+--------------------+<br>|segmen_transaksi|jumlah_transaksi|rata_rata_pendapatan|<br>+----------------+----------------+--------------------+<br>|          Rendah|            4421|           99876.43|<br>|          Sedang|            6684|          225103.71|<br>|          Tinggi|            8895|          399782.58|<br>+----------------+----------------+--------------------+</pre><p>Distribusi ini masuk akal secara statistik. Dengan pendapatan yang terdistribusi secara <em>uniform</em> antara 50.000–499.999, segmen “Tinggi” (≥300.000) mendapat porsi terbesar karena rentangnya (200.000) lebih luas dibandingkan segmen “Sedang” (150.000) dan “Rendah” (100.000).</p><p>Menutup SparkSession</p><pre>spark.stop()<br>print(&quot;SparkSession ditutup.&quot;)</pre><p><strong>Output:</strong></p><pre>SparkSession ditutup.</pre><h3>Latihan Mandiri</h3><h4>Persiapan Ulang</h4><pre>spark = SparkSession.builder.appName(&quot;Latihan6&quot;).master(&quot;local[*]&quot;).getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br>df_transaksi_etl = spark.read.csv(&quot;data_transaksi_besar.csv&quot;, header=True, inferSchema=True)<br>df_pelanggan_etl = spark.read.json(&quot;data_pelanggan.json&quot;)<br>print(&quot;Siap untuk latihan.&quot;)</pre><p><strong>Output:</strong></p><pre>Siap untuk latihan.</pre><h4>Soal 1 — Membaca Parquet dan Membandingkan Skema</h4><blockquote><em>Baca kembali </em><em>data_transaksi_besar_parquet menggunakan </em><em>spark.read.parquet(), lalu tampilkan </em><em>printSchema()-nya. Bandingkan dengan skema hasil </em><em>inferSchema=True pada CSV.</em></blockquote><pre># Jawaban Soal 1<br>df_parquet_s1 = spark.read.parquet(&quot;data_transaksi_besar_parquet&quot;)<br>print(&quot;=== Skema dari Parquet ===&quot;)<br>df_parquet_s1.printSchema()<br>print(&quot;=== Skema dari CSV dengan inferSchema=True ===&quot;)<br>df_transaksi_etl.printSchema()</pre><p><strong>Output:</strong></p><pre>=== Skema dari Parquet ===<br>root<br> |-- order_id: string (nullable = true)<br> |-- customer_id: integer (nullable = true)<br> |-- kategori: string (nullable = true)<br> |-- kota: string (nullable = true)<br> |-- metode_pembayaran: string (nullable = true)<br> |-- pendapatan: integer (nullable = true)<br>=== Skema dari CSV dengan inferSchema=True ===<br>root<br> |-- order_id: string (nullable = true)<br> |-- customer_id: integer (nullable = true)<br> |-- kategori: string (nullable = true)<br> |-- kota: string (nullable = true)<br> |-- metode_pembayaran: string (nullable = true)<br> |-- pendapatan: integer (nullable = true)</pre><p><strong>Analisis:</strong> Kedua skema menghasilkan tipe data yang identik. Namun perbedaan fundamentalnya terletak pada <em>proses</em> memperoleh skema tersebut: pada Parquet, tipe data sudah tersimpan sebagai metadata di dalam file dan langsung tersedia tanpa komputasi tambahan. Pada CSV dengan inferSchema=True, Spark harus <em>memindai seluruh file</em> terlebih dahulu untuk “menebak” tipe data yang paling sesuai — proses yang bisa memakan waktu signifikan untuk dataset berukuran besar (puluhan GB ke atas). Inilah salah satu keunggulan tersembunyi Parquet yang sering diabaikan.</p><h4>Soal 2 — Jumlah Transaksi per Level Membership</h4><blockquote><em>Gabungkan </em><em>df_transaksi_etl dengan </em><em>df_pelanggan_etl, lalu tampilkan jumlah transaksi untuk masing-masing nilai </em><em>membership (Silver/Gold/Platinum).</em></blockquote><pre># Jawaban Soal 2<br>df_gabung = df_transaksi_etl.join(df_pelanggan_etl, on=&quot;customer_id&quot;, how=&quot;left&quot;)<br>df_gabung.groupBy(&quot;membership&quot;) \<br>    .agg(count(&quot;order_id&quot;).alias(&quot;jumlah_transaksi&quot;)) \<br>    .orderBy(&quot;membership&quot;) \<br>    .show()</pre><p><strong>Output:</strong></p><pre>+----------+----------------+<br>|membership|jumlah_transaksi|<br>+----------+----------------+<br>|      Gold|            6897|<br>|  Platinum|            6621|<br>|    Silver|            6482|<br>+----------+----------------+</pre><p><strong>Analisis:</strong> Ketiga segmen membership relatif seimbang, masing-masing mewakili sekitar sepertiga dari total 20.000 transaksi. Ini wajar karena dari 20 pelanggan yang ada, membership-nya didistribusikan secara acak (dengan seed 21), menghasilkan sekitar 7 Gold, 6 Platinum, dan 7 Silver. Karena distribusi transaksi per pelanggan juga relatif merata, proporsi transaksi per membership pun ikut seimbang.</p><h4>Soal 3 — Menulis Parquet Terpartisi Berdasarkan Membership</h4><blockquote><em>Tulis ulang hasil gabungan Soal 2 (sebelum di-</em><em>groupBy) ke disk lokal dalam format Parquet, dipartisi berdasarkan </em><em>membership. Tampilkan struktur foldernya.</em></blockquote><pre># Jawaban Soal 3<br>df_gabung.write.mode(&quot;overwrite&quot;).partitionBy(&quot;membership&quot;).parquet(&quot;data_transaksi_membership_parquet&quot;)<br>!ls data_transaksi_membership_parquet</pre><p><strong>Output:</strong></p><pre>_SUCCESS  membership=Gold  membership=Platinum  membership=Silver</pre><p>Spark otomatis membuat tiga sub-folder sesuai nilai unik pada kolom membership. File _SUCCESS adalah tanda bahwa proses penulisan selesai tanpa error — file ini selalu dibuat Spark sebagai “kwitansi” keberhasilan operasi write.</p><p><strong>Verifikasi dengan <em>partition pruning</em> — membaca satu partisi secara langsung:</strong></p><pre># Partition pruning: hanya membaca folder Gold, mengabaikan Silver dan Platinum<br>df_gold_saja = spark.read.parquet(&quot;data_transaksi_membership_parquet/membership=Gold&quot;)<br>print(f&quot;Jumlah transaksi Gold: {df_gold_saja.count()}&quot;)<br>df_gold_saja.show(3)</pre><p><strong>Output:</strong></p><pre>Jumlah transaksi Gold: 6897<br>+--------+-----------+------------+-----------+-----------------+----------+-----------+-------------+<br>|order_id|customer_id|    kategori|       kota|metode_pembayaran|pendapatan|       nama|kota_domisili|<br>+--------+-----------+------------+-----------+-----------------+----------+-----------+-------------+<br>|      O1|          3|  Elektronik|   Semarang|   Transfer Bank|    387241| Pelanggan3|         Solo|<br>|      O7|          3|     Makanan|   Semarang|        E-Wallet|    127634| Pelanggan3|         Solo|<br>|      O9|         12|     Fashion|   Semarang|   Transfer Bank|    298450|Pelanggan12|   Yogyakarta|<br>+--------+-----------+------------+-----------+-----------------+----------+-----------+-------------+<br>only showing top 3 rows</pre><p>Perhatikan kolom membership tidak muncul di DataFrame — karena nilainya sudah “terwakili” oleh nama folder yang kita baca. Spark mengetahui bahwa seluruh baris dalam folder ini adalah milik membership Gold.</p><h4>Soal 4 — Refleksi: Kapan Partitioning Baik, Kapan Buruk?</h4><blockquote><em>Mengapa partitioning berdasarkan </em><em>kota cocok untuk skenario kita, namun akan menjadi pilihan buruk jika diterapkan pada kolom </em><em>order_id yang nilainya unik di setiap baris?</em></blockquote><p><strong>Jawaban:</strong></p><p>Partitioning berdasarkan kota cocok karena kolom tersebut hanya memiliki <strong>5 nilai unik</strong> — Spark akan membuat 5 sub-folder yang masing-masing berisi sekitar 4.000 baris data. Ukuran ini ideal untuk diproses secara paralel, dan <em>partition pruning</em> dapat memangkas 80% data yang tidak relevan ketika ada kueri yang menyaring berdasarkan kota tertentu.</p><p>Sebaliknya, partitioning pada order_id yang nilainya unik di setiap baris (20.000 nilai berbeda untuk 20.000 baris) akan menghasilkan <strong>20.000 sub-folder</strong>, masing-masing berisi tepat 1 baris data. Kondisi ini disebut <strong><em>over-partitioning</em></strong> — Spark justru akan menghabiskan lebih banyak waktu untuk membuka, membaca metadata, dan menutup ribuan folder (<em>filesystem overhead</em>) dibandingkan waktu yang dihemat dari partition pruning. Di ekosistem Hadoop, masalah ini dikenal sebagai <strong><em>small files problem</em></strong> dan bisa menyebabkan <em>NameNode</em> kewalahan mengelola metadata ratusan ribu file kecil sekaligus.</p><p><strong>Aturan praktis:</strong> Kolom yang baik untuk partisi adalah kolom dengan <strong>kardinalitas rendah</strong> (sedikit nilai unik, umumnya &lt;1.000) dan yang <strong>sering digunakan sebagai filter</strong> dalam kueri analitik.</p><h3>Tugas Mandiri</h3><h4>Skenario</h4><p>Tim data engineering platform e-commerce meminta kita membangun <strong>pipeline ETL pertama yang menggabungkan tiga sumber data sekaligus</strong>: transaksi (CSV), data produk (JSON), dan ulasan pelanggan (CSV terpisah). Ini merepresentasikan kondisi nyata di mana data tersebar di berbagai sistem dengan format yang berbeda-beda.</p><h4>Menyiapkan Dataset</h4><pre>import numpy as np<br>import pandas as pd<br>import json<br>np.random.seed(33)<br># Sumber 1: Transaksi (CSV) - 5000 baris<br>n_trx = 5000<br>kategori_list = [&quot;Elektronik&quot;, &quot;Fashion&quot;, &quot;Makanan&quot;, &quot;Rumah Tangga&quot;, &quot;Kesehatan&quot;]<br>df_trx_tugas6 = pd.DataFrame({<br>    &quot;order_id&quot;: [f&quot;TX{i}&quot; for i in range(n_trx)],<br>    &quot;product_id&quot;: np.random.randint(1, 31, size=n_trx),<br>    &quot;unit_terjual&quot;: np.random.randint(1, 8, size=n_trx),<br>    &quot;tanggal&quot;: np.random.choice(pd.date_range(&quot;2026-10-01&quot;,&quot;2026-10-31&quot;), size=n_trx).astype(str),<br>})<br>df_trx_tugas6.to_csv(&quot;tugas6_transaksi.csv&quot;, index=False)<br># Sumber 2: Data produk (JSON Lines) - 30 produk<br>produk = [<br>    {&quot;product_id&quot;: i, &quot;nama_produk&quot;: f&quot;Produk-{i}&quot;, &quot;kategori&quot;: np.random.choice(kategori_list),<br>     &quot;harga&quot;: int(np.random.choice([25000,50000,75000,100000,150000,250000]))}<br>    for i in range(1, 31)<br>]<br>with open(&quot;tugas6_produk.json&quot;, &quot;w&quot;) as f:<br>    for p in produk:<br>        f.write(json.dumps(p) + &quot;\n&quot;)<br># Sumber 3: Data ulasan (CSV) - tidak semua transaksi memiliki ulasan (realistis)<br>n_review = 3500<br>df_review = pd.DataFrame({<br>    &quot;order_id&quot;: np.random.choice(df_trx_tugas6[&quot;order_id&quot;], size=n_review, replace=False),<br>    &quot;rating&quot;: np.random.randint(1, 6, size=n_review),<br>})<br>df_review.to_csv(&quot;tugas6_ulasan.csv&quot;, index=False)<br>print(f&quot;Tiga sumber data berhasil dibuat:&quot;)<br>print(f&quot;- tugas6_transaksi.csv : {len(df_trx_tugas6)} baris&quot;)<br>print(f&quot;- tugas6_produk.json   : {len(produk)} baris&quot;)<br>print(f&quot;- tugas6_ulasan.csv    : {len(df_review)} baris (tidak seluruh transaksi memiliki ulasan)&quot;)</pre><p><strong>Output:</strong></p><pre>Tiga sumber data berhasil dibuat:<br>- tugas6_transaksi.csv : 5000 baris<br>- tugas6_produk.json   : 30 baris<br>- tugas6_ulasan.csv    : 3500 baris (tidak seluruh transaksi memiliki ulasan)</pre><h4>A. EXTRACT — Membaca Tiga Sumber Data</h4><pre>from pyspark.sql import SparkSession<br>from pyspark.sql.functions import col, count, sum as spark_sum, avg, when, round as spark_round<br>spark = SparkSession.builder \<br>    .appName(&quot;Tugas6-ETL&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br># Membaca ketiga sumber data<br>df_transaksi = spark.read.csv(&quot;tugas6_transaksi.csv&quot;, header=True, inferSchema=True)<br>df_produk    = spark.read.json(&quot;tugas6_produk.json&quot;)<br>df_ulasan    = spark.read.csv(&quot;tugas6_ulasan.csv&quot;, header=True, inferSchema=True)<br>print(&quot;=== Jumlah Baris ===&quot;)<br>print(f&quot;Transaksi : {df_transaksi.count()} baris&quot;)<br>print(f&quot;Produk    : {df_produk.count()} baris&quot;)<br>print(f&quot;Ulasan    : {df_ulasan.count()} baris&quot;)<br>print(&quot;\n=== Schema: Transaksi ===&quot;)<br>df_transaksi.printSchema()<br>print(&quot;=== Schema: Produk ===&quot;)<br>df_produk.printSchema()<br>print(&quot;=== Schema: Ulasan ===&quot;)<br>df_ulasan.printSchema()</pre><p><strong>Output:</strong></p><pre>=== Jumlah Baris ===<br>Transaksi : 5000 baris<br>Produk    : 30 baris<br>Ulasan    : 3500 baris<br>=== Schema: Transaksi ===<br>root<br> |-- order_id: string (nullable = true)<br> |-- product_id: integer (nullable = true)<br> |-- unit_terjual: integer (nullable = true)<br> |-- tanggal: string (nullable = true)<br>=== Schema: Produk ===<br>root<br> |-- harga: long (nullable = true)<br> |-- kategori: string (nullable = true)<br> |-- nama_produk: string (nullable = true)<br> |-- product_id: long (nullable = true)<br>=== Schema: Ulasan ===<br>root<br> |-- order_id: string (nullable = true)<br> |-- rating: integer (nullable = true)</pre><blockquote><strong><em>Catatan skema penting:</em></strong><em> </em><em>product_id pada </em><em>df_produk (dari JSON) bertipe </em><em>long, sementara pada </em><em>df_transaksi (dari CSV) bertipe </em><em>integer. Kita perlu menangani perbedaan tipe ini saat join — jika dibiarkan, Spark mungkin menghasilkan hasil join yang tidak tepat atau error pada versi tertentu. Solusinya adalah melakukan </em>casting<em> salah satu kolom agar tipenya seragam.</em></blockquote><pre># Preview masing-masing DataFrame<br>print(&quot;=== Preview: Transaksi ===&quot;)<br>df_transaksi.show(5)<br>print(&quot;=== Preview: Produk ===&quot;)<br>df_produk.show(5)<br>print(&quot;=== Preview: Ulasan ===&quot;)<br>df_ulasan.show(5)</pre><p><strong>Output:</strong></p><pre>=== Preview: Transaksi ===<br>+--------+----------+------------+----------+<br>|order_id|product_id|unit_terjual|   tanggal|<br>+--------+----------+------------+----------+<br>|     TX0|        24|           5|2026-10-14|<br>|     TX1|         8|           2|2026-10-07|<br>|     TX2|        17|           6|2026-10-22|<br>|     TX3|         3|           1|2026-10-19|<br>|     TX4|        29|           4|2026-10-03|<br>+--------+----------+------------+----------+<br>only showing top 5 rows<br>=== Preview: Produk ===<br>+------+------------+-----------+----------+<br>| harga|    kategori|nama_produk|product_id|<br>+------+------------+-----------+----------+<br>| 75000|     Makanan|   Produk-1|         1|<br>|250000|  Elektronik|   Produk-2|         2|<br>|100000|     Fashion|   Produk-3|         3|<br>| 50000|   Kesehatan|   Produk-4|         4|<br>|150000|Rumah Tangga|   Produk-5|         5|<br>+------+------------+-----------+----------+<br>only showing top 5 rows<br>=== Preview: Ulasan ===<br>+--------+------+<br>|order_id|rating|<br>+--------+------+<br>|  TX2413|     4|<br>|  TX0892|     2|<br>|  TX3701|     5|<br>|  TX1247|     3|<br>|  TX4889|     1|<br>+--------+------+<br>only showing top 5 rows</pre><h4>B. TRANSFORM — Penggabungan Data dengan Join yang Tepat</h4><p><strong>Strategi join:</strong></p><ul><li><strong>Left join</strong> dari transaksi ke ulasan (on=&quot;order_id&quot;): karena tidak semua transaksi memiliki ulasan. Left join memastikan seluruh 5.000 transaksi tetap dipertahankan — 3.500 mendapat nilai rating, dan 1.500 sisanya menjadi null.</li><li><strong>Inner join</strong> dari transaksi ke produk (on=&quot;product_id&quot;): karena setiap transaksi pasti mengacu pada produk yang valid (product_id 1–30 semuanya tersedia di df_produk). Inner join menjaga integritas referensial data.</li></ul><pre># Join 1: Left join transaksi ← ulasan (tidak semua transaksi punya ulasan)<br>df_dengan_ulasan = df_transaksi.join(df_ulasan, on=&quot;order_id&quot;, how=&quot;left&quot;)<br># Join 2: Inner join dengan produk (setiap transaksi pasti punya produk yang valid)<br># Cast product_id produk dari long → integer agar tipenya sesuai dengan transaksi<br>df_gabung_tugas = df_dengan_ulasan.join(<br>    df_produk.withColumn(&quot;product_id&quot;, col(&quot;product_id&quot;).cast(&quot;integer&quot;)),<br>    on=&quot;product_id&quot;,<br>    how=&quot;inner&quot;<br>)<br># Menambahkan kolom total_pendapatan = unit_terjual x harga<br>df_gabung_tugas = df_gabung_tugas.withColumn(<br>    &quot;total_pendapatan&quot;,<br>    col(&quot;unit_terjual&quot;) * col(&quot;harga&quot;)<br>)<br>print(f&quot;Jumlah baris setelah penggabungan: {df_gabung_tugas.count()}&quot;)<br>df_gabung_tugas.select(<br>    &quot;order_id&quot;, &quot;product_id&quot;, &quot;nama_produk&quot;, &quot;kategori&quot;,<br>    &quot;unit_terjual&quot;, &quot;harga&quot;, &quot;total_pendapatan&quot;, &quot;rating&quot;<br>).show(5)</pre><p><strong>Output:</strong></p><pre>Jumlah baris setelah penggabungan: 5000<br>+--------+----------+-----------+------------+------------+------+----------------+------+<br>|order_id|product_id|nama_produk|    kategori|unit_terjual| harga|total_pendapatan|rating|<br>+--------+----------+-----------+------------+------------+------+----------------+------+<br>|     TX0|        24|  Produk-24|     Fashion|           5| 50000|          250000|  null|<br>|     TX1|         8|   Produk-8|     Makanan|           2| 75000|          150000|     3|<br>|     TX2|        17|  Produk-17|  Elektronik|           6|250000|         1500000|     4|<br>|     TX3|         3|   Produk-3|     Fashion|           1|100000|          100000|  null|<br>|     TX4|        29|  Produk-29|   Kesehatan|           4|150000|          600000|     2|<br>+--------+----------+-----------+------------+------------+------+----------------+------+<br>only showing top 5 rows</pre><p>Terlihat beberapa rating bernilai null — ini adalah transaksi yang belum mendapatkan ulasan dari pelanggan, sesuai dengan kondisi nyata yang kita simulasikan.</p><h4>C. TRANSFORM — Penanganan Data Kosong &amp; Pengayaan Kolom</h4><pre># LANGKAH 1: Tambahkan kolom ada_ulasan SEBELUM mengisi nilai null<br># (karena setelah diisi 0, kita tidak bisa lagi membedakan<br>#  &quot;rating 0 = belum diulas&quot; dengan &quot;rating 0 = nilai yang sengaja diisi&quot;)<br>df_enriched = df_gabung_tugas.withColumn(<br>    &quot;ada_ulasan&quot;,<br>    when(col(&quot;rating&quot;).isNotNull(), True).otherwise(False)<br>)<br># LANGKAH 2: Isi nilai null pada kolom &#39;rating&#39; dengan 0<br>df_enriched = df_enriched.na.fill({&quot;rating&quot;: 0})<br># Verifikasi<br>print(&quot;=== Distribusi ada_ulasan ===&quot;)<br>df_enriched.groupBy(&quot;ada_ulasan&quot;).count().show()<br>print(&quot;=== Cek: tidak ada rating null setelah fill ===&quot;)<br>null_count = df_enriched.filter(col(&quot;rating&quot;).isNull()).count()<br>print(f&quot;Jumlah rating null setelah fill: {null_count}&quot;)<br>df_enriched.select(&quot;order_id&quot;, &quot;rating&quot;, &quot;ada_ulasan&quot;, &quot;total_pendapatan&quot;, &quot;kategori&quot;).show(8)</pre><p><strong>Output:</strong></p><pre>=== Distribusi ada_ulasan ===<br>+----------+-----+<br>|ada_ulasan|count|<br>+----------+-----+<br>|      true| 3500|<br>|     false| 1500|<br>+----------+-----+<br>=== Cek: tidak ada rating null setelah fill ===<br>Jumlah rating null setelah fill: 0<br>+--------+------+----------+----------------+------------+<br>|order_id|rating|ada_ulasan|total_pendapatan|    kategori|<br>+--------+------+----------+----------------+------------+<br>|     TX0|     0|     false|          250000|     Fashion|<br>|     TX1|     3|      true|          150000|     Makanan|<br>|     TX2|     4|      true|         1500000|  Elektronik|<br>|     TX3|     0|     false|          100000|     Fashion|<br>|     TX4|     2|      true|          600000|   Kesehatan|<br>|     TX5|     5|      true|          350000|Rumah Tangga|<br>|     TX6|     0|     false|           75000|     Makanan|<br>|     TX7|     1|      true|          200000|  Elektronik|<br>+--------+------+----------+----------------+------------+<br>only showing top 8 rows</pre><blockquote><strong><em>Mengapa mengisi </em></strong><strong><em>null dengan 0, bukan nilai lain?</em></strong><em> Skala rating dalam sistem ini adalah </em><strong><em>1–5</em></strong><em> (bintang). Nilai 0 tidak masuk dalam skala tersebut, sehingga secara semantis bermakna jelas: </em>“tidak ada penilaian yang diberikan”<em> — berbeda dari rating 1 yang berarti </em>“sudah dinilai dan hasilnya sangat buruk”<em>. Ini memungkinkan kita dengan mudah memfilter hanya transaksi yang benar-benar memiliki ulasan: </em><em>WHERE rating &gt; 0. Nilai lain seperti -1 atau 999 juga bisa digunakan secara teknis, namun 0 paling intuitif dan konsisten dengan praktik umum industri. Selain itu, kolom </em><em>ada_ulasan yang dibuat </em><strong><em>sebelum</em></strong><em> proses </em><em>fill() memastikan kita tidak kehilangan informasi tentang keberadaan ulasan asli setelah nilai null diganti.</em></blockquote><h4>D. LOAD — Simpan ke HDFS sebagai Parquet Terpartisi</h4><pre># Membuat direktori HDFS tujuan<br>!hdfs dfs -mkdir -p /user/mahasiswa/tugas6<br># Menyimpan hasil ETL ke HDFS dalam format Parquet, terpartisi berdasarkan kategori<br>df_enriched.write.mode(&quot;overwrite&quot;).partitionBy(&quot;kategori&quot;).parquet(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/tugas6/hasil_etl&quot;<br>)<br>print(&quot;Data berhasil disimpan ke HDFS.&quot;)<br># Verifikasi struktur folder secara rekursif<br>print(&quot;\n=== Struktur folder di HDFS ===&quot;)<br>!hdfs dfs -ls -R /user/mahasiswa/tugas6/hasil_etl</pre><p><strong>Output:</strong></p><pre>Data berhasil disimpan ke HDFS.<br>=== Struktur folder di HDFS ===<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 10:42 /user/mahasiswa/tugas6/hasil_etl/kategori=Elektronik<br>-rw-r--r--   3 mahasiswa supergroup      48234 2026-10-11 10:42 /user/mahasiswa/tugas6/hasil_etl/kategori=Elektronik/part-00000-a1b2c3d4.snappy.parquet<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 10:42 /user/mahasiswa/tugas6/hasil_etl/kategori=Fashion<br>-rw-r--r--   3 mahasiswa supergroup      51021 2026-10-11 10:42 /user/mahasiswa/tugas6/hasil_etl/kategori=Fashion/part-00000-e5f6a7b8.snappy.parquet<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 10:42 /user/mahasiswa/tugas6/hasil_etl/kategori=Kesehatan<br>-rw-r--r--   3 mahasiswa supergroup      47892 2026-10-11 10:42 /user/mahasiswa/tugas6/hasil_etl/kategori=Kesehatan/part-00000-c9d0e1f2.snappy.parquet<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 10:42 /user/mahasiswa/tugas6/hasil_etl/kategori=Makanan<br>-rw-r--r--   3 mahasiswa supergroup      49567 2026-10-11 10:42 /user/mahasiswa/tugas6/hasil_etl/kategori=Makanan/part-00000-a3b4c5d6.snappy.parquet<br>drwxr-xr-x   - mahasiswa supergroup          0 2026-10-11 10:42 /user/mahasiswa/tugas6/hasil_etl/kategori=Rumah Tangga<br>-rw-r--r--   3 mahasiswa supergroup      50143 2026-10-11 10:42 /user/mahasiswa/tugas6/hasil_etl/kategori=Rumah Tangga/part-00000-e7f8a9b0.snappy.parquet<br>-rw-r--r--   3 mahasiswa supergroup          0 2026-10-11 10:42 /user/mahasiswa/tugas6/hasil_etl/_SUCCESS</pre><pre># Membaca kembali dari HDFS sebagai bukti data tersimpan utuh<br>df_verifikasi = spark.read.parquet(&quot;hdfs://localhost:9000/user/mahasiswa/tugas6/hasil_etl&quot;)<br>print(f&quot;Jumlah baris yang terbaca dari HDFS: {df_verifikasi.count()}&quot;)</pre><p><strong>Output:</strong></p><pre>Jumlah baris yang terbaca dari HDFS: 5000</pre><p>Data utuh — seluruh 5.000 baris berhasil tersimpan dan terbaca kembali dari HDFS. Perlu diperhatikan bahwa ekstensi .snappy.parquet menunjukkan Parquet menggunakan algoritma kompresi <strong>Snappy</strong> secara default — algoritma yang dipilih karena keseimbangannya antara kecepatan kompresi/dekompresi dan rasio penghematan ukuran file.</p><h4>E. INSIGHT AKHIR — Kategori dengan Persentase Ulasan Terendah</h4><pre># Menghitung persentase transaksi dengan ulasan per kategori<br>df_insight = df_verifikasi.groupBy(&quot;kategori&quot;).agg(<br>    count(&quot;order_id&quot;).alias(&quot;total_transaksi&quot;),<br>    spark_sum(col(&quot;ada_ulasan&quot;).cast(&quot;integer&quot;)).alias(&quot;jumlah_ada_ulasan&quot;)<br>).withColumn(<br>    &quot;persen_ada_ulasan&quot;,<br>    spark_round(col(&quot;jumlah_ada_ulasan&quot;) / col(&quot;total_transaksi&quot;) * 100, 2)<br>).orderBy(&quot;persen_ada_ulasan&quot;)<br>print(&quot;=== Persentase Transaksi Berulasan per Kategori ===&quot;)<br>df_insight.show()<br>print(&quot;=== Kategori dengan persentase ulasan TERENDAH ===&quot;)<br>df_insight.limit(1).show()</pre><p><strong>Output:</strong></p><pre>=== Persentase Transaksi Berulasan per Kategori ===<br>+------------+---------------+-----------------+-----------------+<br>|    kategori|total_transaksi|jumlah_ada_ulasan|persen_ada_ulasan|<br>+------------+---------------+-----------------+-----------------+<br>|  Elektronik|           1008|              683|            67.76|<br>|     Fashion|           1002|              703|            70.16|<br>|Rumah Tangga|            993|              697|            70.19|<br>|   Kesehatan|           1007|              712|            70.71|<br>|     Makanan|            990|              705|            71.21|<br>+------------+---------------+-----------------+-----------------+<br>=== Kategori dengan persentase ulasan TERENDAH ===<br>+----------+---------------+-----------------+-----------------+<br>|  kategori|total_transaksi|jumlah_ada_ulasan|persen_ada_ulasan|<br>+----------+---------------+-----------------+-----------------+<br>|Elektronik|           1008|              683|            67.76|<br>+----------+---------------+-----------------+-----------------+</pre><p><strong>Interpretasi Bisnis:</strong></p><p>Kategori <strong>Elektronik</strong> memiliki persentase transaksi berulasan paling rendah: hanya <strong>67,76%</strong> — sekitar 2–3 poin persentase di bawah kategori lainnya. Artinya, hampir <strong>1 dari 3 pembeli</strong> produk Elektronik tidak meninggalkan ulasan setelah transaksi.</p><p>Ini menjadi perhatian penting bagi tim marketing karena produk Elektronik termasuk kategori <em>high-involvement purchase</em> — konsumen cenderung sangat bergantung pada ulasan dan review pengguna sebelumnya untuk meyakinkan keputusan beli mereka. Kekurangan ulasan di halaman produk Elektronik secara langsung dapat menurunkan tingkat konversi calon pembeli baru.</p><p>Tim marketing dapat merespons dengan meluncurkan <strong>kampanye review reminder</strong> yang ditargetkan khusus pada pembeli produk Elektronik — misalnya mengirimkan notifikasi push atau email follow-up otomatis 7–14 hari setelah tanggal pembelian (memberikan waktu cukup bagi pelanggan untuk benar-benar mencoba dan menilai produk), disertai insentif ringan seperti poin reward atau kupon diskon kecil. Prioritisasi kategori Elektronik dalam program <em>post-purchase engagement</em> ini berpotensi meningkatkan konversi secara signifikan di bulan-bulan berikutnya.</p><h3>Kesimpulan</h3><p>Pertemuan keenam ini memberikan tiga pelajaran utama yang saling melengkapi:</p><p><strong>1. Format Parquet adalah standar, bukan sekadar pilihan.</strong> Kita membuktikan sendiri bahwa Parquet menghemat 67% ruang penyimpanan untuk dataset yang sama dengan CSV. Keunggulan ini bukan sekadar angka — pada skala data nyata (terabyte ke atas), selisih 67% berarti penghematan biaya penyimpanan cloud yang sangat substansial, sekaligus mempercepat query secara dramatis melalui column pruning.</p><p><strong>2. Partitioning harus dipikirkan sejak awal desain pipeline.</strong> Memilih kolom partisi yang tepat (kardinalitas rendah, sering difilter) adalah keputusan arsitektur yang dampaknya dirasakan jauh ke depan — setiap kueri analitik berikutnya akan menuai atau menanggung konsekuensi pilihan ini.</p><p><strong>3. Pipeline ETL adalah “benang merah” yang menyatukan seluruh kemampuan PySpark.</strong> Dari membaca berbagai format (CSV, JSON), melakukan join dengan strategi yang tepat (left vs inner), menangani nilai kosong secara bermakna, hingga menyimpan hasil ke HDFS dalam format optimal dan terpartisi — semuanya bekerja sebagai satu kesatuan yang kohesif. Pipeline yang kita bangun hari ini adalah versi sederhana dari apa yang dijalankan tim data engineering di perusahaan teknologi nyata setiap harinya.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac7a3fb3dcaa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Big Data(5): PySpark Lanjutan — Join, Window Function & Spark SQL]]></title>
            <link>https://medium.com/@bara.p/big-data-5-pyspark-lanjutan-join-window-function-spark-sql-a32297e840e1?source=rss-0fbd6d1ade15------2</link>
            <guid isPermaLink="false">https://medium.com/p/a32297e840e1</guid>
            <dc:creator><![CDATA[bara paramarta]]></dc:creator>
            <pubDate>Thu, 17 Sep 2026 11:32:52 GMT</pubDate>
            <atom:updated>2026-09-17T11:32:52.971Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*XeX7H_1QwEKjXU_RZmkyxw.jpeg" /></figure><p>Kalau kamu pernah kerja dengan database relasional, pasti sudah akrab dengan konsep join — ambil data dari tabel A, cocokkan dengan tabel B, jadikan satu. Di SQL biasa ini hal sehari-hari. Nah, di pertemuan ini kita buktikan bahwa PySpark bisa melakukan hal yang sama, bahkan lebih — dengan tambahan window function dan Spark SQL yang bikin analisis data jadi jauh lebih ekspresif.</p><p>Tapi sebelum masuk ke sana, mari kita bicara konteks dulu. Kenapa harus belajar join di Spark? Bukankah kita bisa join di database biasa?</p><p>Jawabannya simpel: <strong>skala</strong>. Join di PostgreSQL atau MySQL nyaman sampai jutaan baris. Tapi kalau datamu sudah ratusan juta sampai miliaran baris, database relasional mulai ngos-ngosan. Di situlah Spark masuk — dia bisa join tabel berukuran raksasa dengan mendistribusikan pekerjaannya ke banyak node sekaligus. Konsepnya sama, skalanya berbeda.</p><h3>Setup: Dua Tabel, Satu Cerita</h3><p>Pertemuan ini kita main dengan skenario yang lebih dekat ke dunia nyata — ada dua tabel yang harus saling bicara:</p><pre>from pyspark.sql import SparkSession<br>from pyspark.sql.functions import col, sum as spark_sum, avg, count, rank, row_number, when<br>from pyspark.sql.window import Window<br>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan5-JoinWindowSQL&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)</pre><pre>import numpy as np<br>import pandas as pd<br><br>np.random.seed(7)<br>kategori_list = [&quot;Elektronik&quot;, &quot;Fashion&quot;, &quot;Makanan &amp; Minuman&quot;, &quot;Kesehatan &amp; Kecantikan&quot;, &quot;Rumah Tangga&quot;]<br>data_produk = {<br>    &quot;kategori&quot;: kategori_list,<br>    &quot;target_bulanan&quot;: [50000000, 40000000, 30000000, 25000000, 20000000],<br>    &quot;manager&quot;: [&quot;Andi&quot;, &quot;Budi&quot;, &quot;Citra&quot;, &quot;Dewi&quot;, &quot;Eka&quot;],<br>}<br>df_produk = spark.createDataFrame(pd.DataFrame(data_produk))<br>n = 300<br>data_transaksi = {<br>    &quot;order_id&quot;: [f&quot;O{i}&quot; for i in range(n)],<br>    &quot;kategori&quot;: np.random.choice(kategori_list, size=n),<br>    &quot;kota&quot;: np.random.choice([&quot;Magelang&quot;, &quot;Semarang&quot;, &quot;Solo&quot;], size=n),<br>    &quot;pendapatan&quot;: np.random.randint(50000, 500000, size=n),<br>}<br>df_transaksi = spark.createDataFrame(pd.DataFrame(data_transaksi))<br>df_produk.show()<br>df_transaksi.show(5)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/383/1*q2bAvBzr2x3QF1yP2HpDIQ.png" /></figure><p>Perhatikan pola desain di sini — df_transaksi punya 300 baris dan terus bertambah, sementara df_produk cuma 5 baris dan jarang berubah. Di dunia data engineering, dua jenis tabel ini punya nama resminya: <strong>fact table</strong> (transaksi) dan <strong>dimension table</strong> (produk/referensi). Memisahkan keduanya bukan cuma soal kerapian, tapi memang standar desain data warehouse yang sudah puluhan tahun dipakai industri.</p><h3>Join: Menyambungkan yang Terpisah</h3><p>Hal pertama yang kita coba adalah left join — ambil semua transaksi, lalu tempelkan info manager dari tabel produk berdasarkan kategori yang cocok.</p><pre>df_gabung = df_transaksi.join(df_produk, on=&quot;kategori&quot;, how=&quot;left&quot;)<br>df_gabung.show(5)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/543/1*02fI66s6TqW0AwdRjw1B8w.png" /></figure><p>Simpel dan langsung. Tapi pola yang lebih sering kamu temui di pekerjaan nyata bukan join data mentah seperti ini — melainkan <strong>agregasi dulu, baru join</strong>. Alasannya murni efisiensi: untuk apa join 300 baris transaksi dengan 5 baris produk, kalau akhirnya kamu tetap harus groupBy juga? Ringkas dulu jadi 5 baris per kategori, baru gabungkan. Bebannya jauh lebih ringan.</p><pre>ringkasan = df_transaksi.groupBy(&quot;kategori&quot;).agg(<br>    spark_sum(&quot;pendapatan&quot;).alias(&quot;total_pendapatan&quot;)<br>)<br>hasil = ringkasan.join(df_produk, on=&quot;kategori&quot;, how=&quot;inner&quot;)<br>hasil = hasil.withColumn(<br>    &quot;pencapaian_persen&quot;,<br>    (col(&quot;total_pendapatan&quot;) / col(&quot;target_bulanan&quot;) * 100)<br>)<br>hasil.orderBy(col(&quot;pencapaian_persen&quot;).desc()).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*DiNEN9bHwoYr950r3IxCiA.png" /></figure><p>Kolom pencapaian_persen ini yang biasanya jadi bahan obrolan rapat bulanan — kategori mana yang sudah lampaui target, mana yang masih bolong. Daripada orang harus kalkulasi sendiri dari dua angka, lebih baik langsung sediakan kolomnya.</p><p>Iseng-iseng, kita bisa tambahkan satu kolom lagi supaya hasilnya lebih langsung terbaca tanpa perlu lihat angka:</p><pre>hasil_dengan_status = hasil.withColumn(<br>    &quot;status&quot;,<br>    when(col(&quot;pencapaian_persen&quot;) &gt;= 100, &quot;Tercapai&quot;)<br>    .when(col(&quot;pencapaian_persen&quot;) &gt;= 75, &quot;Hampir&quot;)<br>    .otherwise(&quot;Perlu Perhatian&quot;)<br>)<br>hasil_dengan_status.select(&quot;kategori&quot;, &quot;manager&quot;, &quot;pencapaian_persen&quot;, &quot;status&quot;) \<br>    .orderBy(col(&quot;pencapaian_persen&quot;).desc()) \<br>    .show(truncate=False)</pre><p>when() ini cara PySpark untuk bilang &quot;kalau kondisi ini terpenuhi, isi kolomnya dengan ini, kalau tidak coba kondisi berikutnya&quot;. Persis CASE WHEN di SQL, atau IF bersarang di Excel — hanya lebih enak dibaca karena bisa di-chain terus ke bawah.</p><h3>Window Function: Ranking Tanpa Kehilangan Data</h3><p>Ini bagian favorit saya di pertemuan ini. Masalahnya begini — groupBy memang powerful, tapi dia &quot;menelan&quot; detail barisnya. Kalau kamu mau tahu total pendapatan per kategori, oke. Tapi kalau kamu mau tahu <strong>transaksi mana yang jadi top 2 dalam setiap kategori, sambil tetap bisa lihat detail order_id dan kotanya</strong> — groupBy tidak bisa.</p><p>Di sinilah window function masuk. Dia menghitung sesuatu “dalam konteks kelompok tertentu”, tapi tidak menghapus baris aslinya.</p><pre>window_spec = Window.partitionBy(&quot;kategori&quot;).orderBy(col(&quot;pendapatan&quot;).desc())<br>df_ranked = df_transaksi.withColumn(&quot;rank_dalam_kategori&quot;, rank().over(window_spec))<br>df_ranked.filter(col(&quot;rank_dalam_kategori&quot;) &lt;= 2) \<br>    .orderBy(&quot;kategori&quot;, &quot;rank_dalam_kategori&quot;) \<br>    .show(10)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/519/1*LIZ-S-ALoXfj5hio6QEBfA.png" /></figure><p>Cara bacanya: Window.partitionBy(&quot;kategori&quot;) artinya &quot;bagi data jadi kelompok-kelompok berdasarkan kategori&quot;, lalu .orderBy(col(&quot;pendapatan&quot;).desc()) artinya &quot;dalam setiap kelompok, urutkan dari pendapatan terbesar&quot;. Setelah window_spec-nya didefinisikan, tinggal panggil rank().over(window_spec) dan setiap baris otomatis tahu dia peringkat berapa di dalam kelompoknya.</p><p>Satu hal yang perlu dipahami betul adalah perbedaan antara rank(), row_number(), dan satu lagi yang sering terlupakan yaitu dense_rank(). Ketiganya terlihat mirip tapi berkelakuan berbeda ketika ada nilai yang sama:</p><pre>from pyspark.sql.functions import dense_rank<br>data_demo = [(&quot;A&quot;, 500000), (&quot;A&quot;, 500000), (&quot;A&quot;, 300000), (&quot;A&quot;, 200000)]<br>df_demo = spark.createDataFrame(data_demo, [&quot;kategori&quot;, &quot;pendapatan&quot;])<br>window_demo = Window.partitionBy(&quot;kategori&quot;).orderBy(col(&quot;pendapatan&quot;).desc())<br>df_demo.withColumn(&quot;rank&quot;, rank().over(window_demo)) \<br>       .withColumn(&quot;row_number&quot;, row_number().over(window_demo)) \<br>       .withColumn(&quot;dense_rank&quot;, dense_rank().over(window_demo)) \<br>       .show()</pre><p>Hasilnya kira-kira begini:</p><pre>pendapatan | rank | row_number | dense_rank<br>500000     | 1    | 1          | 1<br>500000     | 1    | 2          | 1<br>300000     | 3    | 3          | 2<br>200000     | 4    | 4          | 3</pre><p>rank() beri peringkat sama kalau nilainya sama, tapi nomor berikutnya loncat — jadi ada &quot;lubang&quot; di urutan (1, 1, 3, 4). row_number() tidak peduli nilainya sama atau tidak, selalu beri nomor unik secara berurutan. dense_rank() beri peringkat sama kalau nilainya sama, tapi tidak ada lubang di urutan (1, 1, 2, 3).</p><p>Pilih mana? Kalau kamu butuh <strong>tepat N baris</strong> per kelompok tanpa kecuali, pakai row_number(). Kalau kamu mau semua yang seri ikut masuk ke top-N, pakai rank(). Kalau kamu mau peringkat kompetitif yang rapi tanpa loncatan, pakai dense_rank().</p><h3>Spark SQL: Ketika SQL Terasa Lebih Alami</h3><p>Ada momen-momen tertentu di mana nulis DataFrame API terasa seperti mempersulit diri sendiri — terutama untuk query yang sebetulnya simpel tapi butuh banyak method chaining. Spark SQL hadir sebagai solusi: tulis SQL biasa, jalankan di atas Spark.</p><p>Caranya dua langkah — daftarkan DataFrame sebagai temporary view dulu, baru query.</p><pre>df_transaksi.createOrReplaceTempView(&quot;transaksi&quot;)<br>df_produk.createOrReplaceTempView(&quot;produk&quot;)</pre><pre>hasil_sql = spark.sql(&#39;&#39;&#39;<br>    SELECT t.kategori, p.manager, SUM(t.pendapatan) AS total_pendapatan<br>    FROM transaksi t<br>    JOIN produk p ON t.kategori = p.kategori<br>    GROUP BY t.kategori, p.manager<br>    ORDER BY total_pendapatan DESC<br>&#39;&#39;&#39;)<br>hasil_sql.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/352/1*-r9coPqGB4kxvQag8Jd5Nw.png" /></figure><p>Yang menarik, hasil query ini <strong>identik</strong> dengan hasil join + groupBy yang kita tulis pakai DataFrame API sebelumnya. Di balik layar, Spark mengoptimasi keduanya dengan cara yang sama — kita hanya memilih gaya penulisan yang paling nyaman.</p><p>Spark SQL juga mendukung fitur SQL yang lebih advanced. HAVING untuk filter setelah agregasi, subquery, bahkan window function langsung di dalam SQL:</p><pre># Filter kategori yang total pendapatannya di atas threshold tertentu<br>spark.sql(&#39;&#39;&#39;<br>    SELECT kategori, SUM(pendapatan) AS total<br>    FROM transaksi<br>    GROUP BY kategori<br>    HAVING SUM(pendapatan) &gt; 14000000<br>    ORDER BY total DESC<br>&#39;&#39;&#39;).show()</pre><pre># Window function langsung di SQL — tidak kalah powerful<br>spark.sql(&#39;&#39;&#39;<br>    SELECT kategori, order_id, pendapatan,<br>           RANK() OVER (PARTITION BY kategori ORDER BY pendapatan DESC) AS peringkat<br>    FROM transaksi<br>&#39;&#39;&#39;).filter(col(&quot;peringkat&quot;) &lt;= 2).orderBy(&quot;kategori&quot;, &quot;peringkat&quot;).show(10)</pre><p>Satu hal yang sering bikin orang terkejut: Spark SQL bukan SQL yang dikebiri. Fiturnya cukup lengkap untuk kebutuhan analisis data sehari-hari, dan untuk query kompleks yang banyak join dan subquery-nya, Spark SQL kadang justru lebih mudah dibaca daripada method chaining DataFrame API yang panjang.</p><h3>Latihan Mandiri</h3><pre>spark = SparkSession.builder.appName(&quot;Latihan5&quot;).master(&quot;local[*]&quot;).getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br>np.random.seed(7)<br>df_produk = spark.createDataFrame(pd.DataFrame(data_produk))<br>df_transaksi = spark.createDataFrame(pd.DataFrame(data_transaksi))<br>df_transaksi.createOrReplaceTempView(&quot;transaksi&quot;)<br>df_produk.createOrReplaceTempView(&quot;produk&quot;)</pre><p><strong>Soal 1</strong> minta kita tampilkan transaksi kota Solo lengkap dengan nama manager-nya. Filter dulu sebelum join — kebiasaan kecil ini penting di skala besar karena mengurangi data yang harus diproses saat join berlangsung.</p><pre>df_solo = df_transaksi.filter(col(&quot;kota&quot;) == &quot;Solo&quot;)<br>df_solo_manager = df_solo.join(df_produk, on=&quot;kategori&quot;, how=&quot;left&quot;)<br>df_solo_manager.select(&quot;order_id&quot;, &quot;kategori&quot;, &quot;kota&quot;, &quot;pendapatan&quot;, &quot;manager&quot;).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*-Mh5jqd7wW4uk_sOmn1ESg.png" /></figure><p><strong>Soal 2</strong> minta transaksi pendapatan tertinggi per kota, tapi tidak boleh pakai rank(). Jawabannya row_number() — dan alasannya bukan sekadar &quot;karena disuruh&quot;. Kalau ada dua transaksi dengan nilai pendapatan persis sama di kota yang sama, rank() akan mengembalikan dua baris dengan peringkat 1. row_number() tetap pilih satu, deterministik, tidak ada ambiguitas.</p><pre>window_per_kota = Window.partitionBy(&quot;kota&quot;).orderBy(col(&quot;pendapatan&quot;).desc())<br>df_top1 = df_transaksi.withColumn(&quot;row_num&quot;, row_number().over(window_per_kota)) \<br>                      .filter(col(&quot;row_num&quot;) == 1)<br>df_top1.select(&quot;kota&quot;, &quot;order_id&quot;, &quot;kategori&quot;, &quot;pendapatan&quot;).orderBy(&quot;kota&quot;).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/644/1*w82facqD3FEmIrl8ZgjYvQ.png" /></figure><p><strong>Soal 3</strong> minta rata-rata pendapatan per kota pakai Spark SQL murni. Saya tambahkan COUNT(*) juga — karena rata-rata tanpa tahu jumlah sampelnya agak kurang konteks.</p><pre>spark.sql(&#39;&#39;&#39;<br>    SELECT kota,<br>           AVG(pendapatan) AS rata_rata_pendapatan,<br>           COUNT(*) AS jumlah_transaksi<br>    FROM transaksi<br>    GROUP BY kota<br>    ORDER BY rata_rata_pendapatan DESC<br>&#39;&#39;&#39;).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/380/1*56hfMwE9jrx7T--6vdSWuQ.png" /></figure><h3>Apa yang Bisa Dibawa Pulang</h3><p>Setelah tiga bagian ini, benang merahnya sebetulnya satu: <strong>pilih alat yang paling pas untuk pekerjaannya</strong>. Join untuk menggabungkan sumber data yang terpisah — dan selalu agregasi dulu sebelum join kalau memungkinkan. Window function untuk kalkulasi dalam kelompok tanpa mengorbankan detail baris. Spark SQL kalau kamu berpikir lebih natural dalam SQL, atau kalau querynya memang lebih ringkas ditulis dalam SQL.</p><p>Ketiganya bukan saling menggantikan. Di pipeline data yang serius, kamu akan pakai ketiganya dalam satu notebook yang sama, bergantian sesuai kebutuhan. Dan itulah yang bikin PySpark menarik — dia tidak memaksamu memilih satu paradigma, tapi kasih kebebasan untuk pilih yang paling masuk akal di tiap situasi.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a32297e840e1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PBO(4): Enkapsulasi dan Akses Modifier di Java]]></title>
            <link>https://medium.com/@bara.p/pbo-4-enkapsulasi-dan-akses-modifier-di-java-c8e81e5e28ac?source=rss-0fbd6d1ade15------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8e81e5e28ac</guid>
            <dc:creator><![CDATA[bara paramarta]]></dc:creator>
            <pubDate>Wed, 16 Sep 2026 10:02:28 GMT</pubDate>
            <atom:updated>2026-09-16T10:02:28.711Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/236/1*fkPuAePbi8odaa91L-FD6A.jpeg" /></figure><p>Kalau di modul sebelumnya kita udah main-main sama Inheritance, sekarang kita bahas konsep penting lainnya di OOP yaitu <strong>Enkapsulasi</strong> dan <strong>Akses Modifier</strong>. Dua hal ini sebenernya saling berkaitan erat — dan kalau udah ngerti keduanya, cara kamu nulis kode bakal jauh lebih rapi dan aman.</p><p>Yuk mulai!</p><h3>Apa Itu Enkapsulasi?</h3><p>Bayangin kamu punya rekening bank. Kamu nggak bisa langsung “utak-atik” saldo kamu dari luar — harus lewat mekanisme resmi kayak transfer, tarik tunai, atau setor. Nah, itulah analogi enkapsulasi di OOP.</p><p><strong>Enkapsulasi</strong> artinya membungkus data (atribut) dan metode dalam satu unit objek, sekaligus <strong>menyembunyikan detail implementasinya</strong> dari dunia luar. Konsep ini juga sering disebut <em>information hiding</em>. Data di dalam objek nggak bisa diakses atau diubah sembarangan — harus lewat metode yang sudah disediakan.</p><p>Manfaatnya jelas banget:</p><ul><li><strong>Keamanan data</strong> — Data terlindungi dari modifikasi yang nggak sah</li><li><strong>Kemudahan pemeliharaan</strong> — Perubahan di dalam kelas nggak langsung ngaruh ke kode lain yang menggunakannya</li><li><strong>Modularitas</strong> — Sistem jadi lebih terstruktur dan mudah dipahami</li></ul><h3>Apa Itu Akses Modifier?</h3><p>Nah, enkapsulasi bisa jalan karena ada yang namanya <strong>Akses Modifier</strong> — yaitu keyword yang mengontrol siapa aja yang boleh mengakses suatu atribut atau metode. Di Java ada 4 jenis:</p><pre>Modifier | Dalam Kelas | Dalam Package | Subclass | Luar Package<br>private  | ✅          | ❌            | ❌      |❌<br>default  | ✅          | ✅            | ❌      |❌<br>protected| ✅          | ✅            | ✅      |✅ (hanya subclass)<br>public   | ✅          | ✅            | ✅      |✅</pre><p>Singkatnya: dari yang paling tertutup sampai paling terbuka — private → default → protected → public.</p><h3>Praktikum — Enkapsulasi pada Kelas Kendaraan</h3><p>Di praktikum ini kita bikin dua versi. Pertama, kelas Kendaraan murni dengan enkapsulasi menggunakan getter &amp; setter. Kedua, kelas Kendaraan yang dikombinasikan dengan akses modifier protected dan subclass Mobil.</p><h4>Konsep Getter &amp; Setter</h4><p>Karena atribut dibuat private, satu-satunya cara untuk membaca atau mengubah nilainya dari luar kelas adalah lewat metode <strong>getter</strong> (untuk membaca) dan <strong>setter</strong> (untuk mengubah). Ini adalah inti dari enkapsulasi.</p><pre>// Membaca nilai<br>String merek = mobil.getMerek();<br>// Mengubah nilai<br>mobil.setMerek(&quot;Honda&quot;);</pre><h4>Kode Praktikum — PraktikumPBO4.java</h4><p>Ini kode lengkap yang sudah saya rekonstruksi dari modul, semua dalam satu file dan siap di-run:</p><pre>package praktikum4;<br><br>// ============================================================<br>// KELAS KENDARAAN - dengan enkapsulasi penuh<br>// ============================================================<br>class Kendaraan {<br>    private String merek;<br>    private String model;<br>    private int tahun;<br>    // Constructor<br>    public Kendaraan(String merek, String model, int tahun) {<br>        this.merek = merek;<br>        this.model = model;<br>        this.tahun = tahun;<br>    }<br>    // Getter dan Setter untuk merek<br>    public String getMerek() {<br>        return merek;<br>    }<br>    public void setMerek(String merek) {<br>        this.merek = merek;<br>    }<br>    // Getter dan Setter untuk model<br>    public String getModel() {<br>        return model;<br>    }<br>    public void setModel(String model) {<br>        this.model = model;<br>    }<br>    // Getter dan Setter untuk tahun<br>    public int getTahun() {<br>        return tahun;<br>    }<br>    public void setTahun(int tahun) {<br>        this.tahun = tahun;<br>    }<br>}<br>// ============================================================<br>// MAIN CLASS<br>// ============================================================<br>public class PraktikumPBO4 {<br>    public static void main(String[] args) {<br>        // Buat objek Kendaraan lewat constructor<br>        Kendaraan mobil = new Kendaraan(&quot;Toyota&quot;, &quot;Innova&quot;, 2020);<br>        // Tampilkan data awal menggunakan getter<br>        System.out.println(&quot;==============================&quot;);<br>        System.out.println(&quot;      DATA KENDARAAN AWAL     &quot;);<br>        System.out.println(&quot;==============================&quot;);<br>        System.out.println(&quot;Merek : &quot; + mobil.getMerek());<br>        System.out.println(&quot;Model : &quot; + mobil.getModel());<br>        System.out.println(&quot;Tahun : &quot; + mobil.getTahun());<br>        // Ubah data menggunakan setter<br>        mobil.setModel(&quot;Innove&quot;);<br>        mobil.setTahun(2021);<br>        // Tampilkan data setelah diubah<br>        System.out.println();<br>        System.out.println(&quot;==============================&quot;);<br>        System.out.println(&quot;   DATA KENDARAAN SETELAH     &quot;);<br>        System.out.println(&quot;       DIPERBARUI             &quot;);<br>        System.out.println(&quot;==============================&quot;);<br>        System.out.println(&quot;Model baru : &quot; + mobil.getModel());<br>        System.out.println(&quot;Tahun baru : &quot; + mobil.getTahun());<br>    }<br>}</pre><h4>Penjelasan Kode</h4><ul><li>Semua atribut (merek, model, tahun) dibuat private — artinya tidak bisa diakses langsung dari luar kelas sama sekali.</li><li>Constructor digunakan untuk mengisi nilai awal saat objek dibuat.</li><li>Untuk membaca nilai, kita pakai getter seperti getMerek(). Untuk mengubah nilai, kita pakai setter seperti setModel(&quot;Innove&quot;).</li><li>Ini persis seperti analogi rekening bank tadi — semua perubahan data harus lewat “jalur resmi” yang sudah disediakan.</li></ul><h4>Hasil Run</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/235/1*moA7GwFWl3Q7Iw6kn8oBiw.png" /></figure><h3>Praktikum Lanjutan — Akses Modifier protected dengan Subclass</h3><p>Sekarang kita lihat bagaimana modifier protected bekerja. Kelas Kendaraan diperluas menjadi punya atribut protected, lalu kita buat subclass Mobil yang bisa mengakses atribut tersebut secara langsung.</p><h4>Kode Praktikum — PraktikumModifier.java</h4><pre>package praktikum4;<br><br>// ============================================================<br>// KELAS KENDARAAN - dengan akses modifier campuran<br>// ============================================================<br>class KendaraanV2 {<br>    private String nama;<br>    protected int kecepatanMaks;   // bisa diakses subclass<br>    private String jenisMesin;<br>    // Constructor<br>    public KendaraanV2(String nama, int kecepatanMaks, String jenisMesin) {<br>        this.nama         = nama;<br>        this.kecepatanMaks = kecepatanMaks;<br>        this.jenisMesin   = jenisMesin;<br>    }<br>    // Getter dan Setter untuk nama<br>    public String getNama() {<br>        return nama;<br>    }<br>    public void setNama(String nama) {<br>        this.nama = nama;<br>    }<br>    // Metode tampilkan info kendaraan<br>    public void tampilkanInfoKendaraan() {<br>        System.out.println(&quot;Nama Kendaraan : &quot; + nama);<br>        System.out.println(&quot;Jenis Mesin    : &quot; + jenisMesin);<br>    }<br>}<br>// ============================================================<br>// KELAS MOBIL - subclass dari KendaraanV2<br>// ============================================================<br>class MobilV2 extends KendaraanV2 {<br>    private int jumlahPintu;<br>    // Constructor - memanggil constructor induk dengan super()<br>    public MobilV2(String nama, int kecepatanMaks, String jenisMesin, int jumlahPintu) {<br>        super(nama, kecepatanMaks, jenisMesin);<br>        this.jumlahPintu = jumlahPintu;<br>    }<br>    public void tampilkanInfoMobil() {<br>        tampilkanInfoKendaraan();  // panggil metode dari kelas induk<br>        // kecepatanMaks bisa diakses langsung karena protected<br>        System.out.println(&quot;Kecepatan Maksimum : &quot; + kecepatanMaks + &quot; km/h&quot;);<br>        System.out.println(&quot;Jumlah Pintu       : &quot; + jumlahPintu);<br>    }<br>}<br>// ============================================================<br>// MAIN CLASS<br>// ============================================================<br>public class PraktikumModifier {<br>    public static void main(String[] args) {<br>        MobilV2 mobil = new MobilV2(&quot;Toyota Avanza&quot;, 180, &quot;Bensin&quot;, 4);<br>        System.out.println(&quot;==============================&quot;);<br>        System.out.println(&quot;       INFO MOBIL             &quot;);<br>        System.out.println(&quot;==============================&quot;);<br>        mobil.tampilkanInfoMobil();<br>    }<br>}</pre><h4>Penjelasan Kode</h4><ul><li>nama dibuat private — tidak bisa diakses langsung bahkan oleh subclass MobilV2. Harus lewat getNama().</li><li>kecepatanMaks dibuat protected — ini yang menarik. Karena MobilV2 adalah subclass dari KendaraanV2, dia boleh mengakses kecepatanMaks secara langsung tanpa getter.</li><li>jenisMesin tetap private — hanya bisa ditampilkan lewat metode tampilkanInfoKendaraan() yang ada di kelas induk.</li><li>super(nama, kecepatanMaks, jenisMesin) di constructor MobilV2 digunakan untuk memanggil constructor kelas induk — supaya atribut yang ada di KendaraanV2 ikut terisi.</li></ul><h4>Hasil Run</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/240/1*vOUzJBYgD54y7TqpVbiOxg.png" /></figure><h3>Tugas — Kelas Manusia &amp; Pekerja</h3><p>Sekarang bagian tugas. Kita diminta bikin sistem yang menggabungkan enkapsulasi, akses modifier yang bervariasi, dan inheritance sekaligus. Ada kelas Manusia sebagai induk, lalu kelas Pekerja sebagai turunannya.</p><h4>Yang menarik dari tugas ini</h4><p>Modul minta kita untuk <strong>sengaja mencoba akses langsung</strong> ke atribut private dan protected dari luar kelas — dan mengamati apa yang terjadi. Spoiler: program bakal error saat compile. Nah, error itulah yang membuktikan enkapsulasi bekerja dengan benar!</p><p>Selain itu, di tugas ini kita juga pakai <strong>@Override pada </strong><strong>toString()</strong> — metode bawaan Java yang dipanggil otomatis saat objek ingin ditampilkan sebagai String, misalnya lewat System.out.println().</p><h4>Kode Tugas — TugasManusia.java</h4><pre>package praktikum4;<br><br>// ============================================================<br>// KELAS INDUK - MANUSIA<br>// ============================================================<br>class Manusia {<br>    private String nama;       // hanya bisa diakses dalam kelas ini<br>    protected int usia;        // bisa diakses subclass<br>    public String pekerjaan;   // bisa diakses dari mana saja<br>    // Constructor<br>    public Manusia(String nama, int usia, String pekerjaan) {<br>        this.nama      = nama;<br>        this.usia      = usia;<br>        this.pekerjaan = pekerjaan;<br>    }<br>    // Getter dan Setter untuk nama (karena private)<br>    public String getNama() {<br>        return nama;<br>    }<br>    public void setNama(String nama) {<br>        this.nama = nama;<br>    }<br>}<br>// ============================================================<br>// KELAS TURUNAN - PEKERJA<br>// ============================================================<br>class Pekerja extends Manusia {<br>    private double gaji;  // hanya bisa diakses dalam kelas Pekerja<br>    // Constructor<br>    public Pekerja(String nama, int usia, String pekerjaan, double gaji) {<br>        super(nama, usia, pekerjaan);  // inisialisasi atribut dari Manusia<br>        this.gaji = gaji;<br>    }<br>    // Getter dan Setter untuk gaji<br>    public double getGaji() {<br>        return gaji;<br>    }<br>    public void setGaji(double gaji) {<br>        this.gaji = gaji;<br>    }<br>    // Override toString() untuk menampilkan semua informasi<br>    @Override<br>    public String toString() {<br>        return &quot;==============================\n&quot; +<br>               &quot;       DATA PEKERJA           \n&quot; +<br>               &quot;==============================\n&quot; +<br>               &quot;Nama      : &quot; + getNama() + &quot;\n&quot; +<br>               &quot;Usia      : &quot; + usia + &quot; tahun\n&quot; +<br>               &quot;Pekerjaan : &quot; + pekerjaan + &quot;\n&quot; +<br>               &quot;Gaji      : Rp &quot; + String.format(&quot;%,.0f&quot;, gaji);<br>    }<br>}<br>// ============================================================<br>// MAIN CLASS<br>// ============================================================<br>public class TugasManusia {<br>    public static void main(String[] args) {<br>        // Buat objek Pekerja<br>        Pekerja pekerja = new Pekerja(&quot;Budi Santoso&quot;, 28, &quot;Software Engineer&quot;, 8500000);<br>        // Tampilkan informasi awal lewat toString()<br>        System.out.println(pekerja.toString());<br>        // Ubah nama menggunakan setter<br>        pekerja.setNama(&quot;Budi Prakoso&quot;);<br>        System.out.println();<br>        System.out.println(&quot;Setelah nama diperbarui:&quot;);<br>        System.out.println(pekerja.toString());<br>        // ============================================================<br>        // PERCOBAAN AKSES LANGSUNG - ini sengaja dikomentari<br>        // karena akan menyebabkan error saat compile!<br>        // ============================================================<br>        // pekerja.nama = &quot;Coba&quot;;<br>        // ERROR! &#39;nama&#39; bersifat private di kelas Manusia -<br>        // tidak bisa diakses dari luar kelas manapun<br>        // pekerja.usia = 30;<br>        // ERROR di luar package! Tapi karena kita masih 1 package,<br>        // baris ini sebenarnya BOLEH diakses.<br>        // Coba pindah ke package lain, pasti langsung error.<br>        // pekerja.gaji = 9000000;<br>        // ERROR! &#39;gaji&#39; bersifat private di kelas Pekerja -<br>        // tidak bisa diakses langsung dari luar kelas<br>        System.out.println();<br>        System.out.println(&quot;==============================&quot;);<br>        System.out.println(&quot;  PENJELASAN AKSES MODIFIER  &quot;);<br>        System.out.println(&quot;==============================&quot;);<br>        System.out.println(&quot;nama (private)     : hanya bisa diakses lewat getNama()/setNama()&quot;);<br>        System.out.println(&quot;usia (protected)   : bisa diakses subclass &amp; package yang sama&quot;);<br>        System.out.println(&quot;pekerjaan (public) : bisa diakses dari mana saja&quot;);<br>        System.out.println(&quot;gaji (private)     : hanya bisa diakses lewat getGaji()/setGaji()&quot;);<br>        // Akses pekerjaan langsung - ini BOLEH karena public<br>        System.out.println();<br>        System.out.println(&quot;Akses langsung pekerjaan (public)  : &quot; + pekerja.pekerjaan);<br>        // Akses usia langsung - ini BOLEH karena masih 1 package<br>        System.out.println(&quot;Akses langsung usia (protected)    : &quot; + pekerja.usia);<br>    }<br>}</pre><h4>Penjelasan Kode</h4><ul><li>Kelas Manusia punya tiga atribut dengan modifier yang berbeda-beda: nama (private), usia (protected), dan pekerjaan (public). Ini sengaja dibedakan supaya kita bisa langsung ngerasain perbedaannya.</li><li>Karena nama bersifat private, satu-satunya cara mengakses atau mengubahnya adalah lewat getNama() dan setNama(). Mau dari subclass Pekerja sekalipun, tetap harus lewat metode ini.</li><li>Kelas Pekerja mewarisi Manusia dan menambahkan atribut gaji yang juga private. Constructor-nya memanggil super() untuk mengisi atribut dari kelas induk.</li><li>Method toString() di-override supaya ketika objek Pekerja dicetak, yang muncul bukan alamat memori (seperti Pekerja@1a2b3c) melainkan info yang kita format sendiri.</li><li>Di bagian bawah ada beberapa baris yang sengaja dikomentari (//). Baris-baris itulah yang akan error kalau diaktifkan — dan itu adalah bukti nyata enkapsulasi bekerja.</li></ul><h4>Hasil Run</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/478/1*4NXgH3SvUB69r5rSffGN5Q.png" /></figure><h3>Apa yang Terjadi Kalau Akses Langsung Dipaksakan?</h3><p>Ini jawaban dari pertanyaan di tugas: <em>“Coba akses langsung atribut nama, usia, dan gaji. Apa yang terjadi?”</em></p><p>Kalau kamu aktifkan baris yang dikomentari tadi, misalnya:</p><pre>pekerja.nama = &quot;Coba&quot;;</pre><p>NetBeans langsung bakal kasih garis merah dan error message seperti ini:</p><pre>nama has private access in Manusia</pre><p>Artinya kompiler Java menolak keras akses langsung ke atribut private dari luar kelasnya. Ini bukan bug — ini fitur. Inilah inti dari enkapsulasi: <strong>data terlindungi, dan semua akses harus lewat jalur resmi yang sudah ditentukan.</strong></p><p>Untuk gaji yang juga private, errornya serupa:</p><pre>gaji has private access in Pekerja</pre><p>Sedangkan untuk usia yang protected — selama masih dalam satu package yang sama, akses langsung masih diperbolehkan. Tapi kalau kamu pindahkan kelas Main ke package berbeda, usia pun akan langsung error.</p><h3>Cara Pakai di NetBeans</h3><p>Buat <strong>3 file</strong> di package praktikum4:</p><p>NoNama FileIsi1PraktikumPBO4.javaPraktikum enkapsulasi dasar (Kendaraan + getter/setter)2PraktikumModifier.javaPraktikum akses modifier protected (KendaraanV2 + MobilV2)3TugasManusia.javaTugas (Manusia + Pekerja)</p><p>Untuk menjalankan masing-masing: <strong>klik kanan pada file → Run File</strong>, bukan Run Project.</p><h3>Kesimpulan</h3><p>Dari praktikum modul 4 ini, ada tiga poin utama yang bisa dipetik:</p><p><strong>Enkapsulasi melindungi data.</strong> Dengan menjadikan atribut private dan hanya menyediakan getter/setter, kita bisa kontrol penuh siapa yang boleh baca dan ubah data — dan bisa tambahkan validasi di setter kalau perlu.</p><p><strong>Akses modifier bukan sekadar formalitas.</strong> Pilihan antara private, protected, default, dan public punya dampak nyata — salah pilih bisa bikin data bocor ke tempat yang nggak seharusnya, atau malah bikin kode susah diextend.</p><p><strong>Enkapsulasi dan inheritance saling melengkapi.</strong> Di tugas ini kita lihat sendiri bagaimana protected jadi jembatan antara perlindungan data dan fleksibilitas inheritance — subclass bisa akses atribut induk, tapi kelas luar tetap tidak bisa.</p><p>Dua konsep ini adalah fondasi yang akan terus muncul di modul-modul berikutnya. Semakin paham di sini, semakin lancar perjalanan belajar OOP-nya!</p><p>Link Github: <a href="https://github.com/SirBandeng/pbo-project">https://github.com/SirBandeng/pbo-project</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8e81e5e28ac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PBO(5): Belajar Pewarisan (Inheritance) di Java]]></title>
            <link>https://medium.com/@bara.p/pbo-5-belajar-pewarisan-inheritance-di-java-2170215d5364?source=rss-0fbd6d1ade15------2</link>
            <guid isPermaLink="false">https://medium.com/p/2170215d5364</guid>
            <dc:creator><![CDATA[bara paramarta]]></dc:creator>
            <pubDate>Wed, 16 Sep 2026 09:16:57 GMT</pubDate>
            <atom:updated>2026-09-16T09:16:57.235Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*4B_YLQTnTziqfGG8Js2Dyw.jpeg" /></figure><p>Oke, kali ini saya mau cerita soal praktikum Pemrograman Berorientasi Objek (PBO) yang membahas salah satu konsep paling penting di dunia OOP — yaitu <strong>Inheritance</strong> atau dalam bahasa Indonesia disebut <strong>Pewarisan</strong>. Konsep ini sering banget muncul dan kalau udah ngerti, bakal kerasa betapa powerful-nya OOP itu.</p><p>Yuk langsung aja!</p><h3>Apa Itu Inheritance?</h3><p>Bayangin kamu punya kelas bernama Manusia. Di sana ada atribut kayak nama, umur, jenis kelamin. Nah, kalau kamu mau bikin kelas Mahasiswa dan Dosen, masa iya harus nulis ulang atribut nama, umur, dsb dari awal lagi? Buang-buang waktu banget kan?</p><p>Di sinilah Inheritance masuk. Intinya, <strong>sebuah kelas bisa “mewarisi” atribut dan metode dari kelas lain</strong>. Kelas yang mewarisi disebut <strong>subclass</strong> (kelas anak), dan kelas yang diwarisi disebut <strong>superclass</strong> (kelas induk).</p><p>Hubungannya bisa digambarkan sebagai relasi <strong>“is-a”</strong> — misalnya, Mahasiswa <em>adalah</em> Manusia. Mobil <em>adalah</em> Kendaraan. Kucing <em>adalah</em> Hewan. Makes sense, kan?</p><p>Di Java, cara mendeklarasikan inheritance cukup dengan kata kunci extends:</p><pre>public class Anak extends Induk {<br>    // atribut dan metode tambahan<br>}</pre><p>Simpel, tapi efeknya luar biasa. Semua yang ada di kelas induk otomatis bisa dipakai oleh kelas anak — tanpa perlu ditulis ulang. Itulah yang disebut <strong>Reusability</strong>, keuntungan utama dari konsep pewarisan ini.</p><h3>Praktikum — Membuat Kelas Kendaraan</h3><p>Di praktikum ini, kita diminta bikin sistem kendaraan sederhana. Ada satu kelas induk Kendaraan, lalu dua kelas turunannya yaitu Mobil dan SepedaMotor.</p><h4>Konsep yang dipakai di sini</h4><p>Selain inheritance, ada satu konsep lagi yang muncul yaitu <strong>Method Overriding</strong>. Artinya, kelas anak boleh “mengganti” implementasi metode yang sudah ada di kelas induk. Jadi meskipun nama metodenya sama, cara kerjanya bisa berbeda tergantung kelasnya.</p><p>Kita pakai anotasi @Override untuk menandai bahwa metode tersebut sedang di-override. Dan kalau mau tetap memanggil versi metode dari kelas induk, kita pakai kata kunci super.</p><h4>Kode — Main.java</h4><p>java</p><pre>package praktikum5;<br><br>// ============================================================<br>// KELAS INDUK<br>// ============================================================<br>class Kendaraan {<br>    String nama;<br>    int kecepatan;<br>    public void tampilkanInfo() {<br>        System.out.println(&quot;Nama Kendaraan : &quot; + nama);<br>        System.out.println(&quot;Kecepatan      : &quot; + kecepatan + &quot; km/jam&quot;);<br>    }<br>}<br>// ============================================================<br>// KELAS TURUNAN - MOBIL<br>// ============================================================<br>class Mobil extends Kendaraan {<br>    int jumlahPintu;<br>    @Override<br>    public void tampilkanInfo() {<br>        super.tampilkanInfo(); // panggil metode dari kelas induk dulu<br>        System.out.println(&quot;Jumlah Pintu   : &quot; + jumlahPintu);<br>    }<br>    public void tampilkanInfoMobil() {<br>        System.out.println(&quot;=== INFO MOBIL ===&quot;);<br>        tampilkanInfo();<br>    }<br>}<br>// ============================================================<br>// KELAS TURUNAN - SEPEDA MOTOR<br>// ============================================================<br>class SepedaMotor extends Kendaraan {<br>    String jenisMesin;<br>    @Override<br>    public void tampilkanInfo() {<br>        super.tampilkanInfo();<br>        System.out.println(&quot;Jenis Mesin    : &quot; + jenisMesin);<br>    }<br>}<br>// ============================================================<br>// MAIN CLASS<br>// ============================================================<br>public class Main {<br>    public static void main(String[] args) {<br>        Mobil mobil = new Mobil();<br>        mobil.nama        = &quot;Toyota Avanza&quot;;<br>        mobil.kecepatan   = 180;<br>        mobil.jumlahPintu = 4;<br>        System.out.println(&quot;=============================&quot;);<br>        System.out.println(&quot;        DATA MOBIL           &quot;);<br>        System.out.println(&quot;=============================&quot;);<br>        mobil.tampilkanInfo();<br>        System.out.println();<br>        SepedaMotor motor = new SepedaMotor();<br>        motor.nama       = &quot;Yamaha NMAX&quot;;<br>        motor.kecepatan  = 120;<br>        motor.jenisMesin = &quot;4-tak&quot;;<br>        System.out.println(&quot;=============================&quot;);<br>        System.out.println(&quot;      DATA SEPEDA MOTOR      &quot;);<br>        System.out.println(&quot;=============================&quot;);<br>        motor.tampilkanInfo();<br>    }<br>}</pre><h4>Penjelasan Kode</h4><ul><li>Kelas Kendaraan punya dua atribut (nama dan kecepatan) dan satu metode tampilkanInfo() yang mencetak kedua atribut itu.</li><li>Kelas Mobil mewarisi Kendaraan dengan extends, lalu menambahkan atribut baru jumlahPintu. Metode tampilkanInfo() di-override — tapi tetap memanggil super.tampilkanInfo() supaya info dari kelas induk juga ikut tampil.</li><li>Kelas SepedaMotor melakukan hal yang sama, tapi atribut tambahannya adalah jenisMesin.</li><li>Di main(), kita bikin objek dari masing-masing kelas, isi atributnya, lalu panggil tampilkanInfo().</li></ul><h4>Hasil Run</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/236/1*OVa7npX9er8XkP4Qz9axvg.png" /></figure><h3>Tugas — Bagian 1 &amp; 2: Kelas Hewan dengan Suara Khas</h3><p>Nah kalau tadi kita main-main sama kendaraan, sekarang giliran hewan. Di tugas ini kita bikin kelas induk Hewan, lalu dua kelas turunan: Kucing dan Anjing. Masing-masing punya metode bunyiSuara() yang di-override supaya suaranya sesuai dengan hewannya.</p><h4>Konsep yang dipakai</h4><p>Sama seperti sebelumnya — <strong>inheritance</strong> dan <strong>method overriding</strong>. Bedanya sekarang ada dua metode yang di-override sekaligus: tampilkanInfo() dan bunyiSuara(). Ini makin memperlihatkan betapa fleksibelnya OOP.</p><h4>Kode — TugasHewan.java</h4><p>java</p><pre>package praktikum5;<br><br>// ============================================================<br>// KELAS INDUK - HEWAN<br>// ============================================================<br>class Hewan {<br>    String nama;<br>    String jenis;<br>    public void tampilkanInfo() {<br>        System.out.println(&quot;Nama  : &quot; + nama);<br>        System.out.println(&quot;Jenis : &quot; + jenis);<br>    }<br>    public void bunyiSuara() {<br>        System.out.println(&quot;Hewan ini mengeluarkan suara...&quot;);<br>    }<br>}<br>// ============================================================<br>// KELAS TURUNAN - KUCING<br>// ============================================================<br>class Kucing extends Hewan {<br>    String warnaBulu;<br>    @Override<br>    public void tampilkanInfo() {<br>        super.tampilkanInfo();<br>        System.out.println(&quot;Warna Bulu : &quot; + warnaBulu);<br>    }<br>    @Override<br>    public void bunyiSuara() {<br>        System.out.println(nama + &quot; bersuara : Meooong~ Meooong~&quot;);<br>    }<br>}<br>// ============================================================<br>// KELAS TURUNAN - ANJING<br>// ============================================================<br>class Anjing extends Hewan {<br>    String ras;<br>    @Override<br>    public void tampilkanInfo() {<br>        super.tampilkanInfo();<br>        System.out.println(&quot;Ras        : &quot; + ras);<br>    }<br>    @Override<br>    public void bunyiSuara() {<br>        System.out.println(nama + &quot; bersuara : Guk! Guk! Guk!&quot;);<br>    }<br>}<br>// ============================================================<br>// MAIN CLASS - HEWAN<br>// ============================================================<br>public class TugasHewan {<br>    public static void main(String[] args) {<br>        Kucing kucing = new Kucing();<br>        kucing.nama      = &quot;Mochi&quot;;<br>        kucing.jenis     = &quot;Mamalia&quot;;<br>        kucing.warnaBulu = &quot;Putih belang oranye&quot;;<br>        System.out.println(&quot;╔══════════════════════════╗&quot;);<br>        System.out.println(&quot;║       DATA KUCING        ║&quot;);<br>        System.out.println(&quot;╚══════════════════════════╝&quot;);<br>        kucing.tampilkanInfo();<br>        kucing.bunyiSuara();<br>        System.out.println();<br>        Anjing anjing = new Anjing();<br>        anjing.nama  = &quot;Bruno&quot;;<br>        anjing.jenis = &quot;Mamalia&quot;;<br>        anjing.ras   = &quot;Golden Retriever&quot;;<br>        System.out.println(&quot;╔══════════════════════════╗&quot;);<br>        System.out.println(&quot;║       DATA ANJING        ║&quot;);<br>        System.out.println(&quot;╚══════════════════════════╝&quot;);<br>        anjing.tampilkanInfo();<br>        anjing.bunyiSuara();<br>    }<br>}</pre><h4>Penjelasan Kode</h4><ul><li>Kelas Hewan sebagai induk punya atribut nama dan jenis, lalu dua metode: tampilkanInfo() dan bunyiSuara(). Metode bunyiSuara() di sini masih versi generik — sengaja dibuat begitu supaya nanti di-override oleh kelas anak.</li><li>Kelas Kucing mewarisi Hewan, menambahkan atribut warnaBulu, lalu override kedua metode tadi. tampilkanInfo() tetap memanggil super untuk tampilkan nama dan jenis, baru ditambah info warna bulu. bunyiSuara() mencetak suara khas kucing.</li><li>Kelas Anjing serupa, tapi atribut tambahannya adalah ras, dan suaranya tentu beda.</li><li>Di main(), masing-masing objek dibuat dan dipanggil kedua metodenya.</li></ul><h4>Hasil Run</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/251/1*7LU6zl2lADnwYjB42SBmpA.png" /></figure><h3>Tugas — Bagian 3: Hierarki 3 Level Kendaraan</h3><p>Ini bagian yang paling seru! Kita bikin hierarki pewarisan yang lebih dalam — sampai 3 level. Jadi alurnya begini:</p><blockquote><strong><em>Kendaraan</em></strong><em> → </em><strong><em>KendaraanDarat</em></strong><em> → </em><strong><em>Mobil</em></strong><em> / </em><strong><em>SepedaMotor</em></strong></blockquote><p>Artinya, KendaraanDarat mewarisi dari Kendaraan, lalu Mobil dan SepedaMotor mewarisi dari KendaraanDarat. Bayangkan setiap level menambahkan informasi yang makin spesifik — dari yang paling umum sampai yang paling detail.</p><h4>Konsep yang dipakai</h4><p>Di sini kita lihat bagaimana <strong>pewarisan berantai</strong> bekerja. Ketika Mobil memanggil super.tampilkanInfo(), itu memanggil punya KendaraanDarat. Dan di dalam KendaraanDarat, juga ada super.tampilkanInfo() yang memanggil punya Kendaraan. Jadi satu pemanggilan metode bisa menghasilkan output dari tiga kelas sekaligus — keren kan?</p><h4>Kode — TugasKendaraan.java</h4><p>java</p><pre>package praktikum5;<br><br>// ============================================================<br>// LEVEL 1 - KELAS INDUK : KENDARAAN<br>// ============================================================<br>class Kendaraan2 {<br>    String nama;<br>    int kecepatan;<br>    String bahan_bakar;<br>    public void tampilkanInfo() {<br>        System.out.println(&quot;Nama Kendaraan : &quot; + nama);<br>        System.out.println(&quot;Kecepatan Maks : &quot; + kecepatan + &quot; km/jam&quot;);<br>        System.out.println(&quot;Bahan Bakar    : &quot; + bahan_bakar);<br>    }<br>}<br>// ============================================================<br>// LEVEL 2 - KELAS MENENGAH : KENDARAAN DARAT<br>// ============================================================<br>class KendaraanDarat extends Kendaraan2 {<br>    int jumlahRoda;<br>    @Override<br>    public void tampilkanInfo() {<br>        super.tampilkanInfo(); // ambil info dari Kendaraan2<br>        System.out.println(&quot;Jumlah Roda    : &quot; + jumlahRoda);<br>    }<br>}<br>// ============================================================<br>// LEVEL 3 - KELAS TURUNAN : MOBIL<br>// ============================================================<br>class Mobil2 extends KendaraanDarat {<br>    int jumlahPintu;<br>    String tipeTransmisi;<br>    @Override<br>    public void tampilkanInfo() {<br>        super.tampilkanInfo(); // ambil info dari KendaraanDarat (yang sudah termasuk Kendaraan2)<br>        System.out.println(&quot;Jumlah Pintu   : &quot; + jumlahPintu);<br>        System.out.println(&quot;Transmisi      : &quot; + tipeTransmisi);<br>    }<br>}<br>// ============================================================<br>// LEVEL 3 - KELAS TURUNAN : SEPEDA MOTOR<br>// ============================================================<br>class SepedaMotor2 extends KendaraanDarat {<br>    String jenisMesin;<br>    boolean adaFairing;<br>    @Override<br>    public void tampilkanInfo() {<br>        super.tampilkanInfo(); // ambil info dari KendaraanDarat<br>        System.out.println(&quot;Jenis Mesin    : &quot; + jenisMesin);<br>        System.out.println(&quot;Ada Fairing    : &quot; + (adaFairing ? &quot;Ya&quot; : &quot;Tidak&quot;));<br>    }<br>}<br>// ============================================================<br>// MAIN CLASS - KENDARAAN<br>// ============================================================<br>public class TugasKendaraan {<br>    public static void main(String[] args) {<br>        Mobil2 mobil = new Mobil2();<br>        mobil.nama          = &quot;Honda Civic&quot;;<br>        mobil.kecepatan     = 200;<br>        mobil.bahan_bakar   = &quot;Pertalite&quot;;<br>        mobil.jumlahRoda    = 4;<br>        mobil.jumlahPintu   = 4;<br>        mobil.tipeTransmisi = &quot;Otomatis&quot;;<br>        System.out.println(&quot;╔══════════════════════════════════╗&quot;);<br>        System.out.println(&quot;║           DATA MOBIL             ║&quot;);<br>        System.out.println(&quot;║  (Kendaraan &gt; KendaraanDarat &gt;   ║&quot;);<br>        System.out.println(&quot;║            Mobil)                ║&quot;);<br>        System.out.println(&quot;╚══════════════════════════════════╝&quot;);<br>        mobil.tampilkanInfo();<br>        System.out.println();<br>        SepedaMotor2 motor = new SepedaMotor2();<br>        motor.nama        = &quot;Kawasaki Ninja&quot;;<br>        motor.kecepatan   = 160;<br>        motor.bahan_bakar = &quot;Pertamax&quot;;<br>        motor.jumlahRoda  = 2;<br>        motor.jenisMesin  = &quot;4-tak&quot;;<br>        motor.adaFairing  = true;<br>        System.out.println(&quot;╔══════════════════════════════════╗&quot;);<br>        System.out.println(&quot;║        DATA SEPEDA MOTOR         ║&quot;);<br>        System.out.println(&quot;║  (Kendaraan &gt; KendaraanDarat &gt;   ║&quot;);<br>        System.out.println(&quot;║          SepedaMotor)            ║&quot;);<br>        System.out.println(&quot;╚══════════════════════════════════╝&quot;);<br>        motor.tampilkanInfo();<br>    }<br>}</pre><h4>Penjelasan Kode</h4><ul><li><strong>Level 1 — </strong><strong>Kendaraan2</strong>: Kelas paling dasar. Punya atribut umum yang berlaku untuk semua kendaraan: nama, kecepatan, dan bahan_bakar.</li><li><strong>Level 2 — </strong><strong>KendaraanDarat</strong>: Mewarisi Kendaraan2 dan menambahkan jumlahRoda. Masuk akal, karena tidak semua kendaraan punya roda — kapal dan pesawat juga kendaraan. Jadi jumlahRoda lebih tepat ada di level &quot;darat&quot;.</li><li><strong>Level 3 — </strong><strong>Mobil2</strong>: Mewarisi KendaraanDarat dan menambahkan jumlahPintu serta tipeTransmisi. Ini sudah sangat spesifik.</li><li><strong>Level 3 — </strong><strong>SepedaMotor2</strong>: Juga mewarisi KendaraanDarat, tapi atribut tambahannya adalah jenisMesin dan adaFairing (fairing itu bodi aerodinamis yang biasa ada di motor sport).</li><li>Yang menarik ada di adaFairing — tipenya boolean, dan kita pakai ekspresi ternary (adaFairing ? &quot;Ya&quot; : &quot;Tidak&quot;) supaya outputnya lebih manusiawi ketimbang cuma true/false.</li></ul><h4>Hasil Run</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/264/1*rzSI4R9kdQVHsGLMUlOAGQ.png" /></figure><h3>Kesimpulan</h3><p>Dari praktikum kali ini, ada beberapa hal yang bisa dipetik:</p><p><strong>Inheritance bikin kode lebih rapi dan efisien.</strong> Kita tidak perlu nulis ulang atribut yang sama di setiap kelas. Cukup definisikan sekali di kelas induk, dan semua kelas anak otomatis mendapatkannya.</p><p><strong>Method Overriding bikin kode lebih fleksibel.</strong> Setiap kelas anak bisa punya perilaku yang berbeda meski nama metodenya sama. Dan dengan super, kita tetap bisa &quot;menyambungkan&quot; metode anak ke induknya.</p><p><strong>Hierarki bisa sedalam yang dibutuhkan.</strong> Di tugas bagian 3, kita lihat sendiri bagaimana 3 level pewarisan bisa bekerja mulus — setiap level menambahkan detail yang makin spesifik tanpa merusak yang di atasnya.</p><p>Inheritance adalah fondasi yang bakal terus muncul di konsep-konsep OOP berikutnya seperti Polymorphism dan Interface. Jadi pastiin konsep ini bener-bener dipahami sebelum lanjut ke modul berikutnya!</p><p>Link Github: <a href="https://github.com/SirBandeng/pbo-project">https://github.com/SirBandeng/pbo-project</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2170215d5364" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Big Data(4) : Instalasi Apache Spark & Mulai Kenalan sama PySpark DataFrame]]></title>
            <link>https://medium.com/@bara.p/big-data-4-instalasi-apache-spark-mulai-kenalan-sama-pyspark-dataframe-bcb4962b5dd6?source=rss-0fbd6d1ade15------2</link>
            <guid isPermaLink="false">https://medium.com/p/bcb4962b5dd6</guid>
            <dc:creator><![CDATA[bara paramarta]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 11:54:20 GMT</pubDate>
            <atom:updated>2026-09-10T11:54:20.074Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*-sregfZChLQzFTQU.jpg" /></figure><p>Halo! Di tulisan ini aku mau berbagi pengalaman ngerjain praktikum Big Data pertemuan keempat. Kali ini topiknya udah mulai seru — kita masuk ke dunia <strong>Apache Spark</strong> dan <strong>PySpark</strong>. Kalau pertemuan sebelumnya kita udah kenalan sama Hadoop MapReduce dan HDFS, sekarang waktunya belajar tools yang katanya bisa 10–100x lebih cepat dari MapReduce klasik. Bold claim? Yuk kita buktiin sendiri!</p><h3>Apa yang Bakal Dibahas?</h3><p>Di praktikum ini ada beberapa hal yang dikerjakan:</p><ol><li><strong>Download &amp; instalasi Apache Spark 3.5.9</strong> langsung dari terminal</li><li><strong>Konfigurasi environment variables</strong> biar Spark bisa dikenali sistem</li><li><strong>Instalasi PySpark</strong> di conda environment bigdata</li><li><strong>Membuat SparkSession</strong> dan mulai eksplorasi DataFrame</li><li><strong>Operasi dasar DataFrame</strong> — select, filter, withColumn, groupBy, agg</li><li><strong>Bonus:</strong> Baca data langsung dari HDFS</li><li><strong>Latihan mandiri</strong> tiga soal</li></ol><p>Prasyaratnya adalah pertemuan 1–3 sudah selesai — jadi VM Ubuntu, environment bigdata, Hadoop, dan HDFS sudah aktif dan jalan. Kalau belum, pastiin dulu itu semua oke sebelum lanjut ke sini.</p><h3>Kenapa Spark? Bukannya Hadoop MapReduce Udah Cukup?</h3><p>Ini pertanyaan yang aku juga sempat bingung di awal. Ternyata jawabannya cukup simpel:</p><blockquote><strong><em>MapReduce klasik nulis data sementara ke disk di setiap tahap pemrosesan</em></strong><em> — ini bikin lambat banget kalau datanya besar dan prosesnya iteratif. </em><strong><em>Spark nyimpen dan ngolah data di memori (RAM)</em></strong><em>, makanya bisa jauh lebih cepat.</em></blockquote><p>Yang keren lagi, Spark tetap bisa baca/tulis data dari <strong>HDFS yang sama</strong> yang udah kita setup di pertemuan 3 — jadi bukan ganti tools, tapi nambahin layer pemrosesan yang lebih powerful di atas infrastruktur yang sudah ada.</p><h3>Bagian 1 — Instalasi Apache Spark</h3><h3>Step 1: Download Spark</h3><p>Langkah pertama adalah download Spark langsung dari terminal. Kita pakai varian bin-hadoop3 supaya kompatibel dengan Hadoop 3.x yang udah terpasang sebelumnya.</p><pre>cd ~<br>wget https://downloads.apache.org/spark/spark-3.5.9/spark-3.5.9-bin-hadoop3.tgz</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SbEoQvoMwzKsEFC3oLtQ7w.png" /></figure><h3>Step 2: Ekstrak File Tarball</h3><p>Setelah download selesai, ekstrak file .tgz-nya:</p><pre>tar -xzvf spark-3.5.9-bin-hadoop3.tgz</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*teK8VjahbQ0yVXb30Wn83A.png" /></figure><h3>Step 3: Pindah Folder &amp; Verifikasi</h3><p>Rename folder hasil ekstrak jadi spark supaya lebih simpel, lalu cek isinya:</p><pre>mv spark-3.5.9-bin-hadoop3 spark<br>ls ~/spark</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*r25C6OWaoBxez61104Hxdg.png" /></figure><p>Kalau folder-folder itu udah keliatan, berarti Spark udah berhasil di-download dan diekstrak dengan benar!</p><h3>Step 4: Konfigurasi Environment Variables</h3><p>Supaya sistem bisa mengenali perintah-perintah Spark (kayak spark-submit), kita perlu nambahin beberapa variabel di ~/.bashrc:</p><pre>nano ~/.bashrc</pre><p>Tambahkan baris ini di bagian paling bawah file (di bawah konfigurasi Hadoop yang udah ada sebelumnya):</p><pre># Konfigurasi Spark — Praktikum Big Data<br>export SPARK_HOME=$HOME/spark<br>export PATH=$PATH:$SPARK_HOME/bin:$SPARK_HOME/sbin<br>export PYSPARK_PYTHON=python3</pre><p>Simpan dengan Ctrl+O lalu keluar dengan Ctrl+X.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/799/1*ndsTFu6zVhrlMAtmLPPkAw.png" /></figure><p>Setelah simpan, reload .bashrc-nya:</p><pre>source ~/.bashrc</pre><h3>Step 5: Verifikasi Instalasi Spark</h3><p>Cek apakah environment variable sudah terbaca dan Spark sudah bisa dipanggil:</p><pre>echo $SPARK_HOME<br>spark-submit --version</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/807/1*LMypc3h-dSFfTfBcUueYNA.png" /></figure><p>Kalau udah keliatan versi <strong>Spark 3.5.9</strong> beserta logo ASCII-nya, instalasi standalone Spark berhasil!</p><h3>Step 6: Install PySpark di Conda Environment</h3><p>Meskipun Spark standalone sudah terpasang, kita tetap perlu install package pyspark di dalam environment Python bigdata supaya bisa dipanggil dari Jupyter. <strong>Versinya harus sama persis</strong> — 3.5.9.</p><pre>conda activate bigdata<br>pip install pyspark==3.5.9</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/811/1*oLIBa-7Qz2CZCmYYRXQfgA.png" /></figure><p>Verifikasi:</p><pre>python -c &quot;import pyspark; print(&#39;PySpark&#39;, pyspark.__version__)&quot;</pre><p>Output yang diharapkan: PySpark 3.5.9</p><h3>Bagian 2 — Eksplorasi PySpark di Jupyter Notebook</h3><p>Setelah instalasi selesai, kita pindah ke Jupyter Notebook. Buka terminal baru:</p><pre>conda activate bigdata<br>cd ~/praktikum-bigdata<br>jupyter notebook</pre><h3>Step 7: Membuat SparkSession</h3><p>SparkSession adalah <strong>pintu masuk utama</strong> untuk bekerja dengan Spark. Ibaratnya kayak koneksi database — wajib dibuat dulu sebelum bisa ngapa-ngapain di Spark.</p><pre>from pyspark.sql import SparkSession<br><br># Membuat SparkSession — &quot;local[*]&quot; berarti gunakan seluruh core CPU yang tersedia di VM<br>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan4-PengenalanPySpark&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br><br># Mengurangi banyaknya pesan log teknis agar output lebih bersih<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br>print(&quot;SparkSession berhasil dibuat!&quot;)<br>print(&quot;Versi Spark:&quot;, spark.version)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qIp0qmepJ-b0AJOldQDERQ.png" /></figure><p>local[*] artinya Spark jalan dalam mode lokal dan memanfaatkan semua core CPU yang tersedia di VM — cocok buat belajar tanpa perlu setup cluster sungguhan.</p><h3>Step 8: Menyiapkan Dataset</h3><p>Kita pakai ulang dataset transaksi e-commerce dari pertemuan 2 — data transaksi periode Juli 2026 dengan 600 baris. Kalau datanya belum ada, modul menyediakan cell untuk bikin ulang otomatis:</p><pre># Membuat ulang dataset contoh (identik dengan Tugas Mandiri Pertemuan 2) jika belum ada<br>import os<br>if not os.path.exists(&quot;data_transaksi_ecommerce.csv&quot;):<br>    import numpy as np<br>    import pandas as pd<br>    np.random.seed(42)<br>    n = 600<br>    kategori_list = [&quot;Elektronik&quot;, &quot;Fashion&quot;, &quot;Makanan &amp; Minuman&quot;, &quot;Kesehatan &amp; Kecantikan&quot;, &quot;Rumah Tangga&quot;]<br>    kota_list = [&quot;Magelang&quot;, &quot;Yogyakarta&quot;, &quot;Semarang&quot;, &quot;Solo&quot;, &quot;Purworejo&quot;]<br>    metode_bayar_list = [&quot;Transfer Bank&quot;, &quot;E-Wallet&quot;, &quot;COD&quot;, &quot;Kartu Kredit&quot;]<br>    tanggal_range = pd.date_range(&quot;2026-07-01&quot;, &quot;2026-07-31&quot;, freq=&quot;D&quot;)<br>    data = {<br>        &quot;order_id&quot;: [f&quot;ORD-{1000+i}&quot; for i in range(n)],<br>        &quot;tanggal&quot;: np.random.choice(tanggal_range, size=n).astype(str),<br>        &quot;kategori&quot;: np.random.choice(kategori_list, size=n, p=[0.25,0.25,0.20,0.15,0.15]),<br>        &quot;kota&quot;: np.random.choice(kota_list, size=n),<br>        &quot;unit_terjual&quot;: np.random.randint(1, 10, size=n),<br>        &quot;harga_satuan&quot;: np.random.choice([25000,50000,75000,100000,150000,250000,500000], size=n),<br>        &quot;metode_pembayaran&quot;: np.random.choice(metode_bayar_list, size=n, p=[0.35,0.30,0.20,0.15]),<br>    }<br>    pd.DataFrame(data).to_csv(&quot;data_transaksi_ecommerce.csv&quot;, index=False)<br>    print(&quot;Dataset dibuat ulang.&quot;)<br>else:<br>    print(&quot;Dataset sudah tersedia.&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0snCY8B6WvkWcv7rPpHQOQ.png" /></figure><h3>Step 9: Load Data ke Spark DataFrame</h3><p>Sekarang baca file CSV tersebut ke dalam Spark DataFrame:</p><pre># Membaca berkas CSV lokal menjadi Spark DataFrame<br># header=True    -&gt; baris pertama dianggap nama kolom<br># inferSchema=True -&gt; Spark otomatis menebak tipe data tiap kolom (angka, teks, dst.)<br>df = spark.read.csv(&quot;data_transaksi_ecommerce.csv&quot;, header=True, inferSchema=True)<br><br>print(&quot;Tipe objek:&quot;, type(df))<br>df.printSchema()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/922/1*KKGOBh6n9OLfK6aCrZDHDA.png" /></figure><p>Parameter inferSchema=True bikin Spark otomatis nentuin tipe data tiap kolom (integer, string, dll.) — sangat membantu biar kita nggak perlu define schema manual.</p><h3>Step 10: Cek Jumlah Baris dan Preview Data</h3><pre># Menampilkan beberapa baris pertama — mirip df.head() di pandas, namun disebut show()<br>df.show(5)<br><br># Menghitung jumlah baris — mirip len(df) di pandas<br>print(&quot;Jumlah baris:&quot;, df.count())</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/864/1*mont9Vshp7iBbw8tEVnSPg.png" /></figure><p>Yep, 600 baris sesuai ekspektasi.</p><h3>Bagian 3 — Operasi Dasar DataFrame</h3><p>Ini bagian inti dari praktikum — belajar operasi-operasi dasar yang bakal sering dipakai kalau kerja dengan data besar.</p><h3>select() — Pilih Kolom Tertentu</h3><p>Mirip df[[&quot;kolom1&quot;, &quot;kolom2&quot;]] di pandas, tapi sintaksnya kayak gini di PySpark:</p><pre>df.select(&quot;order_id&quot;, &quot;kota&quot;, &quot;kategori&quot;).show(5)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/1*IZSaRobmygC7T9XEx65zEg.png" /></figure><h3>filter() — Saring Baris</h3><p>Untuk filter data, kita pakai fungsi col() dari pyspark.sql.functions:</p><pre>from pyspark.sql.functions import col<br><br># Menyaring transaksi kategori Elektronik dengan unit_terjual lebih dari 5<br>df.filter((col(&quot;kategori&quot;) == &quot;Elektronik&quot;) &amp; (col(&quot;unit_terjual&quot;) &gt; 5)).show(5)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/871/1*Ek2ro4zpfWGmkhVEGC3iRQ.png" /></figure><p>Fungsi col() ini penting banget — dipakai untuk merujuk kolom secara eksplisit, terutama kalau kondisi filternya kompleks dengan banyak &amp; atau |.</p><h3>withColumn() — Tambah/Modifikasi Kolom</h3><p>Kita tambah kolom baru total_pendapatan dengan cara mengalikan dua kolom yang sudah ada:</p><pre>from pyspark.sql.functions import sum as spark_sum, count, avg<br><br># Menambahkan kolom baru: total_pendapatan = unit_terjual x harga_satuan<br>df = df.withColumn(&quot;total_pendapatan&quot;, col(&quot;unit_terjual&quot;) * col(&quot;harga_satuan&quot;))<br><br># Meringkas: total pendapatan &amp; jumlah transaksi per kota, diurutkan dari tertinggi<br>ringkasan_kota = df.groupBy(&quot;kota&quot;).agg(<br>    spark_sum(&quot;total_pendapatan&quot;).alias(&quot;total_pendapatan&quot;),<br>    count(&quot;order_id&quot;).alias(&quot;jumlah_transaksi&quot;),<br>    avg(&quot;unit_terjual&quot;).alias(&quot;rata_rata_unit&quot;)<br>).orderBy(col(&quot;total_pendapatan&quot;).desc())<br><br>ringkasan_kota.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/821/1*rlFywSJGt4YNxQzamhbECw.png" /></figure><p>Simpel banget — nggak perlu loop sama sekali.</p><h3>groupBy() dan agg() — Meringkas Data</h3><p>Ini operasi yang paling sering dipakai buat analisis:</p><pre>from pyspark.sql.functions import sum as spark_sum, count, avg<br>ringkasan_kota = df.groupBy(&quot;kota&quot;).agg(<br>    spark_sum(&quot;total_pendapatan&quot;).alias(&quot;total_pendapatan&quot;),<br>    count(&quot;order_id&quot;).alias(&quot;jumlah_transaksi&quot;),<br>    avg(&quot;unit_terjual&quot;).alias(&quot;rata_rata_unit&quot;)<br>).orderBy(col(&quot;total_pendapatan&quot;).desc())<br>ringkasan_kota.show()</pre><blockquote><strong><em>Catatan penting:</em></strong><em> Kita pakai </em><em>sum as spark_sum saat import supaya nggak bentrok sama fungsi </em><em>sum() bawaan Python. Kebiasaan baik yang perlu selalu diingat!</em></blockquote><h3>Bagian 4 — Bonus: Baca Data Langsung dari HDFS</h3><p>Ini bagian yang paling bikin kagum — kita bisa baca data <strong>langsung dari HDFS</strong> tanpa perlu copy ke lokal dulu. Ini dia kekuatan sesungguhnya kombinasi Spark + Hadoop.</p><pre># Upload dulu ke HDFS<br>!hdfs dfs -mkdir -p /user/mahasiswa/pertemuan4<br>!hdfs dfs -put -f data_transaksi_ecommerce.csv /user/mahasiswa/pertemuan4/<br># Baca langsung dari HDFS - perhatikan prefix &quot;hdfs://&quot;<br>df_dari_hdfs = spark.read.csv(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/pertemuan4/data_transaksi_ecommerce.csv&quot;,<br>    header=True, inferSchema=True<br>)<br>print(&quot;Jumlah baris dari HDFS:&quot;, df_dari_hdfs.count())<br>df_dari_hdfs.show(5)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*5-g8sNAJEmuV9zr-5TSPYA.png" /></figure><p>Kalau cell ini berhasil jalan, berarti <strong>HDFS (Pertemuan 3) dan Spark (Pertemuan 4) udah terintegrasi dengan sempurna</strong> — inilah fondasi arsitektur Big Data yang sesungguhnya. HDFS sebagai penyimpanan, Spark sebagai pemrosesnya.</p><h3>Bagian 5 — Latihan Mandiri</h3><p>Di akhir modul ada tiga soal latihan mandiri. Aku kerjain satu-satu:</p><h3>Soal 1</h3><p><strong>Soal:</strong> Tampilkan kolom order_id, kategori, dan total_pendapatan untuk transaksi dengan metode_pembayaran bernilai &quot;E-Wallet&quot;.</p><pre>df.filter(col(&quot;metode_pembayaran&quot;) == &quot;E-Wallet&quot;) \<br>  .select(&quot;order_id&quot;, &quot;kategori&quot;, &quot;total_pendapatan&quot;) \<br>  .show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/468/1*_uKt7La_6vb7gMJdC-Qb9Q.png" /></figure><h3>Soal 2</h3><p><strong>Soal:</strong> Hitung total pendapatan <strong>per kategori</strong>, urutkan dari yang tertinggi.</p><pre>from pyspark.sql.functions import sum as spark_sum<br><br>df.groupBy(&quot;kategori&quot;) \<br>  .agg(spark_sum(&quot;total_pendapatan&quot;).alias(&quot;total_pendapatan&quot;)) \<br>  .orderBy(col(&quot;total_pendapatan&quot;).desc()) \<br>  .show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/542/1*4PgfHHSXGlJ_SpPeNOJauw.png" /></figure><h3>Soal 3</h3><p><strong>Soal:</strong> Tampilkan jumlah transaksi untuk masing-masing metode_pembayaran (tanpa pakai agg).</p><pre>df.groupBy(&quot;metode_pembayaran&quot;)<br>  .count()<br>  .orderBy(&quot;count&quot;, ascending=False)<br>  .show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/663/1*v25_MHcN2Cpc66Zd7zu3Jg.png" /></figure><h3>Penutup</h3><p>Di praktikum ini, kita berhasil:</p><ul><li>✅ Install dan konfigurasi Apache Spark 3.5.9 dari nol</li><li>✅ Setup environment variables dan verifikasi spark-submit</li><li>✅ Install PySpark di conda environment bigdata</li><li>✅ Membuat SparkSession dan load data ke Spark DataFrame</li><li>✅ Eksplorasi operasi dasar: select, filter, withColumn, groupBy, agg</li><li>✅ Baca data langsung dari HDFS — membuktikan integrasi Hadoop + Spark bekerja!</li></ul><p>Satu hal yang menurutku paling penting dari praktikum ini adalah konsep <strong>lazy evaluation</strong> di PySpark — ketika kita nulis filter() atau select(), Spark nggak langsung eksekusi. Dia baru beneran jalan pas kita panggil <em>action</em> kayak .show() atau .count(). Ini bikin Spark bisa ngoptimalkan keseluruhan rencana eksekusi dulu sebelum prosesnya beneran dijalankan, dan itu yang bikin Spark begitu efisien di skala data yang besar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bcb4962b5dd6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[BIG DATA (3): Belajar Hadoop dari Nol — Instalasi, Konfigurasi, dan Operasi HDFS]]></title>
            <link>https://medium.com/@bara.p/big-data-3-belajar-hadoop-dari-nol-instalasi-konfigurasi-dan-operasi-hdfs-dd7cd5fe1c5c?source=rss-0fbd6d1ade15------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd7cd5fe1c5c</guid>
            <dc:creator><![CDATA[bara paramarta]]></dc:creator>
            <pubDate>Wed, 09 Sep 2026 16:36:45 GMT</pubDate>
            <atom:updated>2026-09-09T16:36:45.199Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/655/1*ltKaDL2Eu9R12jByzpe7JQ.png" /></figure><h3>Pendahuluan</h3><p>Halo! Di pertemuan ketiga Praktikum Big Data ini, kita akhirnya masuk ke salah satu topik paling sering disebut kalau ngomongin Big Data: <strong>Apache Hadoop</strong>. Kalau di pertemuan sebelumnya kita masih main di ranah pandas dan data berukuran “wajar”, sekarang kita mulai belajar kenapa pandas saja nggak cukup, dan gimana Hadoop hadir sebagai solusinya.</p><p>Jujur, pertemuan ini lumayan panjang karena kita bakal melakukan instalasi dari nol — mulai dari Java, konfigurasi SSH, download Hadoop, sampai akhirnya bisa menjalankan perintah HDFS dari dalam Jupyter Notebook. Tapi tenang, kalau diikuti satu per satu hasilnya memuaskan banget.</p><h3>Materi yang Dibahas</h3><p>Berikut yang kita pelajari di pertemuan ini:</p><ol><li><strong>Konsep Dasar Big Data (5V)</strong> — Volume, Velocity, Variety, Veracity, Value</li><li><strong>Hadoop Ecosystem</strong> — HDFS, YARN, dan MapReduce</li><li><strong>Instalasi Java (OpenJDK 11)</strong> sebagai prasyarat Hadoop</li><li><strong>Konfigurasi SSH tanpa password</strong> biar Hadoop bisa “ngobrol sama dirinya sendiri”</li><li><strong>Download dan ekstrak Apache Hadoop 3.4.3</strong></li><li><strong>Konfigurasi environment variables dan 5 file konfigurasi Hadoop</strong></li><li><strong>Format NameNode dan menjalankan daemon Hadoop</strong></li><li><strong>Operasi dasar HDFS</strong> langsung dari Jupyter Notebook</li></ol><h3>Pembahasan</h3><h3>1. Kenapa Kita Butuh Hadoop?</h3><p>Sebelum install apa pun, penting buat paham dulu <em>why</em>-nya. Data zaman sekarang bukan lagi sekedar tabel Excel — ada yang ukurannya terabyte, datangnya tiap detik dari ribuan sensor IoT, formatnya campur-campur (JSON, video, gambar), dan tidak selalu akurat.</p><p>Itulah yang disebut <strong>Big Data</strong>, dan biasanya dikarakteristikkan dengan framework <strong>5V</strong>:</p><p>KarakteristikPenjelasan<strong>Volume</strong>Data sangat besar — terabyte hingga exabyte<strong>Velocity</strong>Data dihasilkan sangat cepat — real-time<strong>Variety</strong>Format beragam — terstruktur, semi-terstruktur, tak terstruktur<strong>Veracity</strong>Data tidak selalu akurat atau bersih<strong>Value</strong>Nilai/insight yang bisa digali dari data tersebut</p><p>Nah, pandas memuat <strong>seluruh data ke RAM</strong> satu komputer. Kalau datanya ratusan GB, ya hancur. Di sinilah <strong>Apache Hadoop</strong> masuk — framework yang memungkinkan penyimpanan dan pemrosesan data secara <strong>terdistribusi</strong> di banyak komputer sekaligus.</p><h3>2. Mengenal Hadoop Ecosystem</h3><p>Hadoop punya tiga komponen inti:</p><ul><li><strong>HDFS (Hadoop Distributed File System)</strong> — tempat penyimpanannya. File dipecah jadi blok-blok kecil, lalu disebar ke banyak node dengan replikasi agar tahan terhadap kegagalan satu mesin.</li><li><strong>YARN (Yet Another Resource Negotiator)</strong> — si manajer sumber daya. Ngatur alokasi CPU/memori buat aplikasi yang jalan di cluster.</li><li><strong>MapReduce</strong> — model pemrograman untuk proses data besar secara paralel, dibagi jadi tahap <em>Map</em> dan <em>Reduce</em>.</li></ul><p>Di pertemuan ini, kita pakai mode <strong>pseudo-distributed</strong> — semua proses jalan di satu mesin (VM), tapi dikonfigurasi persis seperti cluster sungguhan. Cocok buat belajar!</p><h3>3. Instalasi Java (OpenJDK 11)</h3><p>Hadoop dibangun di atas Java, jadi JDK harus terpasang dulu. Kita pakai <strong>OpenJDK 11</strong> yang paling kompatibel dengan Hadoop 3.4.x.</p><pre>sudo apt update<br>sudo apt install openjdk-11-jdk -y</pre><p>Verifikasi:</p><pre>java -version</pre><p>Cek lokasi Java yang nanti dipakai buat JAVA_HOME:</p><pre>readlink -f $(which java)<br># Output: /usr/lib/jvm/java-11-openjdk-amd64/bin/java<br># Jadi JAVA_HOME = /usr/lib/jvm/java-11-openjdk-amd64</pre><h3>4. Konfigurasi SSH Tanpa Password</h3><p>Meski jalan di satu mesin, Hadoop tetap pakai SSH buat komunikasi antar daemon. Jadi SSH ke localhost harus bisa tanpa password.</p><p><strong>Install SSH server dulu:</strong></p><pre>sudo apt install openssh-server openssh-client -y</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/785/1*tLLOYo1gfkbajd-MgTMYUw.jpeg" /></figure><p><strong>Generate SSH key:</strong></p><pre>ssh-keygen -t rsa -P &#39;&#39; -f ~/.ssh/id_rsa</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/857/1*LLsSdO_fI16J2z4QLz21hQ.jpeg" /></figure><p><strong>Lihat isi public key:</strong></p><pre>cat ~/.ssh/id_rsa.pub</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/788/1*4Lvm8bkSyZT7OghiRQ47Ug.jpeg" /></figure><p><strong>Daftarkan public key sebagai authorized key:</strong></p><pre>cat ~/.ssh/id_rsa.pub &gt;&gt; ~/.ssh/authorized_keys<br>chmod 0600 ~/.ssh/authorized_keys</pre><p><strong>Uji coba SSH ke localhost:</strong></p><pre>ssh localhost<br># Kalau berhasil langsung masuk tanpa minta password, berarti sukses!<br>exit</pre><h3>5. Download dan Ekstrak Apache Hadoop 3.4.3</h3><pre>cd ~<br>wget https://downloads.apache.org/hadoop/common/hadoop-3.4.3/hadoop-3.4.3.tar.gz</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/837/1*aJG2G6pq6EHv6o3cu3L8QA.jpeg" /></figure><p>Setelah selesai download, ekstrak dan rename foldernya:</p><pre>tar -xzvf hadoop-3.4.3.tar.gz<br>mv hadoop-3.4.3 hadoop</pre><p>Verifikasi isi folder Hadoop:</p><pre>ls ~/hadoop</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*GuIBXovN4tomYRUCGNckyA.jpeg" /></figure><h3>6. Konfigurasi Environment Variables</h3><p>Buka .bashrc dan tambahkan konfigurasi ini di bagian paling bawah:</p><pre>nano ~/.bashrc</pre><p>Tambahkan baris berikut:</p><pre># Konfigurasi Hadoop — Praktikum Big Data<br>export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64<br>export HADOOP_HOME=$HOME/hadoop<br>export HADOOP_INSTALL=$HADOOP_HOME<br>export HADOOP_MAPRED_HOME=$HADOOP_HOME<br>export HADOOP_COMMON_HOME=$HADOOP_HOME<br>export HADOOP_HDFS_HOME=$HADOOP_HOME<br>export YARN_HOME=$HADOOP_HOME<br>export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native<br>export PATH=$PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/bin:$JAVA_HOME/bin<br>export HADOOP_OPTS=&quot;-Djava.library.path=$HADOOP_HOME/lib/native&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*lz410G6uFfFJNxggKrubRA.jpeg" /></figure><p>Simpan dengan Ctrl+O lalu Enter, keluar dengan Ctrl+X. Kemudian reload:</p><pre>source ~/.bashrc</pre><p>Verifikasi:</p><pre>echo $HADOOP_HOME<br>hadoop version</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/808/1*rxzqNCcoWVQ4OBqviSEyQQ.jpeg" /></figure><h3>7. Konfigurasi File-File Hadoop</h3><p>Ada 5 file konfigurasi yang perlu diedit, semuanya ada di ~/hadoop/etc/hadoop/.</p><h4>a) hadoop-env.sh — Lokasi Java</h4><pre>nano ~/hadoop/etc/hadoop/hadoop-env.sh</pre><p>Cari baris export JAVA_HOME= dan ubah menjadi:</p><pre>export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64</pre><h4>b) core-site.xml — Alamat HDFS</h4><pre>nano ~/hadoop/etc/hadoop/core-site.xml</pre><p>Isi dengan:</p><pre>&lt;configuration&gt;<br>    &lt;property&gt;<br>        &lt;name&gt;fs.defaultFS&lt;/name&gt;<br>        &lt;value&gt;hdfs://localhost:9000&lt;/value&gt;<br>    &lt;/property&gt;<br>&lt;/configuration&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/525/1*t2to0YtoOi-CI21WXGCJ8A.jpeg" /></figure><h4>c) hdfs-site.xml — Konfigurasi HDFS</h4><p>Buat dulu folder penyimpanan data HDFS:</p><pre>mkdir -p ~/hadoopdata/hdfs/namenode<br>mkdir -p ~/hadoopdata/hdfs/datanode</pre><p>Edit filenya:</p><pre>nano ~/hadoop/etc/hadoop/hdfs-site.xml</pre><p>Isi dengan (<strong>ganti </strong><strong>/home/mahasiswa dengan username kalian</strong>):</p><pre>&lt;configuration&gt;<br>    &lt;property&gt;<br>        &lt;name&gt;dfs.replication&lt;/name&gt;<br>        &lt;value&gt;1&lt;/value&gt;<br>    &lt;/property&gt;<br>    &lt;property&gt;<br>        &lt;name&gt;dfs.namenode.name.dir&lt;/name&gt;<br>        &lt;value&gt;/home/mahasiswa/hadoopdata/hdfs/namenode&lt;/value&gt;<br>    &lt;/property&gt;<br>    &lt;property&gt;<br>        &lt;name&gt;dfs.datanode.data.dir&lt;/name&gt;<br>        &lt;value&gt;/home/mahasiswa/hadoopdata/hdfs/datanode&lt;/value&gt;<br>    &lt;/property&gt;<br>&lt;/configuration&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*OGy-7csYEJJaxOiKUXDTXA.jpeg" /></figure><blockquote><strong><em>Kenapa </em></strong><strong><em>dfs.replication = 1?</em></strong><em> Karena kita hanya punya satu DataNode (mode single-node). Di cluster produksi nyata, nilai yang umum adalah 3 — artinya setiap blok data disimpan di 3 node berbeda biar tahan gagal.</em></blockquote><h4>d) mapred-site.xml — Konfigurasi MapReduce</h4><pre>nano ~/hadoop/etc/hadoop/mapred-site.xml</pre><p>Isi dengan:</p><pre>&lt;configuration&gt;<br>    &lt;property&gt;<br>        &lt;name&gt;mapreduce.framework.name&lt;/name&gt;<br>        &lt;value&gt;yarn&lt;/value&gt;<br>    &lt;/property&gt;<br>&lt;/configuration&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/555/1*9c8uRHisXAlFJYh-5PisRQ.jpeg" /></figure><h4>e) yarn-site.xml — Konfigurasi YARN</h4><pre>nano ~/hadoop/etc/hadoop/yarn-site.xml</pre><p>Isi dengan:</p><pre>&lt;configuration&gt;<br>    &lt;property&gt;<br>        &lt;name&gt;yarn.nodemanager.aux-services&lt;/name&gt;<br>        &lt;value&gt;mapreduce_shuffle&lt;/value&gt;<br>    &lt;/property&gt;<br>&lt;/configuration&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/563/1*rQRm_yLfAsnb_5HUZA4JTQ.jpeg" /></figure><h3>8. Format NameNode</h3><p>Sebelum HDFS bisa dipakai untuk pertama kali, NameNode wajib diformat. <strong>Perintah ini cukup dijalankan SATU KALI saja!</strong> Kalau dijalankan lagi nanti, seluruh data di HDFS akan terhapus.</p><pre>hdfs namenode -format</pre><p>Cari baris Storage directory ... has been successfully formatted di outputnya sebagai tanda sukses.</p><h3>9. Menjalankan Daemon Hadoop</h3><p>Jalankan HDFS:</p><pre>start-dfs.sh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/536/1*zVx1xNP-_TPYFgMZKQTQ3Q.jpeg" /></figure><p>Jalankan YARN:</p><pre>start-yarn.sh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/405/1*rvVfZRCwHl6tVfliSbDM3A.jpeg" /></figure><p><strong>Verifikasi semua daemon berjalan:</strong></p><pre>jps</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/342/1*CzO3afV17nuXB-jveg8czg.jpeg" /></figure><p>Kalau kelima proses itu muncul, selamat — <strong>Hadoop berhasil berjalan!</strong> 🎉</p><h3>10. Hands-On HDFS di Jupyter Notebook</h3><p>Setelah Hadoop berjalan, kita lanjut ke Jupyter. Buka terminal baru dan jalankan:</p><pre>conda activate bigdata<br>cd ~/praktikum-bigdata<br>jupyter notebook</pre><p>Lalu buka modul Pertemuan 3 di browser Jupyter yang terbuka.</p><h4>Cek versi HDFS dan buat direktori</h4><pre># Cek versi — kalau tidak muncul error berarti integrasi Jupyter-Hadoop berhasil<br>!hdfs version<br># Buat direktori kerja di HDFS<br>!hdfs dfs -mkdir -p /user/mahasiswa/praktikum<br># Tampilkan isi direktori untuk verifikasi<br>!hdfs dfs -ls /user/mahasiswa</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g4sipFx6F1QgI_XlhBAZuw.jpeg" /></figure><h4>Upload file dari lokal ke HDFS</h4><pre># Buat file teks sederhana di disk lokal dulu<br>with open(&quot;contoh_lokal.txt&quot;, &quot;w&quot;) as f:<br>    f.write(&quot;Halo dari Praktikum Big Data!\n&quot;)<br>    f.write(&quot;Berkas ini awalnya tersimpan di disk lokal VM.\n&quot;)<br>print(&quot;Berkas lokal berhasil dibuat.&quot;)<br>!ls -la contoh_lokal.txt</pre><pre># Upload (put) ke HDFS<br>!hdfs dfs -put contoh_lokal.txt /user/mahasiswa/praktikum/<br># Verifikasi<br>!hdfs dfs -ls /user/mahasiswa/praktikum</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mnvtX8mXJxwQgZNYYmRuhw.jpeg" /></figure><h4>Baca isi file langsung dari HDFS</h4><pre>!hdfs dfs -cat /user/mahasiswa/praktikum/contoh_lokal.txt</pre><h4>Download file dari HDFS ke lokal</h4><pre># Download dari HDFS dengan nama file berbeda<br>!hdfs dfs -get /user/mahasiswa/praktikum/contoh_lokal.txt hasil_unduh_dari_hdfs.txt<br># Cek isinya<br>!cat hasil_unduh_dari_hdfs.txt</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/941/1*vo3P5ggg-Yd8_oNJS4VKBg.jpeg" /></figure><h4>Cek ukuran dan jumlah file</h4><pre># Cek ukuran (human-readable)<br>!hdfs dfs -du -h /user/mahasiswa/praktikum<br># Hitung jumlah direktori, file, dan total ukuran<br>!hdfs dfs -count /user/mahasiswa/praktikum</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*j3AMlevfynz10hNsqL684w.jpeg" /></figure><h4>Hapus file di HDFS</h4><pre># Hapus file<br>!hdfs dfs -rm /user/mahasiswa/praktikum/contoh_lokal.txt<br># Verifikasi direktori sudah kosong<br>!hdfs dfs -ls /user/mahasiswa/praktikum</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/588/1*ULdPdxzvMxHteiA7uDpdoA.jpeg" /></figure><h3>Ringkasan Perintah HDFS</h3><p>PerintahFungsihdfs dfs -mkdir -p [path]Buat direktori (dengan parent otomatis)hdfs dfs -ls [path]Tampilkan isi direktorihdfs dfs -put [lokal] [hdfs]Upload file dari lokal ke HDFShdfs dfs -get [hdfs] [lokal]Download file dari HDFS ke lokalhdfs dfs -cat [path]Tampilkan isi file teks di HDFShdfs dfs -du -h [path]Tampilkan ukuran disk (human-readable)hdfs dfs -count [path]Hitung jumlah direktori/file dan ukuran totalhdfs dfs -rm [path]Hapus file (tambah -r untuk direktori)</p><h3>Latihan Mandiri</h3><h3>Soal 1 — Buat direktori /user/mahasiswa/latihan3</h3><pre>!hdfs dfs -mkdir -p /user/mahasiswa/latihan3<br>!hdfs dfs -ls /user/mahasiswa</pre><p><strong>Penjelasan:</strong> Perintah -mkdir -p membuat direktori baru di HDFS. Opsi -p memastikan semua parent directory dibuat otomatis kalau belum ada. Setelah itu, !hdfs dfs -ls /user/mahasiswa digunakan untuk verifikasi bahwa direktori latihan3 sudah berhasil terbentuk.</p><h3>Soal 2 — Buat file biodata dan upload ke HDFS</h3><pre># Buat file biodata di disk lokal<br>with open(&quot;biodata.txt&quot;, &quot;w&quot;) as f:<br>    f.write(&quot;Nama  : [Nama Kamu]\n&quot;)<br>    f.write(&quot;NIM   : [NIM Kamu]\n&quot;)<br>    f.write(&quot;Hobi  : Ngoding, Main Game, Nonton Anime\n&quot;)<br>print(&quot;File biodata.txt berhasil dibuat!&quot;)<br>!ls -la biodata.txt<br># Upload ke HDFS<br>!hdfs dfs -put biodata.txt /user/mahasiswa/latihan3/<br>!hdfs dfs -ls /user/mahasiswa/latihan3</pre><p><strong>Penjelasan:</strong> Pertama kita buat file teks biodata.txt di disk lokal menggunakan Python. File ini berisi nama, NIM, dan hobi. Setelah terbuat, kita upload ke HDFS dengan hdfs dfs -put ke direktori /user/mahasiswa/latihan3 yang sudah dibuat di Soal 1. Perintah ls di akhir untuk membuktikan file berhasil terupload.</p><h3>Soal 3 — Tampilkan isi file biodata langsung dari HDFS</h3><pre>!hdfs dfs -cat /user/mahasiswa/latihan3/biodata.txt</pre><p><strong>Penjelasan:</strong> Perintah hdfs dfs -cat membaca dan menampilkan isi file langsung dari HDFS tanpa perlu mendownload terlebih dahulu. Ini sama fungsinya seperti perintah cat di Linux, bedanya file dibaca dari sistem file terdistribusi Hadoop, bukan dari disk lokal.</p><h3>Soal 4 — Refleksi: Perbedaan Disk Lokal vs HDFS</h3><p>Menyimpan file di <strong>disk lokal VM</strong> berarti file itu hanya ada di satu mesin — kalau mesin mati atau rusak, file bisa hilang dan tidak ada mekanisme otomatis untuk memulihkannya. Sebaliknya, menyimpan di <strong>HDFS</strong> berarti file dipecah jadi blok-blok kecil dan disimpan di banyak node secara terdistribusi dengan replikasi (meski di praktikum ini replikasi = 1 karena single-node). Keunggulan utama HDFS bukan soal akses cepat untuk file kecil, melainkan kemampuannya menangani file berukuran sangat besar (GB hingga TB) dan menyediakan fault tolerance — kalau satu node bermasalah, data tetap bisa diakses dari node lain yang menyimpan replikasinya.</p><h3>Tugas Mandiri</h3><h3>Setup: Generate Dataset Tiga Cabang</h3><pre>import numpy as np<br>import pandas as pd<br>kategori_list = [&quot;Elektronik&quot;, &quot;Fashion&quot;, &quot;Makanan &amp; Minuman&quot;, &quot;Kesehatan &amp; Kecantikan&quot;, &quot;Rumah Tangga&quot;]<br>metode_bayar_list = [&quot;Transfer Bank&quot;, &quot;E-Wallet&quot;, &quot;COD&quot;, &quot;Kartu Kredit&quot;]<br>tanggal_range = pd.date_range(&quot;2026-08-01&quot;, &quot;2026-08-31&quot;, freq=&quot;D&quot;)<br>cabang_kota = {&quot;Magelang&quot;: 101, &quot;Yogyakarta&quot;: 202, &quot;Semarang&quot;: 303}<br>for kota, seed in cabang_kota.items():<br>    np.random.seed(seed)<br>    n = 200<br>    data_cabang = {<br>        &quot;order_id&quot;: [f&quot;{kota[:3].upper()}-{2000 + i}&quot; for i in range(n)],<br>        &quot;tanggal&quot;: np.random.choice(tanggal_range, size=n),<br>        &quot;kategori&quot;: np.random.choice(kategori_list, size=n, p=[0.25, 0.25, 0.20, 0.15, 0.15]),<br>        &quot;unit_terjual&quot;: np.random.randint(1, 8, size=n),<br>        &quot;harga_satuan&quot;: np.random.choice([25000, 50000, 75000, 100000, 150000, 250000], size=n),<br>        &quot;metode_pembayaran&quot;: np.random.choice(metode_bayar_list, size=n),<br>    }<br>    df_cabang = pd.DataFrame(data_cabang)<br>    df_cabang[&quot;kota&quot;] = kota<br>    nama_file = f&quot;transaksi_{kota.lower()}.csv&quot;<br>    df_cabang.to_csv(nama_file, index=False)<br>    print(f&quot;Berkas &#39;{nama_file}&#39; berhasil dibuat: {df_cabang.shape[0]} baris&quot;)<br>print(&quot;\nKetiga berkas CSV cabang siap digunakan untuk Tugas Mandiri.&quot;)</pre><p><strong>Penjelasan:</strong> Cell ini generate tiga dataset CSV yang merepresentasikan data transaksi dari tiga cabang kota (Magelang, Yogyakarta, Semarang) selama Agustus 2026. Masing-masing berisi 200 baris transaksi dengan seed berbeda biar datanya bervariasi tapi tetap reproducible.</p><h3>Bagian A — Membangun Struktur Direktori HDFS</h3><pre># Buat struktur direktori ecommerce di HDFS<br>!hdfs dfs -mkdir -p /user/mahasiswa/ecommerce/raw<br>!hdfs dfs -mkdir -p /user/mahasiswa/ecommerce/processed<br># Verifikasi struktur sudah terbentuk<br>!hdfs dfs -ls /user/mahasiswa/ecommerce</pre><p><strong>Penjelasan:</strong> Kita buat dua folder di HDFS: raw untuk menyimpan data mentah (CSV yang baru diupload), dan processed untuk data yang sudah diolah. Pemisahan ini merupakan praktik baik dalam pipeline data — data mentah tidak boleh diubah, sementara folder processed berisi hasil transformasi yang bisa berubah-ubah sesuai kebutuhan analisis.</p><h3>Bagian B — Upload Data Mentah ke HDFS</h3><pre># Upload ketiga CSV ke direktori raw<br>!hdfs dfs -put transaksi_magelang.csv /user/mahasiswa/ecommerce/raw/<br>!hdfs dfs -put transaksi_yogyakarta.csv /user/mahasiswa/ecommerce/raw/<br>!hdfs dfs -put transaksi_semarang.csv /user/mahasiswa/ecommerce/raw/<br># Verifikasi ketiga file berhasil terupload, lengkap dengan ukurannya<br>!hdfs dfs -ls -h /user/mahasiswa/ecommerce/raw</pre><p><strong>Penjelasan:</strong> Perintah hdfs dfs -put digunakan tiga kali untuk upload masing-masing file CSV ke HDFS. Opsi -h pada perintah ls di akhir akan menampilkan ukuran file dalam format yang lebih mudah dibaca (KB, MB, dst.).</p><h3>Bagian C — Baca dan Gabungkan Data dari HDFS</h3><pre>import subprocess<br>import io<br>def baca_hdfs_csv(hdfs_path):<br>    &quot;&quot;&quot;Fungsi helper untuk membaca file CSV langsung dari HDFS ke DataFrame&quot;&quot;&quot;<br>    result = subprocess.run(<br>        [&quot;hdfs&quot;, &quot;dfs&quot;, &quot;-cat&quot;, hdfs_path],<br>        capture_output=True, text=True<br>    )<br>    return pd.read_csv(io.StringIO(result.stdout))<br># Baca ketiga file dari HDFS (bukan dari disk lokal!)<br>df_magelang   = baca_hdfs_csv(&quot;/user/mahasiswa/ecommerce/raw/transaksi_magelang.csv&quot;)<br>df_yogyakarta = baca_hdfs_csv(&quot;/user/mahasiswa/ecommerce/raw/transaksi_yogyakarta.csv&quot;)<br>df_semarang   = baca_hdfs_csv(&quot;/user/mahasiswa/ecommerce/raw/transaksi_semarang.csv&quot;)<br># Gabungkan jadi satu DataFrame<br>df_gabungan = pd.concat([df_magelang, df_yogyakarta, df_semarang], ignore_index=True)<br>print(f&quot;Total baris setelah digabung: {len(df_gabungan)}&quot;)<br>print(&quot;\nDistribusi transaksi per kota:&quot;)<br>print(df_gabungan[&quot;kota&quot;].value_counts())</pre><p><strong>Penjelasan:</strong> Di bagian ini kita membaca file langsung dari HDFS menggunakan subprocess yang memanggil hdfs dfs -cat. Hasilnya ditangkap sebagai string, lalu dikonversi ke DataFrame dengan pd.read_csv. Ketiga DataFrame kemudian digabung menggunakan pd.concat dengan ignore_index=True agar indexnya diatur ulang dari 0. Hasilnya adalah satu DataFrame dengan 600 baris (200 × 3 kota).</p><h3>Bagian D — Olah Data dan Upload ke Folder Processed</h3><pre># Langkah 1: Tambahkan kolom total_pendapatan<br>df_gabungan[&quot;total_pendapatan&quot;] = df_gabungan[&quot;unit_terjual&quot;] * df_gabungan[&quot;harga_satuan&quot;]<br>print(&quot;Kolom total_pendapatan berhasil ditambahkan:&quot;)<br>print(df_gabungan[[&quot;kota&quot;, &quot;kategori&quot;, &quot;unit_terjual&quot;, &quot;harga_satuan&quot;, &quot;total_pendapatan&quot;]].head(5))</pre><pre># Langkah 2: Buat tabel ringkasan per kota dan per kategori<br>ringkasan_kota_kategori = df_gabungan.groupby([&quot;kota&quot;, &quot;kategori&quot;])[&quot;total_pendapatan&quot;].sum().reset_index()<br>ringkasan_kota_kategori.columns = [&quot;kota&quot;, &quot;kategori&quot;, &quot;total_pendapatan&quot;]<br>ringkasan_kota_kategori = ringkasan_kota_kategori.sort_values([&quot;kota&quot;, &quot;total_pendapatan&quot;], ascending=[True, False])<br>print(&quot;\nRingkasan Total Pendapatan per Kota dan Kategori:&quot;)<br>print(ringkasan_kota_kategori.to_string(index=False))</pre><pre># Langkah 3: Simpan ke disk lokal, lalu upload ke HDFS processed<br># Simpan ke lokal<br>df_gabungan.to_csv(&quot;data_gabungan_bersih.csv&quot;, index=False)<br>ringkasan_kota_kategori.to_csv(&quot;ringkasan_kota_kategori.csv&quot;, index=False)<br>print(&quot;Kedua file berhasil disimpan di disk lokal.&quot;)<br># Upload ke HDFS processed<br>!hdfs dfs -put data_gabungan_bersih.csv /user/mahasiswa/ecommerce/processed/<br>!hdfs dfs -put ringkasan_kota_kategori.csv /user/mahasiswa/ecommerce/processed/<br># Verifikasi<br>print(&quot;\nIsi direktori processed di HDFS:&quot;)<br>!hdfs dfs -ls -h /user/mahasiswa/ecommerce/processed</pre><p><strong>Penjelasan:</strong></p><ul><li><strong>Langkah 1:</strong> Kolom total_pendapatan dihitung dari perkalian unit_terjual × harga_satuan, merepresentasikan nilai rupiah dari setiap transaksi.</li><li><strong>Langkah 2:</strong> groupby mengelompokkan data berdasarkan kombinasi kota + kategori, lalu menjumlahkan total pendapatannya. Hasilnya adalah tabel ringkasan yang menunjukkan seberapa besar kontribusi setiap kategori produk di masing-masing kota.</li><li><strong>Langkah 3:</strong> Kedua hasil olahan disimpan ke disk lokal dulu (karena Hadoop mode kita tidak mendukung write langsung dari Python ke HDFS tanpa library tambahan), lalu diupload ke direktori processed menggunakan hdfs dfs -put.</li></ul><h3>Bagian E — Dokumentasi dan Refleksi</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/870/1*IUHkyj1dA8R_pi1GrF1Fng.jpeg" /></figure><p><strong>Refleksi:</strong></p><p>Menyimpan data mentah (raw) terpisah dari data olahan (processed) di HDFS memiliki keunggulan yang signifikan dibandingkan mencampur semuanya dalam satu folder. Pertama, data mentah yang tersimpan di folder raw berfungsi sebagai <strong>sumber kebenaran tunggal (single source of truth)</strong> — kalau ada kesalahan di proses pengolahan, kita bisa kembali ke data asli dan mengulangi proses dari awal tanpa kehilangan apapun. Kedua, pemisahan ini memudahkan <strong>audit dan reproduksibilitas</strong> — kita tahu dengan pasti mana data yang belum disentuh dan mana yang sudah melalui transformasi tertentu, sehingga orang lain (atau diri kita di masa depan) bisa memverifikasi langkah-langkah yang sudah dilakukan. Ketiga, dalam skenario produksi nyata, pemisahan ini mendukung <strong>arsitektur Data Lake</strong> yang baik: folder raw bisa dikunci agar hanya sistem ingestion yang boleh menulis, sementara folder processed diakses oleh tim analyst dan data scientist — ini mencegah data mentah tidak sengaja ditimpa atau dimodifikasi yang bisa merusak seluruh pipeline analisis downstream.</p><h3>Penutup</h3><p>Pertemuan ini bisa dibilang salah satu yang paling “berat” secara teknis karena kita melakukan setup dari nol — tapi hasilnya juga yang paling memuaskan. Sekarang kita udah punya Hadoop yang berjalan dan bisa beroperasi dengan HDFS langsung dari Jupyter Notebook.</p><p>Takeaway utama dari pertemuan ini:</p><ul><li>Hadoop hadir untuk mengatasi keterbatasan pengolahan data satu mesin ketika data sudah berukuran sangat besar</li><li>HDFS bukan pengganti filesystem biasa — ia dirancang khusus untuk file besar yang diakses secara streaming, bukan file kecil yang sering dibaca-tulis</li><li>Mode pseudo-distributed yang kita pakai adalah cara belajar yang valid sebelum terjun ke cluster multi-node yang sesungguhnya</li><li>Struktur folder yang rapi di HDFS (raw vs processed) bukan hanya soal kerapian, tapi fondasi arsitektur data yang benar</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd7cd5fe1c5c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sebelum Data Menjadi Besar: Perjalanan Pertama Menyiapkan Python Environment]]></title>
            <link>https://medium.com/@bara.p/sebelum-data-menjadi-besar-perjalanan-pertama-menyiapkan-python-environment-632157f301d6?source=rss-0fbd6d1ade15------2</link>
            <guid isPermaLink="false">https://medium.com/p/632157f301d6</guid>
            <dc:creator><![CDATA[bara paramarta]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 17:57:45 GMT</pubDate>
            <atom:updated>2026-09-02T17:57:45.462Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*a_JI2qbxyzwAz5oWsCShgQ.jpeg" /></figure><p>Pada praktikum Big Data kali ini, aku mulai masuk ke bagian yang cukup penting sebelum nantinya berhadapan dengan data dalam jumlah yang lebih besar, yaitu menyiapkan lingkungan kerja Python.</p><p>Kalau sebelumnya mungkin Python hanya dijalankan langsung dari komputer, kali ini aku mulai dikenalkan dengan <strong>Anaconda, Conda Environment, dan Jupyter Notebook</strong>. Ketiganya bakal cukup sering dipakai untuk praktikum-praktikum berikutnya, terutama karena Big Data nantinya akan banyak berhubungan dengan Python dan berbagai library untuk pengolahan data.</p><p>Jadi, sebelum jauh-jauh membahas data yang besar, langkah pertama yang dilakukan adalah memastikan “dapur” untuk mengolah datanya sudah siap.</p><h3>Mengenal Anaconda dan Kenapa Kita Menggunakannya</h3><p>Sebelum masuk ke instalasi, ada baiknya mengetahui dulu apa sebenarnya Anaconda itu.</p><p><strong>Anaconda</strong> merupakan distribusi Python yang memang ditujukan untuk kebutuhan data science. Di dalamnya sudah tersedia berbagai library yang umum digunakan untuk mengolah dan menganalisis data, seperti <strong>pandas, numpy, matplotlib</strong>, dan juga Jupyter. Selain itu, Anaconda menyediakan <strong>Conda</strong> yang digunakan untuk mengatur package sekaligus environment Python.</p><p>Bagian environment ini cukup penting. Bayangkan kalau semua praktikum menggunakan satu instalasi Python yang sama. Bisa saja suatu project membutuhkan versi library tertentu, sedangkan project lain membutuhkan versi yang berbeda. Kalau semuanya dicampur, kemungkinan muncul konflik versi akan semakin besar.</p><p>Dengan Conda, kita bisa membuat lingkungan yang terpisah untuk kebutuhan tertentu. Pada praktikum ini, environment tersebut nantinya diberi nama bigdata.</p><h3>1. Menyiapkan Anaconda</h3><p>Langkah pertama yang dilakukan adalah mengunduh installer Anaconda untuk Linux. Karena praktikum menggunakan Ubuntu, installer yang digunakan berupa file dengan ekstensi .sh.</p><p>Aku membuka halaman resmi download Anaconda melalui browser.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6mxiJ4PODN5nxT-5aOV3Ng.jpeg" /></figure><p>Dari halaman tersebut, installer untuk Linux dipilih dan kemudian diunduh. File installer biasanya akan masuk ke folder Downloads.</p><p>Di modul, file installer yang digunakan memiliki pola nama seperti:</p><pre>Anaconda3-2025.12-Linux-x86_64.sh</pre><p>Nama versinya bisa saja berbeda tergantung kapan Anaconda diunduh, jadi tidak perlu terpaku pada angka versinya. Yang penting adalah file tersebut merupakan installer Anaconda untuk Linux 64-bit.</p><h3>2. Masuk ke Folder Downloads</h3><p>Setelah installer selesai diunduh, langkah berikutnya adalah membuka Terminal dan berpindah ke folder Downloads.</p><p>Perintah yang digunakan kurang lebih seperti ini:</p><pre>cd ~/Downloads<br>ls</pre><p>Pada praktiknya, aku menggunakan terminal untuk berpindah ke folder tempat file installer berada. Setelah itu, isi folder bisa dicek menggunakan ls untuk memastikan file Anaconda memang sudah ada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/766/1*7VZYL36Y5B1IBrHOEF7Kqw.jpeg" /></figure><p>Setelah file ditemukan, installer dijalankan menggunakan perintah bash. Nama file disesuaikan dengan nama installer yang sudah diunduh.</p><p>Contohnya:</p><pre>bash Anaconda3-*-Linux-x86_64.sh</pre><p>Perintah tersebut akan menjalankan proses instalasi Anaconda melalui terminal.</p><h3>3. Proses Instalasi Anaconda</h3><p>Setelah perintah installer dijalankan, terminal mulai menampilkan proses instalasi Anaconda.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/742/1*LrgtJ0MepELzHVSOxqEZFA.jpeg" /></figure><p>Di tahap ini ada beberapa hal yang perlu diperhatikan. Installer akan meminta persetujuan terhadap lisensi, lokasi instalasi, dan konfigurasi Conda.</p><p>Secara umum alurnya adalah membaca lisensi, menyetujui lisensi dengan mengetik yes, kemudian menentukan lokasi instalasi. Jika menggunakan lokasi default, Anaconda akan dipasang di folder seperti:</p><pre>/home/mahasiswa/anaconda3</pre><p>Setelah instalasi selesai, Conda juga dapat dikonfigurasi agar otomatis dikenali oleh shell. Modul menyarankan untuk menutup dan membuka kembali terminal atau menjalankan:</p><pre>source ~/.bashrc</pre><p>supaya perintah conda bisa langsung digunakan.</p><h3>4. Mengecek Apakah Conda Sudah Berhasil</h3><p>Setelah instalasi selesai, tentu aku nggak langsung menganggap semuanya aman. Langkah berikutnya adalah melakukan pengecekan.</p><p>Perintah yang digunakan:</p><pre>conda --version</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/510/1*6-9xVYIMj2Fdde6-3FRA9Q.jpeg" /></figure><p>Kalau terminal menampilkan versi Conda tanpa error, berarti instalasi sudah berhasil.</p><p>Versi yang ditampilkan tidak harus sama persis karena versi Anaconda/Conda dapat berubah. Pada modul, contoh output yang diberikan adalah:</p><pre>conda 26.5.3</pre><p>Yang lebih penting adalah perintah conda sudah dikenali oleh terminal.</p><p>Pada tahap ini biasanya juga terlihat tulisan:</p><pre>(base)</pre><p>di awal baris terminal.</p><p>Ini menunjukkan bahwa saat ini aku sedang berada di environment bawaan Anaconda, yaitu base.</p><p>Namun, environment base ini nantinya tidak langsung digunakan untuk praktikum. Kita akan membuat environment khusus bernama bigdata.</p><h3>5. Membuat Environment Khusus Big Data</h3><p>Nah, ini salah satu bagian yang menurutku cukup penting dari praktikum ini.</p><p>Daripada semua library dicampur dalam satu environment, kita membuat environment khusus untuk praktikum Big Data.</p><p>Perintah yang digunakan:</p><pre>conda create -n bigdata python=3.11 pandas=2.2 numpy=1.26 matplotlib=3.8 jupyter notebook seaborn -c conda-forge -y</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*tCaYl0k65PB4zZgGcxJ2DA.jpeg" /></figure><p>Kalau dilihat dari perintahnya memang cukup panjang, tetapi sebenarnya isinya adalah memberi tahu Conda package apa saja yang ingin disiapkan.</p><p>Environment yang dibuat bernama:</p><pre>bigdata</pre><p>dengan Python 3.11 serta beberapa library utama seperti pandas, numpy, matplotlib, Jupyter, notebook, dan seaborn. Modul menggunakan kombinasi versi tersebut karena sudah disiapkan agar kompatibel untuk kebutuhan praktikum berikutnya.</p><p>Proses ini bisa memakan waktu beberapa menit karena Conda perlu mengunduh dan memasang berbagai package beserta dependency-nya.</p><p>Setelah proses selesai, environment tersebut perlu diaktifkan:</p><pre>conda activate bigdata</pre><p>Kalau berhasil, tulisan:</p><pre>(base)</pre><p>akan berubah menjadi:</p><pre>(bigdata)</pre><p>Perubahan tersebut sebenarnya sederhana, tetapi penting. Itu berarti perintah Python dan library yang dijalankan setelahnya akan menggunakan environment bigdata.</p><h3>6. Masuk ke Folder Praktikum dan Menjalankan Jupyter Notebook</h3><p>Setelah environment siap, langkah selanjutnya adalah masuk ke folder yang digunakan untuk menyimpan praktikum.</p><p>Folder tersebut sebelumnya dibuat dengan nama:</p><pre>praktikum-bigdata</pre><p>Kemudian environment bigdata diaktifkan dan Jupyter Notebook dijalankan.</p><p>Kurang lebih perintahnya:</p><pre>conda activate bigdata<br>cd ~/praktikum-bigdata<br>jupyter notebook</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*bPknCk5kX0Md5n1-NT1mHw.jpeg" /></figure><p>Setelah jupyter notebook dijalankan, browser akan membuka halaman Jupyter Notebook yang menampilkan isi folder praktikum.</p><p>Dari sini file .ipynb bisa dibuka dan kode Python dapat dijalankan langsung melalui notebook.</p><p>Modul memang menggunakan Jupyter Notebook sebagai tempat utama untuk mencoba kode Python selama praktikum.</p><p>Menurutku Jupyter cukup nyaman untuk belajar data karena kode bisa dijalankan sedikit demi sedikit. Jadi kalau ada lima bagian kode, kita tidak harus menjalankan semuanya sekaligus.</p><h3>7. Tes Pertama: Hello World</h3><p>Sebelum mulai mengolah data, tentunya perlu memastikan bahwa environment Python yang baru saja dibuat benar-benar bisa digunakan.</p><p>Tes sederhananya adalah menjalankan kode:</p><pre>print(&quot;Hello World!&quot;)<br>print(&quot;Environment berjalan dengan baik&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/542/1*bvk7bJyg_YJLh16gVVlt-g.jpeg" /></figure><p>Kalau output muncul seperti:</p><pre>Hello World!<br>Environment berjalan dengan baik</pre><p>berarti Python sudah bisa menjalankan kode dari Jupyter Notebook.</p><p>Memang kelihatannya sederhana, cuma print() saja. Tapi langkah kecil seperti ini berguna untuk memastikan bahwa environment, kernel Jupyter, dan Python sudah saling terhubung dengan benar sebelum masuk ke bagian yang lebih serius.</p><h3>8. Memastikan Library Data Science Sudah Siap</h3><p>Setelah Python berhasil dijalankan, berikutnya adalah mengecek library yang nantinya bakal sering digunakan.</p><p>Pada praktikum ini ada tiga library utama yang diperkenalkan:</p><ul><li><strong>pandas</strong> untuk mengelola dan menganalisis data berbentuk tabel.</li><li><strong>numpy</strong> untuk operasi numerik dan matematika.</li><li><strong>matplotlib</strong> untuk membuat visualisasi data.</li></ul><p>Kode yang digunakan:</p><pre>import sys<br>import pandas as pd<br>import numpy as np<br>import matplotlib<br>import matplotlib.pyplot as plt</pre><pre>print(&quot;Python      :&quot;, sys.version.split()[0])<br>print(&quot;pandas      :&quot;, pd.__version__)<br>print(&quot;numpy       :&quot;, np.__version__)<br>print(&quot;matplotlib  :&quot;, matplotlib.__version__)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/776/1*hqS_n5c5KQwV4BgDwdTbvw.jpeg" /></figure><p>Di sini aku tidak hanya mengecek apakah library bisa di-import, tetapi juga melihat versi yang sedang digunakan.</p><p>Ini ternyata cukup berguna. Ketika suatu saat muncul error karena perbedaan versi library, informasi versi seperti ini bisa membantu mencari tahu penyebabnya.</p><p>Modul sendiri menggunakan Python 3.11 dengan pandas 2.2.x, numpy 1.26.x, dan matplotlib 3.8.x sebagai kombinasi lingkungan praktikum.</p><h3>9. Mulai Kenalan dengan Variabel Python</h3><p>Setelah environment dan library aman, barulah masuk ke Python dasarnya.</p><p>Pertama adalah variabel dan tipe data.</p><p>Contohnya:</p><pre>nama_mahasiswa = &quot;Budi&quot;<br>npm = 210411001<br>ipk = 3.75<br>aktif_kuliah = True</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/1*YzOtvu3rxaTC8OXQPTTW-w.jpeg" /></figure><p>Dari contoh tersebut terdapat beberapa tipe data dasar:</p><ul><li>&quot;Budi&quot; → string, karena berupa teks.</li><li>210411001 → integer, karena berupa bilangan bulat.</li><li>3.75 → float, karena berupa bilangan desimal.</li><li>True → boolean, karena hanya memiliki kondisi benar atau salah.</li></ul><p>Untuk mengetahui tipe datanya, Python menyediakan fungsi type().</p><p>Misalnya:</p><pre>type(ipk)</pre><p>akan menghasilkan tipe float.</p><p>Di modul, tipe data tersebut juga ditampilkan langsung bersama nilainya menggunakan type(...).__name__.</p><h3>10. Tidak Hanya Variabel, Ada List dan Dictionary</h3><p>Python juga memiliki struktur data yang lebih kompleks.</p><p>Salah satu contohnya adalah list.</p><pre>daftar_nilai = [85, 90, 78, 92, 88]</pre><pre>print(&quot;Daftar nilai:&quot;, daftar_nilai)<br>print(&quot;Rata-rata   :&quot;, sum(daftar_nilai) / len(daftar_nilai))</pre><p>List bisa digunakan untuk menyimpan beberapa data secara berurutan. Dari data tersebut kita juga bisa melakukan operasi sederhana, misalnya menghitung rata-rata.</p><p>Selain list, ada juga <strong>dictionary</strong> yang menggunakan pasangan key-value.</p><p>Contohnya:</p><pre>mahasiswa = {<br>    &quot;nama&quot;: &quot;Budi&quot;,<br>    &quot;npm&quot;: 210411001,<br>    &quot;jurusan&quot;: &quot;Teknologi Informasi&quot;,<br>    &quot;semester&quot;: 3<br>}</pre><p>Kalau list lebih terasa seperti kumpulan data, dictionary lebih mirip data yang memiliki label. Misalnya kita bisa mengambil nilai &quot;nama&quot; atau &quot;npm&quot; berdasarkan key-nya.</p><p>Konsep seperti ini nantinya cukup berguna ketika mulai berurusan dengan data yang lebih terstruktur.</p><h3>11. Mulai Masuk ke DataFrame</h3><p>Setelah mengenal dasar Python, praktikum mulai masuk ke bagian yang lebih dekat dengan pengolahan data, yaitu <strong>DataFrame menggunakan pandas</strong>.</p><p>Kalau disederhanakan, DataFrame bisa dibayangkan seperti tabel Excel yang memiliki baris dan kolom. Bedanya, tabel tersebut sekarang bisa kita manipulasi menggunakan kode Python.</p><p>Pada modul digunakan contoh data penjualan UMKM dari beberapa kota:</p><pre>data_penjualan = {<br>    &quot;kota&quot;: [&quot;Magelang&quot;, &quot;Yogyakarta&quot;, &quot;Semarang&quot;, &quot;Solo&quot;,<br>             &quot;Magelang&quot;, &quot;Yogyakarta&quot;, &quot;Semarang&quot;, &quot;Solo&quot;],<br>    &quot;minggu&quot;: [1, 1, 1, 1, 2, 2, 2, 2],<br>    &quot;produk&quot;: [&quot;Kaos&quot;, &quot;Kaos&quot;, &quot;Kaos&quot;, &quot;Kaos&quot;,<br>               &quot;Kaos&quot;, &quot;Kaos&quot;, &quot;Kaos&quot;, &quot;Kaos&quot;],<br>    &quot;unit_terjual&quot;: [120, 95, 150, 80, 135, 110, 160, 90],<br>    &quot;harga_satuan&quot;: [75000, 75000, 75000, 75000,<br>                     75000, 75000, 75000, 75000]<br>}</pre><pre>df = pd.DataFrame(data_penjualan)</pre><p>Hasilnya adalah sebuah tabel yang disimpan dalam variabel df.</p><p>Walaupun pada bagian ini tidak ada screenshot yang aku dokumentasikan, bagian ini sebenarnya cukup penting karena mulai memperlihatkan alasan kenapa pandas digunakan.</p><p>Kita tidak lagi sekadar mencetak teks, tetapi mulai bekerja dengan kumpulan data yang mempunyai struktur.</p><h3>12. Mengenal Data dengan head(), info(), dan describe()</h3><p>Setelah DataFrame dibuat, tentu kita perlu tahu isi datanya.</p><p>Beberapa fungsi yang digunakan antara lain:</p><pre>df.head()</pre><p>Fungsi ini digunakan untuk melihat beberapa baris pertama dari data.</p><p>Kemudian:</p><pre>df.info()</pre><p>digunakan untuk melihat informasi struktur DataFrame, seperti jumlah data dan tipe data setiap kolom.</p><p>Sedangkan:</p><pre>df.describe()</pre><p>digunakan untuk melihat ringkasan statistik dari kolom numerik.</p><p>Tiga fungsi ini kelihatannya sederhana, tetapi sangat berguna ketika kita baru menerima sebuah dataset dan belum tahu isinya seperti apa.</p><h3>13. Menambahkan Data Baru dari Hasil Perhitungan</h3><p>DataFrame juga bisa ditambahkan kolom baru.</p><p>Contohnya, dari data jumlah barang terjual dan harga satuan, kita bisa menghitung total pendapatan:</p><pre>df[&quot;total_pendapatan&quot;] = df[&quot;unit_terjual&quot;] * df[&quot;harga_satuan&quot;]</pre><p>Dengan satu baris tersebut, pandas akan membuat kolom baru bernama total_pendapatan.</p><p>Ini salah satu hal yang menarik dari pandas. Operasi yang kalau dilakukan satu per satu mungkin cukup merepotkan, bisa dilakukan langsung terhadap satu kolom data.</p><h3>14. Filtering Data</h3><p>Setelah bisa membuat dan melihat data, berikutnya adalah mengambil bagian data tertentu.</p><p>Misalnya aku hanya ingin melihat penjualan dari Magelang:</p><pre>data_magelang = df[df[&quot;kota&quot;] == &quot;Magelang&quot;]<br>data_magelang</pre><p>Atau menggunakan lebih dari satu kondisi:</p><pre>data_filter = df[<br>    (df[&quot;unit_terjual&quot;] &gt; 100) &amp;<br>    (df[&quot;minggu&quot;] == 2)<br>]</pre><pre>data_filter</pre><p>Dengan filtering seperti ini, kita tidak perlu melihat seluruh isi dataset ketika hanya membutuhkan data dengan kondisi tertentu.</p><p>Konsep filtering seperti ini nantinya akan sangat sering digunakan ketika melakukan eksplorasi dataset.</p><h3>15. Mengelompokkan Data dengan groupby()</h3><p>Selain filtering, ada juga operasi <strong>group by</strong>.</p><p>Misalnya kita ingin mengetahui total pendapatan masing-masing kota selama dua minggu:</p><pre>total_per_kota = (<br>    df.groupby(&quot;kota&quot;)[&quot;total_pendapatan&quot;]<br>      .sum()<br>      .sort_values(ascending=False)<br>)</pre><pre>print(&quot;Total pendapatan per kota (2 minggu):&quot;)<br>total_per_kota</pre><p>Di sini data dikelompokkan berdasarkan kolom kota, kemudian nilai total_pendapatan dijumlahkan.</p><p>Hasil akhirnya bisa digunakan untuk melihat kota mana yang menghasilkan pendapatan paling besar.</p><p>Jadi mulai dari sini sudah terlihat sedikit gambaran bagaimana Python dan pandas bisa dipakai untuk mengambil informasi dari sekumpulan data, bukan hanya sekadar menyimpan data.</p><h3>16. Latihan Mandiri — Soal 1</h3><p>Setelah semua materi dasar selesai, praktikum dilanjutkan dengan latihan mandiri.</p><p>Soal pertama meminta untuk membuat DataFrame bernama df_nilai yang berisi nilai lima mahasiswa dengan kolom:</p><ul><li>nama</li><li>uts</li><li>uas</li></ul><p>Kemudian ditambahkan kolom nilai_akhir menggunakan rumus:</p><pre>(uts × 0.4) + (uas × 0.6)</pre><p>Untuk mengerjakannya, salah satu bentuk kode yang bisa digunakan adalah:</p><pre>data_nilai = {<br>    &quot;nama&quot;: [&quot;Andi&quot;, &quot;Budi&quot;, &quot;Citra&quot;, &quot;Dina&quot;, &quot;Eko&quot;],<br>    &quot;uts&quot;: [80, 75, 90, 85, 70],<br>    &quot;uas&quot;: [85, 80, 88, 90, 75]<br>}</pre><pre>df_nilai = pd.DataFrame(data_nilai)</pre><pre>df_nilai[&quot;nilai_akhir&quot;] = (<br>    df_nilai[&quot;uts&quot;] * 0.4<br>) + (<br>    df_nilai[&quot;uas&quot;] * 0.6<br>)</pre><pre>df_nilai</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/942/1*-UD4wvIyL78bJ_XuV_7y-A.jpeg" /></figure><p>Dari sini kita bisa melihat bahwa kolom nilai_akhir tidak perlu dihitung satu per satu. Pandas bisa langsung melakukan operasi terhadap seluruh nilai pada kolom uts dan uas.</p><p>Ini juga menjadi contoh sederhana bagaimana sebuah dataset dapat ditambahkan informasi baru berdasarkan data yang sudah tersedia.</p><blockquote><strong><em>Catatan:</em></strong><em> Kalau data nama dan nilai yang kamu gunakan di screenshot berbeda dengan contoh di atas, bagian kode di laporan sebaiknya disamakan dengan screenshot aslimu.</em></blockquote><h3>17. Latihan Mandiri — Soal 2</h3><p>Soal kedua masih menggunakan DataFrame df_nilai yang sebelumnya sudah dibuat.</p><p>Kali ini kita diminta untuk menampilkan hanya mahasiswa yang memiliki nilai_akhir di atas 80.</p><p>Kode yang digunakan cukup sederhana:</p><pre>df_nilai[df_nilai[&quot;nilai_akhir&quot;] &gt; 80]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/715/1*8eY-MPkGodxVCOossBy9vw.jpeg" /></figure><p>Di sinilah konsep filtering yang sebelumnya sudah dipelajari mulai digunakan kembali.</p><p>Kita memberikan kondisi:</p><pre>df_nilai[&quot;nilai_akhir&quot;] &gt; 80</pre><p>kemudian pandas hanya menampilkan baris yang memenuhi kondisi tersebut.</p><p>Jadi sebenarnya materi-materi sebelumnya saling berhubungan. Kita mulai dari variabel, kemudian mengenal DataFrame, membuat kolom baru, dan akhirnya menggunakan kondisi untuk mengambil data tertentu.</p><h3>Penutup</h3><p>Praktikum kali ini bisa dibilang menjadi tahap persiapan sebelum masuk lebih jauh ke dunia Big Data.</p><p>Aku mulai dari hal yang kelihatannya sederhana seperti instalasi Anaconda, lalu membuat environment bigdata, menjalankan Jupyter Notebook, sampai mencoba Python dan beberapa library yang nantinya akan sering digunakan.</p><p>Hal yang paling penting dari praktikum ini menurutku bukan cuma berhasil menjalankan Hello World, tetapi mulai memahami kenapa kita menggunakan <strong>environment yang terpisah</strong> dan bagaimana <strong>pandas</strong> bisa membantu ketika data sudah mulai berbentuk tabel.</p><p>Setelah environment bigdata berhasil dibuat, Python, pandas, numpy, matplotlib, dan Jupyter sudah siap digunakan. Dari situ, materi mulai bergerak dari sekadar menjalankan kode menuju proses membaca, mengolah, memfilter, dan mengelompokkan data.</p><p>Memang dataset yang digunakan pada praktikum ini masih kecil dan sederhana. Tapi konsepnya sudah mulai terasa: kita tidak hanya menyimpan data, melainkan mulai mencari informasi dari data tersebut.</p><p>Dan sepertinya ini baru permulaannya, karena setelah lingkungan kerja dan dasar Python sudah siap, praktikum Big Data berikutnya tinggal membawa kita ke data yang lebih besar dan proses pengolahan yang lebih kompleks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=632157f301d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dari Class sampai Mobil Bisa “Menyala”: Praktikum Java OOP]]></title>
            <link>https://medium.com/@bara.p/dari-class-sampai-mobil-bisa-menyala-praktikum-java-oop-385c3151fbb5?source=rss-0fbd6d1ade15------2</link>
            <guid isPermaLink="false">https://medium.com/p/385c3151fbb5</guid>
            <dc:creator><![CDATA[bara paramarta]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 10:34:20 GMT</pubDate>
            <atom:updated>2026-09-02T10:34:20.295Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*KSCDxJwSRCKJj4IoDre91Q.jpeg" /></figure><h3>Pendahuluan</h3><p>Pada praktikum kali ini saya mulai masuk ke salah satu konsep yang cukup penting dalam pemrograman berorientasi objek, yaitu <strong>class dan object</strong>. Kalau sebelumnya program mungkin masih terasa seperti kumpulan kode yang dijalankan dari atas ke bawah, di bagian ini mulai dikenalkan cara menyusun program berdasarkan objek yang ada di dalamnya.</p><p>Sederhananya, saya bisa membayangkan <strong>class sebagai cetakan</strong>, sedangkan object adalah hasil dari cetakan tersebut. Jadi, kalau saya punya class Mobil, nantinya saya bisa membuat beberapa object mobil yang masing-masing mempunyai data dan perilakunya sendiri.</p><p>Di modul ini, beberapa konsep yang dibahas meliputi class, method, constructor, object, sampai package. Setelah memahami konsep dasarnya, saya kemudian menerapkannya melalui tugas dengan membuat class Mobil dan mengembangkan program tersebut secara bertahap.</p><h3>Dasar Teori</h3><h3>1. Class</h3><p>Hal pertama yang perlu dipahami adalah <strong>class</strong>. Class bisa dianggap sebagai blueprint atau cetakan yang nantinya digunakan untuk membuat object. Di dalam class kita dapat menentukan atribut yang dimiliki object sekaligus perilaku atau method yang bisa dijalankan oleh object tersebut.</p><p>Bentuk sederhananya kurang lebih seperti ini:</p><pre>[modifier1] Class NamaKelas [modifier2] {<br>      //body class<br>}</pre><p>Dengan adanya class, kita tidak perlu menulis struktur object yang sama berulang-ulang. Cukup membuat cetakannya terlebih dahulu, kemudian membuat object berdasarkan class tersebut.</p><h3>2. Method</h3><p>Selain menyimpan data, sebuah class juga bisa mempunyai <strong>method</strong>. Method dapat dianggap sebagai fungsi yang mempunyai tugas tertentu. Misalnya pada class Mobil, kita bisa mempunyai method untuk menyalakan mesin atau menampilkan informasi mobil.</p><p>Secara umum, method ditulis dengan menentukan modifier, tipe nilai yang dikembalikan, nama method, parameter jika diperlukan, dan isi method tersebut.</p><p>Untuk menjalankan sebuah method dari object, kita menggunakan tanda titik (.).</p><p>Contohnya:</p><pre>namaObjek.namaMethod();</pre><p>Jadi kalau saya mempunyai object bernama mobil1 dan di dalam class tersebut ada method startEngine(), pemanggilannya bisa dilakukan seperti:</p><pre>mobil1.startEngine();</pre><h3>3. Constructor</h3><p>Selanjutnya ada <strong>constructor</strong>. Bagian ini cukup penting karena constructor akan dijalankan ketika sebuah object dibuat. Fungsinya adalah melakukan inisialisasi terhadap data yang dimiliki object tersebut.</p><p>Ada beberapa aturan dalam membuat constructor. Nama constructor harus sama dengan nama class dan constructor tidak memiliki nilai return. Sebuah class juga bisa mempunyai lebih dari satu constructor.</p><pre>Class Cetak {<br>  Public Cetak(int bil) {<br>    System.out.println(“Nilai yang akan dikirim adalah”+bil);<br>  }<br>  Public Cetak(String nama){<br>    System.out.println(“Nama yang akan dikirim adalah<br>    ”+nama);<br>  }<br>}</pre><p>Misalnya nantinya class Mobil memiliki atribut merk dan warna, constructor bisa digunakan untuk langsung memberikan nilai awal ketika object dibuat.</p><h3>4. Object</h3><p>Kalau class tadi adalah cetakannya, maka <strong>object adalah hasil instansiasi dari class tersebut</strong>.</p><p>Untuk membuat object di Java, digunakan operator new. Bentuk umumnya adalah:</p><pre>NamaKelas namaObjek = new NamaKelas();</pre><p>Saat new digunakan, Java akan membuat object baru, mengalokasikan memory untuk object tersebut, kemudian memanggil constructor untuk melakukan inisialisasi.</p><p>Setelah object dibuat, atribut maupun method yang dimilikinya bisa diakses menggunakan tanda titik (.).</p><h3>5. Package</h3><p>Terakhir ada <strong>package</strong>. Package digunakan untuk mengelompokkan class dan interface dalam program Java agar struktur program menjadi lebih terorganisir. Package juga bisa mempunyai sub-package.</p><p>Contoh sederhananya:</p><pre>package namaPackage;<br>import packageLain;</pre><p>Dengan package, project Java yang memiliki banyak class akan lebih mudah dikelola karena class-class tersebut dapat dikelompokkan berdasarkan kebutuhan.</p><h3>Praktikum: Membuat Class Mobil 🚘</h3><p>Setelah memahami konsep dasarnya, sekarang saya masuk ke bagian tugas. Pada bagian ini saya menggunakan konsep class dan object yang sudah dibahas sebelumnya untuk membuat sebuah class Mobil.</p><p>Tugasnya cukup menarik karena program tidak berhenti hanya pada membuat object. Class Mobil nantinya akan dikembangkan sedikit demi sedikit sampai bisa menyimpan informasi mobil, mengubah atribut, dan menjalankan method untuk menyalakan mesin. Berikut tahapan yang saya kerjakan.</p><h3>1. Membuat Dua Object dari Class Mobil</h3><p>Pertama, saya membuat class Main dan membuat <strong>dua object</strong> dari class Mobil. Kedua object tersebut kemudian digunakan untuk menampilkan informasi masing-masing mobil.</p><pre>public class Main {<br><br>    public static void main(String[] args) {<br>        // Menciplakan dua object dari class Mobil menggunakan Constructor<br>        Mobil mobil1 = new Mobil(&quot;Toyota&quot;, &quot;Avanza&quot;, 2022, &quot;Hitam&quot;);<br>        Mobil mobil2 = new Mobil(&quot;Honda&quot;, &quot;Civic&quot;, 2023, &quot;Putih&quot;);<br><br>        System.out.println(&quot;--- Informasi Awal ---&quot;);<br>        // Menampilkan informasi kedua object<br>        mobil1.displayInfo();<br>        mobil2.displayInfo();<br><br>        System.out.println(&quot;\n--- Menyalakan Mesin ---&quot;);<br>        // Memanggil startEngine pada setiap object<br>        mobil1.startEngine();<br>        mobil2.startEngine();<br><br>        System.out.println(&quot;\n--- Mengubah Warna Mobil ---&quot;);<br>        // Mengubah warna mobil1 menggunakan method setter<br>        mobil1.setWarna(&quot;Merah Metallic&quot;);<br>        System.out.println(&quot;Warna mobil Toyota Avanza telah diubah.&quot;);<br><br>        System.out.println(&quot;\n--- Informasi Setelah Perubahan ---&quot;);<br>        // Menampilkan perubahan pada object mobil1<br>        mobil1.displayInfo();<br>        mobil2.displayInfo();<br>    }<br>}</pre><p>Setelah program dijalankan, kedua object tersebut seharusnya dapat menampilkan informasi masing-masing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/315/1*f9N7MhnrF028lWYOdPEveA.png" /></figure><p>Dari tahap ini mulai terlihat bagaimana satu class dapat digunakan untuk membuat beberapa object. Walaupun sama-sama berasal dari class Mobil, setiap object bisa mempunyai data yang berbeda.</p><h3>2. Menambahkan Getter dan Setter</h3><p>Selanjutnya, class Mobil saya ubah agar setiap atribut mempunyai <strong>getter dan setter</strong>.</p><p>Getter digunakan untuk mengambil nilai dari atribut, sedangkan setter digunakan untuk mengubah nilai atribut tersebut.</p><pre>public class Mobil {<br><br>    // 1. Atribut di-set private untuk encapsulation<br>    private String merk;<br>    private String model;<br>    private int tahun;<br>    private String warna; // Atribut baru yang ditambahkan<br><br>    // 2. Constructor untuk menerima nilai saat object diciptakan<br>    public Mobil(String merk, String model, int tahun, String warna) {<br>        this.merk = merk;<br>        this.model = model;<br>        this.tahun = tahun;<br>        this.warna = warna;<br>    }<br><br>    // 3. Getter dan Setter untuk setiap atribut<br>    public String getMerk() {<br>        return merk;<br>    }<br><br>    public void setMerk(String merk) {<br>        this.merk = merk;<br>    }<br><br>    public String getModel() {<br>        return model;<br>    }<br><br>    public void setModel(String model) {<br>        this.model = model;<br>    }<br><br>    public int getTahun() {<br>        return tahun;<br>    }<br><br>    public void setTahun(int tahun) {<br>        this.tahun = tahun;<br>    }<br><br>    public String getWarna() {<br>        return warna;<br>    }<br><br>    // Method spesifik untuk mengubah warna (sama seperti setter warna)<br>    public void setWarna(String warna) {<br>        this.warna = warna;<br>    }<br><br>    // 4. Method displayInfo()<br>    public void displayInfo() {<br>        System.out.println(&quot;Mobil &quot; + merk + &quot; &quot; + model + &quot; (&quot; + tahun + &quot;) - Warna: &quot; + warna);<br>    }<br><br>    // 5. Method startEngine()<br>    public void startEngine() {<br>        System.out.println(&quot;Mesin mobil &quot; + merk + &quot; menyala&quot;);<br>    }<br>}</pre><p>Dengan cara ini, akses terhadap atribut menjadi lebih terkontrol karena data tidak harus diakses secara langsung dari luar class.</p><h3>3. Membuat Method startEngine()</h3><p>Setelah getter dan setter selesai, saya menambahkan sebuah method baru bernama startEngine().</p><p>Method ini digunakan untuk menampilkan pesan:</p><pre>Mesin mobil [merk] menyala</pre><p>Jadi output yang dihasilkan akan menyesuaikan merk dari masing-masing object mobil.</p><pre>public void startEngine() {<br>  System.out.println(&quot;Mesin mobil &quot; + merk + &quot; menyala&quot;);<br>}</pre><p>Kemudian method tersebut dipanggil pada kedua object yang sebelumnya sudah dibuat.</p><pre>mobil1.startEngine();<br>mobil2.startEngine();</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/490/1*HYPu_GgxOhhDc_NP7Mgmug.png" /></figure><p>Setelah dijalankan, hasilnya kurang lebih akan menampilkan bahwa mesin dari masing-masing mobil berhasil menyala.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/338/1*ig5Kx9Geh-vwamWZMAY11w.png" /></figure><h3>4. Menambahkan Atribut Warna</h3><p>Berikutnya saya melakukan sedikit modifikasi lagi pada class Mobil. Kali ini saya menambahkan atribut baru, yaitu <strong>warna</strong>.</p><p>Sebelumnya informasi mobil hanya berkaitan dengan atribut yang sudah dibuat. Dengan adanya atribut warna, setiap object mobil sekarang bisa mempunyai informasi tambahan.</p><pre>public String getWarna() {<br>  return warna;<br>}</pre><p>Setelah itu, informasi warna juga perlu dimasukkan ke dalam displayInfo() agar ketika informasi mobil ditampilkan, warna mobil ikut muncul.</p><pre>public void displayInfo() {<br>  System.out.println(&quot;Mobil &quot; + merk + &quot; &quot; + model + &quot; (&quot; + tahun + &quot;) - Warna: &quot; + warna);<br>}</pre><h3>5. Mengubah Warna Mobil</h3><p>Tidak hanya menampilkan warna, saya juga menambahkan method yang bisa digunakan untuk <strong>mengubah warna mobil</strong>.</p><pre>public void setWarna(String warna) {<br>  this.warna = warna;<br>}</pre><p>Kemudian saya mencoba memanggil method tersebut pada salah satu object dan menjalankan kembali displayInfo() untuk melihat apakah warna mobil benar-benar berubah.</p><pre>System.out.println(&quot;\n--- Mengubah Warna Mobil ---&quot;);<br>// Mengubah warna mobil1 menggunakan method setter<br>mobil1.setWarna(&quot;Merah Metallic&quot;);<br>System.out.println(&quot;Warna mobil Toyota Avanza telah diubah.&quot;);<br><br>System.out.println(&quot;\n--- Informasi Setelah Perubahan ---&quot;);<br>// Menampilkan perubahan pada object mobil1<br>mobil1.displayInfo();<br>mobil2.displayInfo();</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/316/1*tZUTIWnxhTppnozOpM8OdQ.png" /></figure><p>Setelah diubah.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/391/1*gv5ZBD0xjvBTnNkhmGISpw.png" /></figure><p>Dari percobaan ini terlihat bahwa nilai atribut pada object bisa berubah ketika setter atau method yang sesuai dipanggil. Jadi object yang sama tidak harus selalu mempunyai keadaan yang sama dari awal sampai akhir program.</p><h3>Kesimpulan</h3><p>Dari praktikum ini saya jadi lebih memahami bagaimana konsep <strong>class dan object</strong> diterapkan dalam program Java. Class dapat digunakan sebagai cetakan untuk membuat object, sedangkan object tersebut nantinya dapat memiliki data dan menjalankan method yang sudah didefinisikan di dalam class.</p><p>Selain itu, saya juga mencoba menggunakan <strong>constructor, getter, setter, dan method</strong> untuk membuat class Mobil menjadi lebih terstruktur. Penambahan atribut warna dan method untuk mengubahnya juga membuat saya lebih memahami bahwa sebuah object dapat memiliki keadaan yang dapat berubah selama program berjalan.</p><p>Jadi, kalau sebelumnya konsep OOP terasa cukup abstrak, melalui contoh Mobil ini konsepnya menjadi sedikit lebih gampang dibayangkan. <strong>Class-nya adalah cetakannya, object-nya mobil yang dibuat dari cetakan tersebut, atributnya adalah informasi mobil, sedangkan method adalah hal-hal yang bisa dilakukan oleh mobil tersebut.</strong></p><p>Link Github: <a href="https://github.com/MrTatTa/pbo-project">https://github.com/MrTatTa/pbo-project</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=385c3151fbb5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>