MEMBANGUN MODUL PROGRAM YANG EFEKTIF

PENDAHULUAN

Manusia bila menghadapi permasalahan yang (cukup) besar langkah awal yang dilakukan adalah
membagi/memecah permasalahan tersebut menjadi beberapa bagian yang lebih kecil. Selanjutnya
menyelesaikan secara bertahap bagian demi bagian, baik secara sendiri maupun berkelompok,
sehingga diperoleh solusi dari permasalahan yang besar tersebut. Sebagai gambaran, kita diminta
untuk “menyelesaikan” (baca: memakan) buah semangka sampai habis. Langkah awal yang
dilakukan adalah “mempartisi” (memotong) buah semangka menjadi beberapa bagian dan
memakannya satu persatu, sendiri atau bersama-sama.

Dalam lingkup pengembangan perangkat lunak (program) analogi di atas harus dipakai, apabila
akan menghasilkan perangkat lunak yang baik. Program yang besar harus dipartisi menjadi
beberapa modul yang mudah diselesaikan. Modul program dapat berupa prosedur dan/atau
fungsi.

Untuk mempartisi program menjadi beberapa bagian terdapat dua paradigma pokok, yaitu
Structured Programming (SP) dan Object Oriented Programming (OOP). SP mempartisi program
berdasarkan kata kerja (fungsi sistem) atau behavior sedangkan OOP mempartisi program
berdasarkan kata benda (objek diskrit). Dalam SP, struktur data dan behavior terpisah, di sisi lain
OOP mengenkapsulasi struktur data dan behavior dalam satu objek.

Dalam tulisan ini akan diuraikan sekilas tentang perancangan modul yang baik untuk SP, karena
hal ini merupakan modal utama—kalau tidak dikatakan mutlak—untuk menuju ke OOP.

MENGUKUR MODUL PROGRAM YANG BAIK

Reusable adalah kunci pokok dalam pengembangan perangkat lunak, tema inilah yang mengilhami
perancangan modul program dan perkembangan paradigma pengembangan perangkat lunak secara
umum. Reusable bisa diperoleh bila menerapkan information hiding.

Yang dimaksud Information hiding adalah: [Presman 2000]

• Setiap modul tersembunyi dengan yang lain
• Modul harus dirancang agar informasi (prosedur dan data) yang berada di dalam modul tidak
dapat diakses oleh oleh modul lain yang tidak memerlukan informasi tersebut.

Keuntungan modul yang efektif

• Mengurangi kompleksitas
• Mempermudah perubahan
• Lebih mudah diimplementasikan dan dapat dikerjakan secara paralel (Tim)

Membangun Modul Program yang Efektif halaman 1 dari 3 halaman

Dua Mekanisme pengaktifan modul:
• Diinvokasi by refference (statemen call)
• Dinvokasi oleh interupsi (banyak untuk sistem real-time)

Functional Independence merupakan kunci perancangan yang baik dan kunci kualitas program.
• Merupakan hasil pertumbuhan langsung konsep abstraksi dan information hiding.
• Memiliki subfungsi yang spesifik dan antarmuka yang sederhana apabila dipandang dari bagian
lain dalam struktur program.
• Keuntungan Modul yang independen:
o mudah membagi dalam tim,
o mudah diubah,
o perambatan kesalahan berkurang, dan
o reusable bertambah.

Independensi diukur dengan dengan dua kriteria kualitattif, yaitu Cohesion dan Coupling.
• COHESION: mengukur kekuatan funmgsional relatif suatu modul.
• COUPLING: mengukur interdependensi relatif antar modul

Ciri Modul yang baik:

• High cohesion (functional cohesion): modul hanya melakukan satu tugas dan memerlukan
sedikit interaksi dengan modul lain dalam satu program.
• Low coupling: modul memiliki kopling antar modul yang lemah atau sebebas mungkin dengan
modul yang lain (independen). Kopling tergantung pada kompleksitas antarmuka modul.

STUDI KASUS

Pada halaman berikut diberikan contoh kasus penyelesaian program secara modular. Pada kolom
sebelah kiri, program sudah terdiri dari beberapa modul tetapi masih memiliki kopling tinggi.
Kolom sebelah kanan merupakan hasil perbaikan yang menunjukkan kopling rendah. Kohesi tidak
begitu tampak dalam kasus ini.

KESIMPULAN

Dalam menyusun program tidak sekedar memecah program menjadi beberapa modul, tetapi harus
memperhatikan bagaimana kualitas modul tersebut. Modul yang baik adalah reusable, reusable
dalam program yang sama maupun reusable untuk program yang lain.

Membangun Modul Program yang Efektif halaman 2 dari 3 halaman

 PROGRAM TIDAK BAIK PROGRAM LEBIH BAIK

Program Contoh; Program Contoh;

Uses crt; Uses crt;

Procedure buat_garis (x: byte, y: char); Procedure buat_garis (x: byte, y: char);
Begin Var i: byte;
for i : = 1 to x do Begin
write (y); for i : = 1 to x do
writeln; write (y);
End; writeln;
End; {end procedure buat_garis }

Procedure pangkat_tiga (x: integer); Function pangkat_tiga (x: integer): integer;

Var z: integer; Var z: integer;
Begin Begin
z := x * x * x; z := x * x * x;
writeln (’Hasil 1 = ‚’, z); Pangkat_tiga := z;
buat_garis (10,'='); End; {end function pangkat_tiga }
End;

Function proses(x, y, z: integer): integer; Function proses(x, y, z: integer): integer;

Var s: integer; Var s: integer;
Begin Begin
s := x + y - z; s := x + y - z;
Proses := s; Proses := s;
End; End;

Function hitung_loop(x, y: integer): integer; Function hitung_loop(x, y: integer): integer;

Begin Var i: byte;
for i := 1 to x do Begin
y := y - i; for i := 1 to x do
Hitung_loop := y; y := y - i;
End; Hitung_loop := y;
End; {end function hitung_loop }

Procedure tampilkan_hasil( y: integer); Procedure tampilkan_hasil( x, y: integer);

Begin Begin
Writeln (‘Hasil 2 = ‘, y); Writeln (‘Hasil 1 = ‘, x);
buat_garis(20,'*'); buat_garis(20,'=');
End; Writeln (‘Hasil 2 = ‘, y);
buat_garis(20,'*');
End; {end procedure tampilkan hasil }

Var i: byte; Var

j, a, b, c: integer; j, k, a, b, c: integer;

Begin Begin {program utama}

a := 5; b := 20; c := 10; a := 5; b := 20; c := 10;
b := hitung_loop(a,b); b := hitung_loop(a,b);
pangkat_tiga (b); k = pangkat_tiga (b);
j = proses(a,b,c); j = proses(a,b,c);
tampilkan_hasil(j); tampilkan_hasil(k,j);
End. End. {program utama}

Membangun Modul Program yang Efektif halaman 3 dari 3 halaman