Chapter 2 Procedure. Perjalanan dari rumah menuju ke supermarket :

(1)

2.1 Pengantar

Dalam usaha untuk menyelesaikan suatu tujuan, dapat dilakukan dengan melakukannya secara bertahap, disertai “tujuan kecil” dari masing-masing tahap. Misalnya, proses melakukan perjalanan dari rumah ke kampus yang dijadikan contoh pada chapter 1, telah dijabarkan menjadi beberapa aksi kecil dengan tujuan masing-masing.

Perjalanan dari rumah menuju ke kampus : Berjalan menuju halte (1)

Naik kendaraan umum (2)

Turun di depan kampus (3)

Berjalan menuju ruangan kuliah (4)

Program 2.1

Dengan menjabarkan usaha pencapaian suatu tujuan (program) ke dalam tahap-tahap yang lebih spesifik dan detil, maka aksi yang dilakukan untuk mencapai tujuan tersebut dapat dilakukan dengan lebih terarah dan teratur. Pada program 2.1, tahap (1),(2),(3) dan (4) dapat dikatakan sebagai tahap-tahap yang harus dilakukan untuk menyelesaikan tujuan utama program tersebut.

Salah satu keuntungan dari penggunaan tahap-tahap dalam program adalah bahwa tahap yang sama dapat digunakan lagi pada program yang lain dengan tujuan yang lain.

Perjalanan dari rumah menuju ke supermarket : Berjalan menuju halte (1)

Naik kendaraan umum (2)

Turun di depan supermarket (5)

Berjalan menuju supermarket (6)

Program 2.2

Pada program 2.2, tahap (1) dan (2) adalah tahap yang sama dengan dengan tahap (1) dan (2) pada program 2.1. Tahap yang berbeda pada program 2.2 dari program 2.1 adalah tahap (5) dan (6) yang disesuaikan dengan tujuan utama dari program 2.2. Dengan demikian, tahap (1) dan (2) tidak perlu lagi dijabarkan pada program 2.2 karena bisa menggunakan tahap (1) dan (2) yang sudah dijabarkan pada program 2.1.

Pada bahasa pemrograman, setiap tahap tersebut dapat dituliskan ke dalam procedure (prosedur).

2.2 Procedure pada Program

Contoh tampilan yang ingin dibuat :

Gambar 2.1

*** *** ***

(2)

Dengan menggunakan sequence :

NL;print*;print*;print*; NL;print*;print*;print*; NL;print*;print*;print*

Program 2.3 Salah satu tahap pada program 2.3 :

NL;print*;print*;print* Program 2.4

Dengan memanfaatkan program 2.4, program 2.3 dapat ditulis : program 2.4; program 2.4 ; program 2.4

Program 2.5

Program 2.4 digunakan pada program 2.5, sebagai suatu procedure. Program 2.5 secara keseluruhan terdiri dari procedure definition (program 2.4) dan teks yang berisi perintah pemanggilan procedure tersebut.

2.3 Procedure sebagai Instruksi Baru NL;print*;printspace; printspace;printpace;print* Program 2.6 NL;print*;print*;print*;print*;print* Program 2.7 program 2.6;program 2.6;

program 2.6;program 2.6;program 2.7 Program 2.8

program 2.6;program 2.6;

program 2.7;program 2.6;

Program 2.6 dan program 2.7 merupakan procedure dengan isi yang berbeda-beda. Kedua procedure tersebut dipanggil berkali-kali pada program 2.8, program 2.9, dan program 2.10 untuk tujuan yang berbeda-beda seperti pada gambar 2.8, gambar 2.9 dan gambar 2.10.

Gambar 2.2. Hasil program 2.8

* * * * * * * * *****

(3)

Gambar 2.3. Hasil Program 2.9

Gambar 2.4. Hasil Program 2.10

Suatu program yang melakukan pemanggilan procedure, dapat dituliskan pada program lain sebagai procedure.

program 2.8;NL;program 2.9 Program 2.11

Gambar 2.5. Hasil Program 2.11 2.4 Dependency Graph

Setiap program memiliki hubungan dengan setiap perintah yang digunakan. Jika ada procedure yang dipanggil oleh program tersebut, maka program juga memiliki relasi dengan procedure itu. Relasi (hubungan) yang ada di dalam suatu program dapat digambarkan dengan dependency diagram yang menunjukkan relasi antara program, procedure dan instruksi yang ada.

Gambar 2.6 Dependency Graph dari program 2.5 Program 2.5 Program 2.4 NL print* * * * * ***** * * * * ***** * * ***** * * ***** * * * * * * * * ***** * * * * ***** * * * *

(4)

Gambar 2.7. Dependency Graph dari program 2.11. 2.5 Execution Diagram

Saat sebuah program dieksekusi, pemanggilan procedure dan instruksi tidak dapat digambarkan hanya dengan menggunakan dependency graph. Untuk itu digunakan execution diagram yang menggambarkan relasi antar instruksi, procedure dan instruksi external yang ada pada program.

Gambar 2.8. Execution Diagram dari Program 2.9. 2.6 Notasi Definisi Procedure dan Pemanggilan Procedure

Dalam menuliskan program, setiap perintah harus dituliskan sejelas dan sedetil mungkin agar dapat dimengerti dan dilaksanakan. Sebagai contoh, sebuah program dengan perintah

tidur matono

yang tidak didefinisikan secara jelas bagaimana caranya melaksanakan perintah tersebut. Akibatnya program tidak dapat dilaksanakan dengan baik. Jika dituliskan dengan lebih spesifik :

Program 2.11 Program 2.8 Program 2.9 NL Program 2.6 Program 2.7 print* printspace Program 2.6 Program 2.6 Program 2.7 Program 2.6 Program 2.6 Program 2.9 print* printspace printspaceprintspace print* NL NL NL print* print* print* printspace

printspace printspaceprintspace

printspace printspace printspace printspace print* print* print* printspace NL print*

print* print*print* print* NL

(5)

matono adalah posisi terbalik atau tertelungkup tidur matono

Dengan definisi lengkap maka suatu program dipastikan dapat dieksekusi dengan baik. Perintah tidur tidak perlu didefisikan karena diasumsikan sebagai perntah umum yang sudah pasti dipahami oleh semua orang. Definisi dilakukan pada procedure baru yang diciptakan yang belum ada dan belum dimengerti.

Notasi yang digunakan untuk melakukan definisi suatu procedure adalah :

def <nama procedure>() = <perintah-perintah> enddef Contoh definisi procedure untuk mencetak 3 buah bintang adalah :

def tigabintang() = print*;print*;print*; enddef

Contoh program lengkap yang melakukan definisi dan pemanggilan procedure : def tigabintang() = print*;print*;print* enddef tigabintang();tigabingtang();tigabintang() Program 2.12

Definisi suatu program harus dilakukan dengan lengkap. Contoh program yang memiliki definisi procedure yang tidak lengkap :

def H() = t1();t1();t2();t1();t1() enddef def O() = t2();t1();t1();t1();t2() enddef O();NL;h()

Program 2.14

Pada program 2.14 dituliskan pemanggilan procedure t1() dan t2() pada definisi procedure O() dan H(). Perintah t1() dan t2() tidak akan dimengerti karena tidak didefinisikan (ingat, perintah yang ada hanya print*,printspace dan NL). Jika dituliskan dengan lengkap maka program 2.14 akan menjadi seperti program 2.15.

def H() = t1();t1();t2();t1();t1() enddef def O() = t2();t1();t1();t1();t2() enddef def t1() = NL;print*;printspace; printspace;printspace;print* enddef def t2() = NL;print*;print*;print*; print*;print* enddef O();NL;H() Program 2.15

(6)

2.7 Nested Definition (Definisi di dalam Definisi)

Definisi suatu procedure dapat juga dituliskan di dalam definisi procedure yang lain. Contohnya dapat dilihat pada program 2.16 yang merupakan modifikasi dari program 2.15.

def bentuk1() =

def H() = t1();t1();t2();t1();t1() enddef def O() = t2();t1();t1();t1();t2() enddef def t1() = NL;print*;printspace; printspace;printspace;print* enddef def t2() = NL;print*;print*;print*; print*;print* enddef O();NL;H(); enddef bentuk1();NL;bentuk1() Program 2.16

Pada program 2.16, procedure H(),O(),t1() dan t2() dituliskan sebagai bagian dari procedure bentuk1(). Jika dituliskan secara berurutan maka program 2.16 akan seperti program 2.17

def H() = t1();t1();t2();t1();t1() enddef def O() = t2();t1();t1();t1();t2() enddef def t1() = NL;print*;printspace; printspace;printspace;print* enddef def t2() = NL;print*;print*;print*; print*;print* enddef def bentuk1() = O();NL;H(); enddef bentuk1();NL;bentuk1() Program 2.17

Dengan execution diagram dapat dibuktikan apakah program 2.16 dan program 2.17 identik atau tidak.

2.8 Nama Procedure dan Konsistensi

Suatu procedure dapat diganti namanya, misalnya dengan alasan karena nama procedure tersebut sudah tidak sesuai dengan isi dari procedure. Misalnya :

(7)

def duabintang()=

NL;print*;print*;print* enddef

duabintang();duabintang();duabintang() Program 2.18

Sekalipun nama procedure pada program 2.18 adalah duabintang() namun pada kenyataannya hasil dari eksekusi procedure tersebut akan menampilkan 3 bintang sehingga hasil dari eksekusi program 2.18 akan menghasilkan 3 baris bintang, yang terdiri dari 3 bintang pada tiap barisnya. Yang menjadi makna dari suatu procedure adalah isi dari procedure, bukan nama dari procedure tersebut. Untuk menyesuaikan isi dan nama dari procedure yang ada pada program 2.18 maka dilakukan perubahan seperti pada program 2.19.

def duabintang()=

NL;print*;print*;print* enddef

tigabintang();tigabintang();tigabintang() Program 2.18

Program 2.18 dapat dikatakan tidak konsisten dan tidak menuliskan semua definisi secara lengkap. Pemanggilan procedure tigabintang() akan menjadi instruksi yang tidak dimengeri karena tigabintang() tidak didefinisikan di dalam program. Program dapat dilengkapi seperti program 2.19.

def duabintang()= NL;print*;print* enddef

def tigabintang() = NL;print*;print*;print*; enddef

Program 2.19 sudah merupakan program yang konsisten, namun definisi procedure duabintang()merupakan definisi yang tidak dibutuhkan dan berlebihan karena tidak pernah digunakan pada program. Hal ini tidak efisien dalam dunia pemrograman.

def tigabintang()= NL;print*;print* enddef

Dengan melihat program 2.20, perubahan kecil dilakukan dengan memberi nama yang sama pada kedua procedure yang sama. Hal ini justru membuat program menjadi sangat tidak konsisten karena akan terjadi kekacauan saat pemanggilan tigabintang(). Procedure mana yang akan dieksekusi? Program 2.20 tetap merupakan program yang tidak konsisten.

(8)

def tigabintang()= NL;print*;print*;print*; enddef

tigabintang();tigabintang();tigabintang(); Program 2.21

Maksud perubahan pada program 2.21 adalah untuk menyamakan hasil pada kedua definisi procedure yang ada. Hal ini tetap merupakan bentuk program yang tidak konsisten karena dilakukan definisi dari satu procedure yang sama berulang kali. Sekalipun salah satu procedure diubah menjadi bentuk yang berbeda dan tetap memberikan hasil yang sama, yang sesuai dengan namanya, seperti pada program 2.22, hal ini pun tidak konsisten.

def duabintang() = print*;print* enddef

def tigabintang()= NL;print*;duabintang() enddef

tigabintang();tigabintang();tigabintang(); Program 2.21

Perintah apa pun yang diinstruksikan pada komputer akan dijalankan apa adanya. Pemberian nama suatu procedure tidak diperhatikan. Nama apapun yang diberikan pada procedure tidak dipermasalahkan oleh bahasa pemrograman sekalipun secara manusiawi, nama procedure bertentangan dengan isinya. Penulisan definisi procedure yang berlebihan juga tidak akan menyebabkan terjadinya kesalahan. Namun dalam pemrograman, penulisan program yang baik adalah penulisan program yang efisien, yang tidak menggunakan definisi dan instruksi yang sebenarnya tidak diperlukan. Penulisan program juga harus jelas dan dengan mudah dapat dijabarkan jalannya program.

2.9 Substitusi

Pemanggilan suatu procedure akan mengakibatkan dieksekusinya instruksi yang ada di dalam procedure tersebut. Dengan demikian dapat dijabarkan bahwa :

Instruksi pemanggilan

procedure

dapat

diganti dengan isi dari

procedure

.

Dengan substitusi seperti itu, hasil dari program akan sama dan tidak berubah. Contoh substitusi seperti ini dapat dilihat pada progam 2.22 yang diubah menjadi program 2.23

def tigabintang() = NL;print*;print*;print* enddef

(9)

def tigabintang() = NL;print*;print*;print* enddef

NL;print*;print*;print*; NL;print*;print*;print*; NL;print*;print*;print*

Program 2.23

Definisi procedure tigabintang() tidak pernah dipanggil pada program 2.23.

Definisi yang tidak pernah digunakan pada

program dapat dihapus.

Sehingga program 2.23 dapat ditulis seperti pada program 2.24 NL;print*;print*;print*;

NL;print*;print*;print*; NL;print*;print*;print*

Program 2.23

Pada dasarnya, cara penulisan istruksi tidak memengaruhi hasil dari eksekusi program tersebut. Program 2.23 dapat ditulis dengan berbagai macam cara namun tidak mengubah hasilnya.

NL;print*;print*; print*;NL;print*; print*;print*;NL; print*;print*;print* atau NL;print*;print*;print*;NL; print*;print*;print*;NL; print*;print*;print* atau NL;print*;print*;print*;NL;print*;print*; print*;NL;print*;print*;print* atau NL;print*; print*;print*; NL;print*; print*;print*; NL;print*; print*;print*

(10)

2.10 Tanda Kurung dan Definisi

Ada kemungkinan dimana pada proses substitusi dibutuhkan penambahan tanda kurung. Misalnya untuk rumus x=4+3 dan y=2x, proses substitusi tidak dituliskan menjadi y=24+3 atau pun y=2*4+3. Yang harus dituliskan adalah y=2(4+3) sehingga nilai y=14, bukan y=27 maupun y=11. Konsep yang sama juga diterapkan pada proses substitusi pada program.

def p() =

def q() = print*;print* enddef

NL;q();print* enddef

p();p();p()

Program 2.23

Dengan menggunakan substitusi, setiap pemanggilan p() akan diganti oleh isi dari procedure p() itu sendiri. Tanda « dan » digunakan untuk membatasi penulisan substitusi.

«def q()= print*;print* enddef NL;q();print*»; «def q()= print*;print* enddef NL;q();print*»; «def q()= print*;print* enddef NL;q();print*»

Program 2.24

Pada program 2.24 tidak terjadi inkonsistensi karena definisi q() dituliskan beberapa kali tersebut terjadi dalam sub-program yang berbeda-beda. Setiap sub-program tidak memiliki hubungan dengan sub-program yang lainnya, yang berada diluar tanda « dan ». Substitusi jika dilanjutkan pada penggantian pemanggilan q() dengan isi dari q() maka program 2.24 dapat dituliskan seperti pada program 2.25.

« NL;print;print*;print* »; « NL;print;print*;print* »; « NL;print;print*;print* »

Program 2.25 2.10 Environment Diagram

Hampir dalam setiap sistem pemrograman, terdapat hal yang disebut dengan execution dan environment. Execution adalah proses saat suatu program dan instruksi di dalamnya dijalankan sesuai dengan yang tertulis pada program tersebut. Environment adalah daftar definisi dan arti dari masing-masing definisi yang teratur sehingga dapat diketahui makna dari setiap definisi. Untuk lebih jelasnya dapat diperhatikan program 2.26 dan gambar 2.9

(11)

def f()= NL;print*;print* enddef f();f();f()

Program 2.26

Environment diagram akan menunjukkan cara execution dilakukan berhubungan dengan execution dari procedure yang ada di dalam program. Diagram juga menggambarkan sequence dari instruksi-instruksi dan procedure-procedure yang ada.

Gambar 2.9 Environment Diagram

Execution dari program 2.26 dapat dijabarkan sebagai berikut :

Pertama, execution dimulai dan digambarkan dengan kotak besar pada diagram.

Kedua, execution dari definition yang ada pada program 2.26 akan menciptakan environment baru yang menggambarkan instruksi dasar yang digunakan serta arti dari nama f.

Ketiga, instruks yang akan pada program mulai dilaksanakan, dimulai dari pemanggilan f(). Nama f tidak selalu memiliki arti, namun pada environment yang ini, f memiliki arti. Dalam hal ini, f adalah suatu procedure.

Keempat, execution diciptakan (kotak sebelah kanan atas). Execution dilanjutkan dengan mengikuti instruksi yang ada di dalam procedure f.

Kelima, execution NL yang ada di dalam procedure. Keenam dan ketujuh, execution instruksi print*

Menciptakan environment baru yang memiliki definisi dari instruksi dasar dan nama f, yang diartikan sebagai procedure dengan isi NL;print*;print*.

Execute f() Execute NL Execute print* Execute print* Execute f() Execute f() newline * * Execute NL Execute print* Execute print* Execute NL Execute print* Execute print* newline * * newline * * Execution program 2.26 pada environment

(12)

Kedelapan, procedure selesai dan hilang, begitu juga dengan execution yang menciptakan procedure ini.

Kesembilan, execution dari pemanggila f yang kedua kalinya. Proses yang sama dilakukan seperti pada langkah keempat.

Proses tersebut berlangsung sampai pemanggilan F yang ketigakalinya selesai dan diakhiri dengan berhentinya proses execution dari program 2.26.

2.10 Perencanaam Program dengan Procedure

Misalnya akan dirancang suatu program yang memiliki hasil eksekusi seperti gambar 2.10.

Gambar 2.10

Dari bentuk pada gambar 2.10, dapat dituliskan secara berurutan perintah yang digunakan pada program :

NL;p*;p*;p*;p*;p*;p*;p*;p*;p*;p*; NL;p*;p*;p*;p*;p*;p*;p*;p*;p*;p*; NL;p*;p*;ps;ps;ps;ps;ps;ps;p*;p*; NL;p*;p*;ps;ps;ps;ps;ps;ps;p*;p*; NL;p*;p*;p*;p*;p*;p*;p*;p*;p*;p*; NL;p*;p*;p*;p*;p*;p*;p*;p*;p*;p*; Program 2.26

Pada program 2.26, print* ditulis p*, sedangkan printspace ditulis ps, hanya agar 1 baris tampilan dapat dituliskan instruksinya pada 1 baris juga. Dengan demikian program dapat ditulis dengan rapi dan mudah dipahami.

Dengan melakukan analisa pada gambar hasil program dapat dilihat bahwa secara garis besar ada 2 tipe instruksi yang bisa digunakan. Instruksi yang pertama untuk menghasilkan 1 baris bintang berjumlah 10 bintang. Instruksi yang kedua untuk menghasilkan 1 baris yang terdiri dari 6 spasi yang diawali dengan 2 bintang di diakhiri dengan 2 bintang.

Tipe 1 : NL;p*;p*;p*;p*;p*;p*;p*;p*;p*;p*; Tipe 2 : NL;p*;p*;ps;ps;ps;ps;ps;ps;p*;p*;

Jika diperhatikan dengan lebih teliti, maka terlihat bahwa tipe 1 dan tipe 2 memiliki kesamaan pada awal dan akhir dari setiap baris. Kedua tipe tersebut selalu diawali dan diakhiri dengan bentuk yang sama, yaitu p*;p*;. Tipe 1 :

NL;

**p;p;**

p*;p*;p*;p*;p*;p*;

**p;p;**

**********

(13)

Tipe 2 :

NL;

**p;p;**

ps;ps;ps;ps;ps;ps;

**p;p;**

Dengan demikian procedure paling sederhana yang bisa dibuat adalah def duabintang () = print*;print* enddef

Dilanjutkan dengan procedure tipe2 dan procedure tipe2 def tipe1() = NL;duabintang(); print*;print*;print*;print*;print*;print*; duabintang(); enddef def tipe2 () = NL;duabintang(); printspsce;printspsce;printspsce; printspsce;printspsce;printspsce; duabintang(); enddef

Tampilan pada gambar 2.10 dapat dihasilnya dengan pemanggilan instruksi tipe 1 dan tipe 2. Secara lengkap program dapat ditulis seperti pada program 2.27.

def duabintang () = print*;print* enddef def tipe1() = NL;duabintang(); print*;print*;print*;print*;print*;print*; duabintang() enddef def tipe2 () = NL;duabintang(); printspsce;printspsce;printspsce; printspsce;printspsce;printspsce; duabintang() enddef tipe1();tipe1();tipe2(); tipe2();tipe1();tipe1(); Program 2.27 2.10 Urutan Definisi dan Nested Definition

Beberapa bahasa pemrograman memiliki keterbatasan dalam urutan penulisan definisi atau procedure. Adakalanya pemanggilan suatu procedure hanya bisa dilakukan setelah procedure tersebut telah didefinisikan. Dengan kata lain, definisi procedure harus dilakukan sebelum pemanggilan dari procedure tersebut. Hal ini penting untuk diperhatikan dalam menentukan urutan dalam penulisan definisi procedure.

(14)

Nested Definition, bisa juga disebut procedure yang ditulis di dalam procedure yang lain. Cara ini juga tidak salalu didukung oleh bahasa pemrograman yang digunakan. Untuk menghindari terjadinya kesalahan, definisi procedure yang berada di dalam definisi procedure yang lain dapat dituliskan secara sejajar.

Contoh untuk dua hal ini dapat dilihat pada program 2.27, dimana procedure duabintang() dituliskan sebelum procedure tipe1() dan procedure tipe2() karena di dalam kedua procedure tersebut dilakukan pemanggilan terhadap procedure duabintang().

2.10 Pada Bahasa Pascal

Program 2.27 jika dituliskan menggunakan bahasa pascal : uses crt; procedure duabintang; begin write(’*’); write(’*’); end; procedure tipe1(); begin writeln;duabintang; write(’*’);write(’*’);write(’*’); write(’*’);write(’*’);write(’*’); duabintang; end; procedure tipe2; begin begin writeln;duabintang;

write(’ ’);write(’ ’);write(’ ’); write(’ ’);write(’ ’);write(’ ’); duabintang; end; begin tipe1;tipe1;tipe2; tipe2;tipe1;tipe1; end.

(15)

2.10 Pada Bahasa C++

Program 2.27 jika dituliskan menggunakan bahasa C++ : include <stdio.h> void duabintang(); { printf(”*”);printf(”*”); } void tipe1(); { printf(”\n”);duabintang(); printf(”*”);printf(”*”);printf(”*”); printf(”*”);printf(”*”);printf(”*”); duabintang(); } void tipe2(); { printf(”\n”);duabintang();

printf(” ”);printf(” ”);printf(” ”); printf(” ”);printf(” ”);printf(” ”); duabintang(); } void main() { tipe1();tipe1();tipe2(); tipe2();tipe1();tipe1(); }