feat: add article

Author: purwnt

.eleventy.js

@@ -50,7 +50,55 @@ module.exports = function(eleventyConfig) {
   });
 
   eleventyConfig.addCollection("articles", function(collectionApi) {
-    return collectionApi.getFilteredByGlob("src/[0-9][0-9][0-9][0-9]/**/*.md");
+    const items = collectionApi.getFilteredByGlob("src/[0-9][0-9][0-9][0-9]/**/*.md");
+
+    function getSortTime(item) {
+      if (item?.data?.date) {
+        const parsed = new Date(item.data.date);
+        if (!Number.isNaN(parsed.getTime())) return parsed.getTime();
+      }
+
+      const url = item?.url || "";
+      const match = url.match(/^\/(\d{4})\/(\d{2})\//);
+      if (match) {
+        const year = match[1];
+        const month = match[2];
+        const parsed = new Date(`${year}-${month}-01T00:00:00Z`);
+        if (!Number.isNaN(parsed.getTime())) return parsed.getTime();
+      }
+
+      return 0;
+    }
+
+    // Newest first
+    return items.sort((a, b) => getSortTime(b) - getSortTime(a));
+  });
+
+  // Format "Januari 2026" from URL like /2026/01/slug/
+  eleventyConfig.addFilter("getMonthYearFromUrl", function(url) {
+    if (!url) return "";
+    const match = url.match(/^\/(\d{4})\/(\d{2})\//);
+    if (!match) return "";
+
+    const year = match[1];
+    const month = match[2];
+
+    const monthNames = {
+      "01": "Januari",
+      "02": "Februari",
+      "03": "Maret",
+      "04": "April",
+      "05": "Mei",
+      "06": "Juni",
+      "07": "Juli",
+      "08": "Agustus",
+      "09": "September",
+      "10": "Oktober",
+      "11": "November",
+      "12": "Desember",
+    };
+
+    return `${monthNames[month] || month} ${year}`;
   });
 
   // Watch targets

src/2026/01/dasar-cybersecurity-python-port-scanning.md

@@ -0,0 +1,118 @@
+---
+layout: article.njk
+title: "Dasar Cybersecurity dengan Python: Scanning Port Sederhana"
+date: 2026-01-03
+category: SECURITY
+image: /img/logos/logo-belajarpython-square.png
+permalink: /2026/01/dasar-cybersecurity-python-port-scanning/
+---
+
+Python tidak hanya populer untuk Data Science dan Web Development, tetapi juga merupakan bahasa yang sangat *powerful* di dunia **Cybersecurity** dan **Ethical Hacking**. Salah satu teknik dasar dalam keamanan jaringan yang wajib diketahui adalah **Port Scanning**.
+
+Dalam artikel ini, kita akan belajar cara membuat *Port Scanner* sederhana menggunakan Python. Alat ini berguna untuk memeriksa port mana saja yang terbuka pada sebuah server atau komputer target.
+
+## Apa itu Port Scanning?
+
+Port scanning adalah proses memeriksa port pada alamat IP tertentu untuk mengetahui layanan apa yang sedang berjalan. 
+*   **Administrator Jaringan** menggunakannya untuk memastikan keamanan dan menutup port yang tidak perlu.
+*   **Penyerang (Hacker)** menggunakannya untuk mencari celah masuk (vulnerability) pada sistem target.
+
+> **Peringatan Keras:** Gunakan ilmu ini hanya untuk tujuan edukasi, riset keamanan, atau pada jaringan milik Anda sendiri. Melakukan scanning pada jaringan orang lain tanpa izin adalah tindakan ilegal.
+
+## Persiapan
+
+Kita tidak perlu menginstall library tambahan karena kita akan menggunakan library bawaan Python bernama `socket`. Library ini menyediakan antarmuka untuk komunikasi jaringan tingkat rendah.
+
+## Membuat Port Scanner Sederhana
+
+Buatlah file baru bernama `port_scanner.py` dan tulis kode berikut:
+
+```python
+import socket
+import sys
+from datetime import datetime
+
+# Mendefinisikan target
+# Bisa menggunakan IP (misal: 127.0.0.1) atau domain (misal: scanme.nmap.org)
+target_input = "127.0.0.1" 
+
+# Menerjemahkan hostname ke IPv4
+try:
+    target = socket.gethostbyname(target_input)
+except socket.gaierror:
+    print("Hostname tidak dapat diselesaikan.")
+    sys.exit()
+
+print("-" * 50)
+print(f"Sedang memindai target: {target}")
+print(f"Waktu mulai: {datetime.now()}")
+print("-" * 50)
+
+try:
+    # Melakukan scan pada port 1 sampai 100 (bisa diubah range-nya)
+    for port in range(1, 101):
+        # Membuat socket object
+        # AF_INET: IPv4
+        # SOCK_STREAM: TCP
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        
+        # Set timeout agar tidak menunggu terlalu lama jika port tertutup
+        s.settimeout(0.5) 
+        
+        # Mencoba koneksi ke port
+        # connect_ex mengembalikan 0 jika berhasil, dan error code jika gagal
+        result = s.connect_ex((target, port))
+        
+        if result == 0:
+            print(f"Port {port}: TERBUKA")
+            
+        # Menutup koneksi
+        s.close()
+        
+except KeyboardInterrupt:
+    print("\nScan dihentikan oleh pengguna.")
+    sys.exit()
+except socket.error:
+    print("\nTidak dapat terhubung ke server.")
+    sys.exit()
+
+print("-" * 50)
+print("Scan selesai.")
+```
+
+## Penjelasan Kode
+
+1.  **Import Module**:
+    *   `socket`: Inti dari komunikasi jaringan.
+    *   `sys`: Untuk menangani input sistem dan exit.
+    *   `datetime`: Untuk mencatat waktu scan.
+
+2.  **Menentukan Target**:
+    *   `socket.gethostbyname()` mengubah nama domain menjadi alamat IP yang bisa dipahami komputer.
+
+3.  **Looping Port**:
+    *   Kita menggunakan `range(1, 101)` untuk memindai port 1 hingga 100. Anda bisa memperluasnya hingga 65535 (total port TCP), namun akan memakan waktu lebih lama.
+
+4.  **Socket Object**:
+    *   `socket.AF_INET` menentukan kita menggunakan IPv4.
+    *   `socket.SOCK_STREAM` menentukan kita menggunakan protokol TCP.
+
+5.  **Koneksi**:
+    *   `s.connect_ex((target, port))` adalah metode yang mencoba melakukan koneksi. Berbeda dengan `connect()` yang akan *raise error* jika gagal, `connect_ex()` mengembalikan angka. Angka **0** berarti sukses (port terbuka).
+
+6.  **Error Handling**:
+    *   `KeyboardInterrupt`: Menangani jika pengguna menekan `Ctrl+C` untuk menghentikan program.
+    *   `socket.error`: Menangani jika terjadi masalah koneksi umum.
+
+## Mengapa Port Terbuka Berbahaya?
+
+Port yang terbuka ibarat pintu rumah yang tidak terkunci. Jika di balik port tersebut berjalan layanan yang memiliki celah keamanan (bug) atau konfigurasi yang lemah (misal password default), penyerang bisa masuk dan mengambil alih sistem.
+
+Sebagai praktisi keamanan siber, tugas Anda adalah menemukan port-port ini dan memastikan layanan yang berjalan di belakangnya aman, atau menutupnya jika tidak diperlukan.
+
+## Langkah Selanjutnya
+
+Ini adalah teknik *Reconnaissance* (pengumpulan informasi) yang sangat dasar. Untuk pengembangan lebih lanjut, Anda bisa mempelajari:
+*   **Nmap**: Tools scanning paling populer di dunia (bisa dijalankan lewat Python dengan `python-nmap`).
+*   **Banner Grabbing**: Mengambil informasi versi aplikasi yang berjalan di port tertentu.
+*   **Multithreading**: Mempercepat proses scanning dengan menjalankan banyak scan sekaligus.

src/2026/01/membuat-chatbot-python-openai.md

@@ -0,0 +1,101 @@
+---
+layout: article.njk
+title: Membuat Chatbot Sederhana dengan Python dan OpenAI API
+date: 2026-01-03
+category: AI & ML
+image: /img/logos/logo-belajarpython-square.png
+permalink: /2026/01/membuat-chatbot-python-openai/
+---
+
+Revolusi kecerdasan buatan (AI) telah membawa kita ke era di mana komputer bisa memahami dan membalas percakapan manusia dengan sangat natural. Di balik teknologi populer seperti ChatGPT, terdapat model bahasa besar (LLM) yang bisa kita akses menggunakan Python.
+
+Dalam tutorial ini, kita akan membuat chatbot CLI (Command Line Interface) sederhana yang bisa diajak ngobrol layaknya ChatGPT, menggunakan API resmi dari OpenAI.
+
+## Persiapan
+
+Sebelum memulai, ada beberapa hal yang perlu disiapkan:
+
+1.  **Akun OpenAI**: Daftar di [platform.openai.com](https://platform.openai.com) dan buat **API Key**.
+2.  **Python**: Pastikan Python sudah terinstall di komputer Anda.
+3.  **Library OpenAI**: Install library resmi OpenAI versi terbaru.
+
+```bash
+pip install openai
+```
+
+> **Penting**: API Key bersifat rahasia. Jangan pernah membagikannya atau meng-upload kode yang berisi API Key ke GitHub publik.
+
+## Kode Chatbot Cerdas
+
+Kita akan membuat chatbot yang memiliki "ingatan" jangka pendek, sehingga dia bisa nyambung jika diajak ngobrol panjang. Buat file `chatbot.py`:
+
+```python
+from openai import OpenAI
+import os
+
+# Inisialisasi Client
+# Sebaiknya simpan API Key di environment variable, tapi untuk belajar bisa hardcode (HATI-HATI!)
+client = OpenAI(
+    api_key="ganti-dengan-api-key-anda-disini" 
+)
+
+# List untuk menyimpan riwayat percakapan (Context)
+conversation_history = [
+    {"role": "system", "content": "Kamu adalah asisten AI yang ramah, pintar, dan suka membantu programmer pemula belajar Python. Jawablah dengan bahasa gaul Indonesia yang sopan."}
+]
+
+print("Bot: Halo! Ada yang bisa aku bantu soal coding hari ini? (ketik 'keluar' untuk stop)")
+
+while True:
+    # 1. Menerima input user
+    user_input = input("Kamu: ")
+    
+    # Cek jika user ingin berhenti
+    if user_input.lower() in ["keluar", "exit", "stop"]:
+        print("Bot: Oke, sampai jumpa lagi! Semangat codingnya ya!")
+        break
+    
+    # 2. Menambahkan input user ke riwayat percakapan
+    conversation_history.append({"role": "user", "content": user_input})
+    
+    try:
+        # 3. Mengirim request ke OpenAI
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo", # Model yang cepat dan hemat biaya
+            messages=conversation_history
+        )
+        
+        # 4. Mendapatkan balasan AI
+        ai_response = response.choices[0].message.content
+        
+        # 5. Menampilkan balasan
+        print(f"Bot: {ai_response}")
+        
+        # 6. Menyimpan balasan AI ke riwayat agar bot 'ingat' konteks
+        conversation_history.append({"role": "assistant", "content": ai_response})
+        
+    except Exception as e:
+        print(f"Terjadi error: {e}")
+```
+
+## Penjelasan Konsep Penting
+
+### 1. Roles (Peran)
+Dalam API OpenAI, ada 3 peran utama dalam percakapan:
+*   **System**: Memberikan instruksi dasar tentang kepribadian atau tugas AI. Di contoh ini, kita menyuruhnya menjadi "asisten ramah yang suka bahasa gaul".
+*   **User**: Input dari kita (manusia).
+*   **Assistant**: Balasan dari AI. Kita perlu menyimpan ini kembali ke `conversation_history` agar AI tahu apa yang baru saja dia katakan.
+
+### 2. Context (Konteks)
+Model AI sebenarnya "pelupa". Setiap request adalah hal baru baginya. Agar dia bisa nyambung, kita harus mengirimkan **seluruh riwayat percakapan** (`conversation_history`) setiap kali kita bertanya. Inilah mengapa kita menggunakan list `append`.
+
+### 3. Model
+Kita menggunakan `gpt-3.5-turbo` karena ini adalah model yang digunakan ChatGPT versi gratis. Cepat, pintar, dan biayanya sangat murah untuk eksperimen.
+
+## Pengembangan Lebih Lanjut
+
+Chatbot ini bisa dikembangkan menjadi lebih canggih, misalnya:
+*   **Integrasi Telegram/WhatsApp**: Hubungkan script ini dengan API bot Telegram.
+*   **Knowledge Base**: Berikan dokumen PDF atau teks ke dalam prompt agar bot bisa menjawab pertanyaan spesifik tentang perusahaan atau produk Anda.
+*   **Voice Assistant**: Gabungkan dengan library *Text-to-Speech* agar bot bisa bersuara.
+

src/2026/01/pengenalan-machine-learning-python.md

@@ -0,0 +1,102 @@
+---
+layout: article.njk
+title: Pengenalan Machine Learning dengan Python untuk Pemula
+date: 2026-01-03
+category: AI & ML
+image: /img/logos/logo-belajarpython-square.png
+permalink: /2026/01/pengenalan-machine-learning-python/
+---
+
+Machine Learning (ML) adalah cabang dari kecerdasan buatan (AI) yang memungkinkan komputer untuk belajar dari data tanpa harus diprogram secara eksplisit. Jika pemrograman tradisional adalah memberikan instruksi langkah demi langkah, Machine Learning adalah memberikan data kepada komputer dan membiarkannya menemukan pola sendiri.
+
+Python saat ini menjadi bahasa pemrograman "de facto" untuk Machine Learning dan Data Science karena sintaksnya yang mudah dibaca dan ekosistem library yang sangat kaya.
+
+## Tipe-Tipe Machine Learning
+
+Sebelum masuk ke kode, penting untuk memahami tiga kategori utama dalam ML:
+
+1.  **Supervised Learning (Pembelajaran Terawasi)**: Komputer dilatih dengan data yang sudah memiliki label (jawaban). Contoh: Mendeteksi email spam (spam/bukan spam).
+2.  **Unsupervised Learning (Pembelajaran Tak Terawasi)**: Komputer mencari pola dalam data yang tidak berlabel. Contoh: Mengelompokkan pelanggan berdasarkan perilaku belanja (clustering).
+3.  **Reinforcement Learning**: Komputer belajar melalui *trial and error* untuk mencapai tujuan tertentu. Contoh: AI yang belajar bermain game catur.
+
+## Persiapan Lingkungan
+
+Untuk mengikuti tutorial ini, Anda perlu menginstall library `scikit-learn`, yang merupakan library ML paling populer untuk pemula.
+
+```bash
+pip install scikit-learn
+```
+
+## Studi Kasus: Membedakan Apel dan Jeruk
+
+Kita akan membuat program sederhana menggunakan algoritma **Decision Tree** (Pohon Keputusan) untuk membedakan buah Apel dan Jeruk berdasarkan ciri-ciri fisiknya.
+
+Anggap kita memiliki data pengamatan sebagai berikut:
+
+| Berat (gram) | Tekstur | Buah |
+| :--- | :--- | :--- |
+| 140 | Kasar | Jeruk |
+| 130 | Kasar | Jeruk |
+| 150 | Halus | Apel |
+| 170 | Halus | Apel |
+
+Dalam komputer, kita akan mengubah data teks menjadi angka agar bisa diproses:
+*   Tekstur: 0 = Halus, 1 = Kasar
+*   Buah: 0 = Apel, 1 = Jeruk
+
+### Kode Python
+
+Buat file `ml_buah.py` dan tulis kode berikut:
+
+```python
+from sklearn import tree
+
+# 1. Persiapan Data (Features)
+# Format: [berat, tekstur]
+# Tekstur: 0 = Halus, 1 = Kasar
+features = [
+    [140, 1], 
+    [130, 1], 
+    [150, 0], 
+    [170, 0]
+]
+
+# 2. Persiapan Label (Target)
+# 0 = Apel, 1 = Jeruk
+labels = [1, 1, 0, 0]
+
+# 3. Membuat Model (Classifier)
+# Kita menggunakan Decision Tree
+clf = tree.DecisionTreeClassifier()
+
+# 4. Melatih Model (Training)
+# Model belajar pola dari data features dan labels
+clf = clf.fit(features, labels)
+
+# 5. Melakukan Prediksi
+# Kita punya buah baru: Berat 160g, Tekstur Halus (0)
+buah_baru = [[160, 0]]
+prediksi = clf.predict(buah_baru)
+
+# Menampilkan hasil
+if prediksi[0] == 0:
+    print("Hasil Prediksi: Apel")
+else:
+    print("Hasil Prediksi: Jeruk")
+```
+
+### Penjelasan Kode
+
+*   **Features**: Adalah atribut atau ciri-ciri dari data. Di sini features kita adalah berat dan tekstur.
+*   **Labels**: Adalah jawaban atau klasifikasi yang benar.
+*   **fit()**: Ini adalah proses "belajar". Model mencari hubungan matematis antara berat/tekstur dengan jenis buah.
+*   **predict()**: Setelah belajar, model diuji dengan data baru yang belum pernah dilihat sebelumnya.
+
+## Apa Selanjutnya?
+
+Selamat! Anda baru saja membuat model Machine Learning pertama Anda. Dunia ML sangat luas, berikut adalah roadmap belajar yang disarankan:
+
+1.  **Data Manipulation**: Pelajari library **Pandas** untuk mengolah data tabel (CSV, Excel).
+2.  **Data Visualization**: Pelajari **Matplotlib** atau **Seaborn** untuk membuat grafik dari data.
+3.  **Algoritma Lain**: Pelajari algoritma lain di Scikit-Learn seperti *Linear Regression*, *K-Nearest Neighbors (KNN)*, dan *Support Vector Machine (SVM)*.
+4.  **Deep Learning**: Jika sudah mahir, lanjut ke **TensorFlow** atau **PyTorch** untuk membuat Neural Network.