Tugas Modularisasi, Fungsi, Rekursi, dan Penanganan Kesalahan

Tugas Praktik Pertemuan 10 KKA Kelas XI: Modularisasi, Fungsi, Rekursi, dan Penanganan Kesalahan
KKA Kelas XI Pertemuan 10 Bab 3 Tugas Praktik

Tugas Praktik Pertemuan 10: Modularisasi, Fungsi, Rekursi, dan Penanganan Kesalahan

Pada tugas praktik ini, kamu akan bertindak sebagai junior programmer yang diminta membuat dan memperbaiki sebuah program sederhana.

Kamu tidak hanya diminta menulis kode sampai program bisa berjalan. Kamu juga harus menunjukkan bahwa programmu dapat dibagi menjadi beberapa fungsi, memiliki input dan output yang jelas, menangani kesalahan, diuji menggunakan beberapa skenario, diperbaiki ketika ditemukan masalah, dan didokumentasikan.

1. Dasar Tugas Praktik

Tugas ini disusun berdasarkan materi Pertemuan 10 pada Bab 3 - Algoritma Pemrograman Tingkat Lanjut.

Fokus materi Pertemuan 10 adalah:

  • Parameter
  • Return value
  • Scope
  • Dekomposisi atau modularisasi
  • Rekursi terbatas
  • Exception/error handling
  • Kontrak fungsi
Catatan:

Tugas ini dirancang sebagai tugas praktik, sehingga bukti utama yang dikumpulkan bukan hanya jawaban teori, tetapi berupa program, hasil pengujian, dokumentasi kesalahan, perbaikan, dan refleksi.

2. Judul Tugas

Membuat Program Transaksi Sederhana dengan Modularisasi, Fungsi, Validasi, Rekursi, dan Error Handling

Jenis: Praktik pemrograman

Bahasa pemrograman: Python

Bentuk kerja: Individu atau berpasangan sesuai arahan guru.

Produk akhir: Program yang dapat dijalankan + dokumentasi pengujian + laporan singkat.

3. Skenario Dunia Kerja

Bayangkan kamu bekerja sebagai junior programmer pada sebuah perusahaan pengembang aplikasi.

Tim developer sedang membuat program sederhana untuk membantu toko mencatat transaksi.

Programmer sebelumnya membuat kode dalam satu blok panjang. Kode tersebut sulit diperbaiki karena semua proses bercampur menjadi satu.

Kamu mendapat tugas untuk melakukan perbaikan struktur program sehingga setiap proses mempunyai fungsi yang jelas.

Selain itu, program harus mampu menangani input yang tidak valid dan harus diuji sebelum diserahkan kepada pengguna.

Tugas utama kamu:

Buat sebuah program transaksi sederhana yang menerapkan konsep modularisasi, fungsi, parameter, return value, scope, rekursi terbatas, dan exception/error handling.

4. Tujuan Praktik

Setelah menyelesaikan praktik ini, siswa diharapkan mampu:

  1. Memecah masalah program menjadi beberapa bagian.
  2. Membuat fungsi dengan tugas yang jelas.
  3. Menggunakan parameter dalam fungsi.
  4. Menggunakan return value untuk mengembalikan hasil.
  5. Memahami penggunaan scope variabel.
  6. Menerapkan rekursi sederhana dengan kondisi berhenti.
  7. Menangani kesalahan menggunakan exception handling.
  8. Membuat program yang dapat diuji.
  9. Menemukan kesalahan melalui pengujian.
  10. Melakukan perbaikan berdasarkan hasil pengujian.
  11. Mendokumentasikan proses dan hasil pekerjaan.

5. Ketentuan Program

Program yang kamu buat minimal harus memiliki fitur berikut:

No. Fitur Ketentuan
1 Input produk Program menerima nama produk.
2 Input harga Program menerima harga produk.
3 Input jumlah Program menerima jumlah produk.
4 Subtotal Dihitung menggunakan fungsi.
5 Diskon Dihitung menggunakan fungsi.
6 Total Dihitung menggunakan fungsi.
7 Validasi Input tidak valid harus ditangani.
8 Modularisasi Program minimal memiliki 4 fungsi.
9 Rekursi Gunakan satu fungsi rekursif sederhana dengan kondisi berhenti.
10 Pengujian Minimal 3 skenario pengujian.

6. Tahap 1: Orientasi Masalah

Sebelum menulis kode, pahami terlebih dahulu masalah yang akan diselesaikan.

Tuliskan:

  1. Apa masalah yang harus diselesaikan?
  2. Siapa pengguna program?
  3. Data apa yang harus dimasukkan?
  4. Informasi apa yang harus dihasilkan?
  5. Apa batasan program?

Jawaban siswa

Tuliskan jawabanmu sendiri berdasarkan kasus yang diberikan.

Jangan langsung copy contoh jawaban.

Bagian ini bertujuan melihat apakah kamu memahami masalah sebelum mulai membuat program.

7. Tahap 2: Rancang Modularisasi Program

Sebelum membuat kode, tentukan fungsi apa saja yang diperlukan.

Kamu dapat menggunakan tabel berikut.

Nama Fungsi Tugas Parameter Return
................................ ................................ ................................ ................................
................................ ................................ ................................ ................................
................................ ................................ ................................ ................................
................................ ................................ ................................ ................................

8. Tahap 3: Membuat Fungsi

Buat minimal empat fungsi.

Salah satu kemungkinan struktur:

def validasi_harga(harga):
    pass


def validasi_jumlah(jumlah):
    pass


def hitung_subtotal(harga, jumlah):
    pass


def hitung_diskon(subtotal):
    pass


def hitung_total(subtotal, diskon):
    pass

Kode di atas baru merupakan kerangka. Kamu harus melengkapinya.

9. Tahap 4: Parameter dan Return Value

Pastikan fungsi yang membutuhkan data menerima parameter.

Contohnya:

def hitung_subtotal(harga, jumlah):
    return harga * jumlah

Fungsi tersebut menerima:

  • harga
  • jumlah

Kemudian mengembalikan hasil melalui return.

Tugas siswa

Buat fungsi lain yang menggunakan parameter dan return value sesuai kebutuhan programmu.

10. Tahap 5: Scope Variabel

Pastikan variabel yang hanya dibutuhkan di dalam fungsi tidak dibuat sebagai variabel global tanpa alasan.

Contoh:

def hitung_diskon(subtotal):

    diskon = 0

    if subtotal >= 500000:
        diskon = subtotal * 0.10

    return diskon

Variabel diskon digunakan di dalam fungsi tersebut.

Tugas siswa

Identifikasi minimal tiga variabel pada programmu dan jelaskan scope masing-masing.

Variabel Dibuat di mana? Scope
................ ................ ................
................ ................ ................
................ ................ ................

11. Tahap 6: Rekursi Terbatas

Tambahkan satu fungsi rekursif sederhana.

Gunakan rekursi dengan tujuan pembelajaran, bukan sekadar menambah jumlah kode.

Contoh

def jumlah_sampai(n):

    if n == 0:
        return 0

    return n + jumlah_sampai(n - 1)

Pada fungsi tersebut:

  • n == 0 merupakan kondisi berhenti atau base case.
  • jumlah_sampai(n - 1) merupakan pemanggilan fungsi terhadap masalah yang lebih kecil.

Tugas siswa

Buat satu fungsi rekursif sederhana dan jelaskan:

  1. Apa fungsi tersebut?
  2. Apa base case-nya?
  3. Bagaimana proses pemanggilannya?
  4. Apa hasil akhirnya?

12. Tahap 7: Error Handling

Program harus mampu menghadapi input yang tidak sesuai.

Gunakan try-except untuk menangani exception yang memang mungkin terjadi.

Contoh

try:

    harga = float(input("Masukkan harga: "))

except ValueError:

    print("Harga harus berupa angka.")

Tugas siswa

Programmu minimal harus menangani:

  • Input harga bukan angka.
  • Input jumlah bukan angka.
  • Harga tidak boleh kurang dari atau sama dengan nol.
  • Jumlah tidak boleh kurang dari atau sama dengan nol.

13. Tahap 8: Kontrak Fungsi

Buat dokumentasi sederhana mengenai salah satu fungsi yang kamu buat.

Jelaskan:

  • Input yang diterima.
  • Syarat input.
  • Output yang dihasilkan.
  • Kemungkinan kesalahan.

Format

Komponen Jawaban
Nama fungsi ................................
Parameter ................................
Syarat input ................................
Return value ................................
Kesalahan yang mungkin terjadi ................................

14. Tahap 9: Pengujian Program

Program yang selesai dibuat harus diuji.

Minimal lakukan tiga skenario pengujian.

Sebaiknya pengujian mencakup:

  • Kondisi normal.
  • Kondisi batas atau nilai khusus.
  • Input tidak valid.
No. Skenario/Input Hasil yang Diharapkan Hasil Aktual Status Perbaikan
1 ........................ ........................ ........................ PASS/FAIL ........................
2 ........................ ........................ ........................ PASS/FAIL ........................
3 ........................ ........................ ........................ PASS/FAIL ........................
4 ........................ ........................ ........................ PASS/FAIL ........................
Penting:

Jangan hanya menulis "program berhasil". Tunjukkan input yang diberikan, hasil yang diharapkan, hasil aktual, dan tindakan perbaikan jika terjadi kesalahan.

15. Tahap 10: Temukan dan Perbaiki Bug

Gunakan kode berikut sebagai latihan debugging.

def hitung_total(harga, jumlah):

    total = harga * jumlah


try:

    harga = int(input("Harga: "))
    jumlah = int(input("Jumlah: "))

    hasil = hitung_total(harga, jumlah)

    print("Total:", hasil)

except ValueError:

    print("Input tidak valid.")

Pertanyaan

  1. Mengapa fungsi hitung_total() belum memberikan hasil kepada pemanggil?
  2. Apa yang perlu ditambahkan?
  3. Bagaimana versi kode yang sudah diperbaiki?
  4. Buat minimal dua pengujian untuk membuktikan perbaikannya.

16. Produk yang Harus Dikumpulkan

Siswa wajib mengumpulkan:

  1. File program Python yang sudah dibuat.
  2. Screenshot program berjalan.
  3. Screenshot ketika terjadi error/input tidak valid.
  4. Tabel hasil pengujian minimal tiga skenario.
  5. Dokumentasi fungsi yang dibuat.
  6. Catatan bug dan perbaikan.
  7. Refleksi pembelajaran.

17. Contoh Jawaban / Contoh Solusi

Perhatian:

Kode berikut adalah contoh solusi. Siswa boleh membuat struktur berbeda selama memenuhi ketentuan tugas dan dapat menjelaskan keputusan teknisnya.

Contoh Program

def validasi_harga(harga):
    if harga <= 0:
        raise ValueError("Harga harus lebih dari 0")

    return harga


def validasi_jumlah(jumlah):
    if jumlah <= 0:
        raise ValueError("Jumlah harus lebih dari 0")

    return jumlah


def hitung_subtotal(harga, jumlah):
    return harga * jumlah


def hitung_diskon(subtotal):

    if subtotal >= 500000:
        return subtotal * 0.10

    return 0


def hitung_total(subtotal, diskon):
    return subtotal - diskon


def jumlah_sampai(n):

    if n == 0:
        return 0

    return n + jumlah_sampai(n - 1)


try:

    nama_produk = input("Nama produk: ")

    harga = float(input("Harga produk: "))

    jumlah = int(input("Jumlah produk: "))

    harga = validasi_harga(harga)

    jumlah = validasi_jumlah(jumlah)

    subtotal = hitung_subtotal(harga, jumlah)

    diskon = hitung_diskon(subtotal)

    total = hitung_total(subtotal, diskon)

    print()
    print("=== STRUK TRANSAKSI ===")
    print("Produk   :", nama_produk)
    print("Harga    :", harga)
    print("Jumlah   :", jumlah)
    print("Subtotal :", subtotal)
    print("Diskon   :", diskon)
    print("Total    :", total)

except ValueError as error:

    print("Transaksi gagal:", error)

18. Penjelasan Contoh Jawaban

Fungsi 1: validasi_harga()

def validasi_harga(harga):
    if harga <= 0:
        raise ValueError("Harga harus lebih dari 0")

    return harga

Fungsi menerima parameter harga. Fungsi memastikan harga lebih besar dari nol.

Jika tidak sesuai, fungsi menghasilkan ValueError.

Jika valid, nilai harga dikembalikan menggunakan return.

Fungsi 2: validasi_jumlah()

def validasi_jumlah(jumlah):
    if jumlah <= 0:
        raise ValueError("Jumlah harus lebih dari 0")

    return jumlah

Fungsi ini mempunyai tanggung jawab khusus untuk memvalidasi jumlah barang.

Fungsi 3: hitung_subtotal()

def hitung_subtotal(harga, jumlah):
    return harga * jumlah

Fungsi menerima dua parameter dan mengembalikan hasil perkalian.

Fungsi 4: hitung_diskon()

def hitung_diskon(subtotal):

    if subtotal >= 500000:
        return subtotal * 0.10

    return 0

Fungsi bertanggung jawab menentukan nilai diskon berdasarkan subtotal.

Fungsi 5: hitung_total()

def hitung_total(subtotal, diskon):
    return subtotal - diskon

Fungsi menghitung jumlah akhir yang harus dibayar.

19. Contoh Penerapan Rekursi

def jumlah_sampai(n):

    if n == 0:
        return 0

    return n + jumlah_sampai(n - 1)

Misalnya:

jumlah_sampai(5)

Prosesnya secara konseptual:

5 + jumlah_sampai(4)
4 + jumlah_sampai(3)
3 + jumlah_sampai(2)
2 + jumlah_sampai(1)
1 + jumlah_sampai(0)
0

Hasil akhirnya:

15
Hal penting:

Fungsi mempunyai base case: n == 0.

Base case diperlukan agar pemanggilan rekursif berhenti.

20. Contoh Pengujian

No. Skenario Input Hasil Diharapkan Hasil Aktual Status
1 Normal 20.000 × 3 Total 60.000 Total 60.000 PASS
2 Mendapat diskon 200.000 × 3 Subtotal 600.000 dan diskon 60.000 Subtotal 600.000 dan diskon 60.000 PASS
3 Harga negatif -10.000 × 2 Program menolak harga Program menolak harga PASS
4 Jumlah nol 20.000 × 0 Program menolak jumlah Program menolak jumlah PASS
5 Input bukan angka Harga = "dua puluh" Error ditangani Error ditangani PASS

21. Contoh Kontrak Fungsi

Komponen Contoh Jawaban
Nama fungsi hitung_subtotal()
Parameter harga dan jumlah
Syarat input Harga dan jumlah harus bernilai positif.
Return value Hasil harga dikalikan jumlah.
Tujuan Menghitung subtotal transaksi.

22. Contoh Bug dan Perbaikannya

Kode bermasalah

def hitung_total(harga, jumlah):

    total = harga * jumlah

Masalahnya adalah fungsi menghitung nilai total, tetapi tidak mengembalikannya kepada pemanggil.

Kode diperbaiki

def hitung_total(harga, jumlah):

    total = harga * jumlah

    return total

Sekarang nilai total dapat diterima oleh kode yang memanggil fungsi.

Contoh penggunaan

hasil = hitung_total(20000, 3)

print(hasil)

Hasil:

60000

23. Refleksi Siswa

Setelah menyelesaikan praktik, tuliskan refleksi sebanyak 150–200 kata.

Jawab pertanyaan berikut:

  1. Apa konsep yang paling kamu pahami dari praktik ini?
  2. Apa bukti bahwa programmu benar-benar sudah diuji?
  3. Kesalahan apa yang kamu temukan?
  4. Bagaimana cara kamu memperbaikinya?
  5. Apa manfaat modularisasi dalam pekerjaan programmer?
  6. Apa manfaat error handling bagi pengguna aplikasi?
  7. Apa yang masih ingin kamu perbaiki dari programmu?

Contoh Jawaban Refleksi

Setelah mengerjakan praktik ini, saya memahami bahwa program sebaiknya tidak dibuat dalam satu blok kode yang panjang. Program dapat dibagi menjadi beberapa fungsi sehingga setiap fungsi mempunyai tugas tertentu. Saya juga memahami penggunaan parameter dan return value karena hasil dari satu fungsi dapat digunakan kembali oleh bagian program lain.

Saat melakukan pengujian, saya menemukan bahwa input berupa teks pada bagian harga menyebabkan program mengalami error. Saya kemudian menggunakan exception handling agar program dapat memberikan pesan kesalahan kepada pengguna. Saya juga mencoba rekursi sederhana dan memahami bahwa rekursi membutuhkan kondisi berhenti agar tidak berjalan terus-menerus.

Dari praktik ini saya memahami bahwa pekerjaan programmer bukan hanya membuat program berjalan, tetapi juga menguji, menemukan kesalahan, memperbaiki, dan mendokumentasikan hasilnya.

Catatan untuk siswa:

Contoh refleksi di atas hanya sebagai contoh. Refleksi yang dikumpulkan harus menggambarkan pengalaman dan proses pekerjaanmu sendiri.

24. Checklist Sebelum Mengumpulkan

  • ☐ Program dapat dijalankan.
  • ☐ Program memiliki minimal 4 fungsi.
  • ☐ Fungsi menggunakan parameter.
  • ☐ Fungsi menggunakan return value jika diperlukan.
  • ☐ Scope variabel dapat dijelaskan.
  • ☐ Terdapat fungsi rekursif.
  • ☐ Rekursi memiliki base case.
  • ☐ Terdapat validasi input.
  • ☐ Terdapat exception/error handling.
  • ☐ Terdapat kontrak atau dokumentasi fungsi.
  • ☐ Program diuji minimal 3 skenario.
  • ☐ Hasil aktual dicatat.
  • ☐ Kesalahan diperbaiki.
  • ☐ Screenshot hasil program tersedia.
  • ☐ Screenshot error/input tidak valid tersedia.
  • ☐ Refleksi 150–200 kata sudah dibuat.

25. Rubrik Penilaian Praktik

Penilaian berikut mengikuti pembagian asesmen pada Pertemuan 10 dalam modul, yaitu pengetahuan, keterampilan, sikap kerja, dan refleksi.

Komponen Aspek yang Dinilai Skor Maksimal
Pengetahuan Pemahaman parameter, return value, scope, modularisasi, rekursi, error handling, dan kontrak fungsi. 20
Keterampilan Fungsi, ketepatan program, pengujian, dokumentasi, debugging, dan revisi. 50
Sikap Kerja Kemandirian, kolaborasi, keamanan, etika, ketekunan, dan komunikasi. 15
Refleksi Kedalaman bukti, analisis kesalahan, transfer pembelajaran, dan rencana perbaikan. 15
Total 100

26. Tantangan Pengayaan

Jika tugas utama sudah selesai, kembangkan program dengan beberapa fitur tambahan.

  1. Tambahkan lebih dari satu produk dalam satu transaksi.
  2. Buat fungsi untuk menghitung total seluruh produk.
  3. Tambahkan kategori diskon.
  4. Tambahkan validasi nama produk agar tidak kosong.
  5. Tambahkan menu transaksi.
  6. Buat pengujian tambahan untuk kondisi batas.
  7. Buat dokumentasi program yang lebih lengkap.
Jangan menambahkan fitur dengan mengorbankan kualitas kode.

Program sederhana tetapi terstruktur, dapat diuji, dan dapat dijelaskan lebih baik daripada program besar yang tidak dapat dipahami pembuatnya sendiri.

27. Kesimpulan Tugas Praktik

Tugas Pertemuan 10 bukan sekadar tugas mengetik kode. Siswa dilatih mengikuti alur kerja pemrograman yang lebih nyata:

Masalah
   ↓
Memahami kebutuhan
   ↓
Memecah masalah
   ↓
Merancang fungsi/modul
   ↓
Membuat kode
   ↓
Validasi
   ↓
Error handling
   ↓
Pengujian
   ↓
Menemukan bug
   ↓
Memperbaiki
   ↓
Menguji kembali
   ↓
Mendokumentasikan
   ↓
Refleksi

Dengan demikian, keberhasilan tugas tidak hanya dilihat dari apakah program menghasilkan output, tetapi juga dari proses bagaimana program dirancang, diuji, diperbaiki, dan dijelaskan.

28. Referensi Dasar Tugas

Tugas praktik ini terutama mengacu pada Modul Ajar Pembelajaran Mendalam Koding dan Kecerdasan Artifisial (KKA) Kelas XI Semester 1, khususnya Pertemuan 10 Semester 1 - Modularisasi, Fungsi, Rekursi, dan Penanganan Kesalahan.

Bagian Pertemuan 10 pada modul menetapkan materi esensial berupa parameter, return value, scope, dekomposisi modul, rekursi terbatas, exception/error handling, dan kontrak fungsi. Modul juga menetapkan bahwa siswa menerapkan konsep tersebut pada kasus kontekstual, menghasilkan artefak yang dapat diuji, menemukan kesalahan, melakukan perbaikan, serta melakukan refleksi.

Prosedur praktik juga diselaraskan dengan LKPD pada modul: orientasi, investigasi, desain, implementasi, pengujian dan revisi, kemudian refleksi. Modul menetapkan minimal tiga skenario pengujian serta bukti berupa tabel pengujian dan versi revisi.

KKA Kelas XI - Pertemuan 10

Bab 3: Algoritma Pemrograman Tingkat Lanjut

Fokus: Modularisasi, Fungsi, Rekursi, dan Penanganan Kesalahan

Artikel/tugas ini disusun berdasarkan materi dan struktur praktik pada Modul Ajar KKA Kelas XI yang diberikan.

Post a Comment

0 Comments