PENYUSUNAN MODUL EVALUASI PADA SISTEM PEMBELAJARAN CERDAS
Ifnu Bima Fatkhan G64101070
DEPARTEMEN ILMU KOMPUTER FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM INSTITUT PERTANIAN BOGOR 2007
PENYUSUNAN MODUL EVALUASI PADA SISTEM PEMBELAJARAN CERDAS
Skripsi Sebagai salah satu syarat untuk memperoleh gelar Sarjana Komputer pada Fakultas Matematika dan Ilmu Pengetahuan Alam Institut Pertanian Bogor
Ifnu Bima Fatkhan G64101070
DEPARTEMEN ILMU KOMPUTER FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM INSTITUT PERTANIAN BOGOR 2007
ABSTRAK IFNU BIMA FATKHAN . Penyusunan Modul Evaluasi pada Sistem Pembelajaran Cerdas. Dibimbing oleh Marimin dan Panji Wasmana. Penyusunan Modul Evaluasi pada Sistem Pembelajaran Cerdas merupakan penelitian untuk menyusun modul evaluasi pada sistem pembelajaran cerdas yang mengajarkan pada siswa konsepkonsep dasar pemrograman bahasa C. Modul evaluasi digunakan oleh sistem pembelajaran cerdas sebagai media untuk mengetahui kemampuan siswa dan mengetahui perkembangan kemampuan siswa sebelum, ketika dan setelah proses pengajaran berlangsung. Modul evaluasi juga memberikan gambaran mengenai karakteristik kemampuan siswa terutama kemampuan siswa dalam mengerjakan soal-soal pemrograman bahasa C. Penelitian ini didasarkan pada sistem pembelajaran cerdas yang telah disusun untuk bahasa Java oleh Edward R. Sykes (Sheridan College, Canada) dan Franya Franek (McMaster University, Canada). Dalam sistem pembelajaran cerdas yang disusun oleh keduanya, proses evaluasi pekerjaan siswa dilaksanakan dengan cara membandingkan pekerjaan siswa dengan kunci jawaban yang unik, padahal jawaban untuk suatu soal tidak unik. Penelitian ini mengambil beberapa ide Intent Recognition yang digunakan oleh Edward Sykes dan Franya Franek. Kemudian memperbaiki metode evaluasinya dengan menambahkan proses grading yang dapat secara objektif mengeveluasi jawaban siswa. Penelitian ini menyempurnakan proses tutorial yang dikembangkan oleh Franek dan Sykes dengan menambahkan output grader, sistem penjelas dan sistem perbaikan terotomasi. Proses evaluasi dimulai dengan melakukan kompilasi terhadap kode sumber hasil jawaban siswa, jika proses kompilasi berhasil, output grader akan mengetes jawaban dengan serangkaian tes. Jika proses kompilasi gagal, lexer dan parser dalam Intent Recognition akan menganalisis kode sumber. Kesalahan yang ditemukan dalam kode sumber dijelaskan oleh sistem penjelas. Siswa dapat meminta pertolongan sistem perbaikan terotomasi untuk memperbaiki kode programnya. Kata kunci : Sistem Pembelajaran Cerdas, Intelligent Tutoring System , modul evaluasi, output grader, perbaikan terotomasi, intent recognition, sistem penjelas.
Penelitian ini aku persembahkan untuk : Ayah dan Ibu tercinta, Kak Mifta, Dek Banan, Dek Pinten dan Neng Dian.
Sejarah Hanya Mengingat Pekerja Keras!!
Judul
: Penyusunan Modul Evaluasi pada Sistem Pembelajaran Cerdas : Ifnu Bima Fatkhan : G64101070
Nama NRP
Menyetujui: Pembimbing I
Prof. Dr. Ir. Marimin, M.S c NIP.131645110
Pembimbing II
Panji Wasmana, S.Kom, M.Si NIP. 132311917
Mengetahui: Dekan Fakultas Matematika dan Ilmu Pengetahuan Alam Institut Pertanian Bogor
Prof. Dr. Ir. Yonny Koesmaryono, MS NIP. 131473999
Tanggal Lulus:
RIWAYAT HIDUP Ifnu Bima Fatkhan lahir di Banyuwangi 15 Maret 1983, dilahirkan dari pasangan Rahmad Nurhadi dan Ngatiyah Ismail. Anak kedu a dari empat bersaudara ini menyelesaikan Pendidikan. Mengengah Atas di SMU Taruna Nusantara Magelang. Pada tahun 2001 penulis melanjutkan pendidikan tingginya di Departamen Ilmu Komputer Institut Pertanian Bogor melalui jalur undangan khusus prestasi. Undangan khusus ini dianugerahkan kepada penulis atas prestasinya sebagai anggota Tim Olimpiade Kimia Indonesia pada 33rd International Chemistry Olympiad di Mumbay India. Selama kuliah penulis aktif dalam beberapa kegiatan kemahasiswaan terutama di Himpunan Mahasiswa Ilmu Komputer. Penulis sangat tertarik dengan Community Develop ment, hal ini dituangkannya dalam program kerja Departemen Riset dan Pengembangan HIMALKOM 2004/2005. Salah satu andil penulis dalam pengembangan komunitas adalah dengan menjadi inisiator dan koordinator komunitas PHP di lingkungan departemen Ilmu Komputer IPB. Saat ini penulis aktif dalam komunitas terutama komunitas NetB eans Indonesia sebagai Community Leader, JLinux sebagai moderator dan komunitas Java User Group Indonesia sebagai anggota aktif.
PRAKATA Alhamdulillah wa syukrulillah penulis persembahkan ke hadirat Allah Subhanahu wa ta’ala atas segala rahmat dan hidayah-Nya sehingga penelitian ini berhasil diselesaikan. Shalawat beriring salam tercurah untuk Nabi Muhammad Shallalahu ‘alaihi wasallam beserta seluruh sahabat, keluarga dan umatnya hingga akhir zaman. Penulis sampaikan terima kasih yang tiada berhingga kepada semua pihak yang telah membantu secara langsung maupun tidak langsung. Khususnya kepada Bapak Prof . Dr. Ir. Marimin, M.Sc dan Bapak Panji Wasmana, S.Kom, M.Si yang dengan sabar dan berbesar hati telah memberikan banyak bimbingan, masukan, motivasi berharga terhadap penelitian ini. P enulis juga ingin mengucapkan terima kasih kepada Ibu Imas Sitanggang, S.Si, M.Kom atas kesediaannya menjadi penguji pada sidang skripsi. Selanjutnya penulis juga ingin mengucapkan terima kasih kepada: 1. Ayah dan Ibu tercinta atas semua do’a, nasehat, ketabahan, kesabaran dan kasih sayang dari awal hingga akhir. 2. Mbak Mifta, Mas Nur, Dek Banan, Dek Dima dan Neng Dian yang selalu memberikan dukungan dan semangat. 3. Dhira, Acid, Robi, Irfan, Rossi, Leisca yang dengan senang hati memberikan dorongan untuk segera menyelesaikan penelitian ini. 4. Dhiku dan Meynar yang dengan sabar memberik an masukan dan koreksi terhadap laporan penelitian ini. 5. Mas Endy yang secara tidak langsung mengenalkan ANTLR, Mas Ibrahim yang bersedia meluangkan wakt u berdiskusi tentang ANTLR, Pak Tonny yang mengajari beberapa konsep tentang Netbeans Platform dan tentu saja semua anggota komunitas netbeans indonesia. 6. Terrence Parr dan Jean Bovet untuk pekerjaan yang luar biasa, ANTLR, C.g dan AntlrWorks. 7. Mas Degy untuk ilmu Java dan icon SExI-FS. 8. Mas Irfan yang dengan sabar meminjami buku-buku perpustakaan, Pak Firman yang bersedia mendengarkan laporan kemajuan, dan Toto yang terus mendukung selama karantina di lab kecil. 9. Denny, Nanang dan penghuni Meteor House yang dengan murah hati menyediakan tempat bernaung selama penelitian ini . 10. Didi untuk pinjaman karpetnya. 11. Irfan untuk tumpangan ke Darmaga dan bantuan selama seminar dan sidang. 12. Semua dosen dan Staf Departemen Ilmu Komputer IPB yang telah banyak membantu baik selama pelaksanaan penelitian ini maupun sebelumnya. 13. Semua pihak lainnya yang telah memberikan kontribusi selama penelitian ini yang tidak dapat disebutkan satu-persatu, terima kasih. Semoga penelitian ini memberikan manfaat untuk pengembangan ilmu pengetahuan di masa datang. Amin. Bogor, Agustus 2007
Ifnu Bima
DAFTAR ISI PENDAHULUAN Latar Belakang................................................................................................................................................... 1 Tujuan ................................................................................................................................................................. 1 Ruang Lingkup .................................................................................................................................................. 2 Manfaat ............................................................................................................................................................... 2 TINJAUAN PUSTAKA Sistem Pembelajaran Cerdas ........................................................................................................................... 2 Model Komunikasi............................................................................................................................................ 2 Modul Pakar ....................................................................................................................................................... 3 Modul Pedagogig .............................................................................................................................................. 3 Modul Siswa...................................................................................................................................................... 4 Modul Evaluasi.................................................................................................................................................. 4 Kode Sumber Bahasa C ............................................................................Error! Bookmark not defined. Token ................................................................................................................................................................... 4 Lexer .................................................................................................................................................................... 4 Parser .................................................................................................................................................................. 4 Grammar ............................................................................................................................................................ 4 METODOLOGI PENELITIAN Kerangka Pemikiran ......................................................................................................................................... 5 Studi Literatur .................................................................................................................................................... 5 Penentuan Metode Pengembangan Sistem ................................................................................................... 5 Analisis Kebutuhan........................................................................................................................................... 6 Perancangan ....................................................................................................................................................... 6 Implementasi...................................................................................................................................................... 6 Pengujian ............................................................................................................................................................ 6 HASIL DAN PEMBAHASAN Analisis ............................................................................................................................................................... 6 Kebutuhan Fungsional .................................................................................................................................. 6 Strategi Penilaian ........................................................................................................................................... 7 Strategi Pengenalan Kesalahan ................................................................................................................... 7 Strategi Perbaikan Terotomasi .................................................................................................................... 7 Kebutuhan Non Fungsional ......................................................................................................................... 7 Perancangan ....................................................................................................................................................... 7 Arsitektur Sistem ........................................................................................................................................... 7 Perancangan Struktur Penyimpanan Data................................................................................................. 8 Perancangan Output Grader ........................................................................................................................ 8 Perancangan Intent Recognition.................................................................................................................. 9 Algoritma Transformasi Token .............................................................................................................. 11 Algoritma Pemeriksaan dan Pencatatan Kesalahan............................................................................ 11 Perancangan Sistem Perbaikan Terotomasi ............................................................................................ 12 Perancangan Antarmuka ............................................................................................................................. 13 Implementasi.................................................................................................................................................... 13 Implementasi Struktur Penyimpanan Data.............................................................................................. 13 Implementasi Output Grader .................................................................................................................... 14 Implementasi Intent Recognition.............................................................................................................. 14 Implementasi Sistem Perbaikan Terotomasi........................................................................................... 16 Proses Tutorial ............................................................................................................................................. 17 Implementasi Antarmuka Sistem.............................................................................................................. 18 Issue dalam Implementasi Sistem............................................................................................................. 19 Kelebihan Sistem ......................................................................................................................................... 19 Kekurangan Sistem ..................................................................................................................................... 20 Pengujian Kinerja Sistem Evaluasi.............................................................................................................. 20
Pengujian Kompleksitas Algo ritma Pada Modul Evaluasi...................................................................... 20 KESIMPULAN DAN SARAN Kesimpulan ....................................................................................................................................................... 21 Saran .................................................................................................................................................................. 21
DAFTAR GAMBAR 1 Arsitektur sistem pembelajaran cerdas b ahasa C (Wasmana 2005). ...................................................2 2 Diagram metodologi p enelitian. .................................................................................................................5 3 Alur pengembangan sistem ( System Development Life Cycle) dengan metode waterfall menurut Pressman (2001). ..........................................................................................................................................6 4 Arsitektur modul evaluasi............................................................................................................................8 5 Langkah-langkah dalam modul Output Grader .......................................................................................9 6 Graph DFA untuk menerima string identifier dalam bahasa C. ...........................................................9 7 Graph DFA untuk memvalidasi sintaks if dalam bahasa C. ................................................................ 10 8 Algoritma pemeriksaan dan pencatatan kesalahan oleh Intent Recognition. .................................... 12 9 Perancangan antarmuka modul evaluasi. ................................................................................................ 13 10 Tampilan antarmuka modul e valuasi.................................................................................................... 18 11 AntlrWorks membantu mengembangkan aplikasi ANTLR.............................................................. 19
DAFTAR TABEL 1 Daftar jenis kesalahan yang dikenali oleh lexer dan parser . ...................................................................... 15 2 Hasil Pengujian Modul Evaluasi ..................................................................................................................... 20
DAFTAR LAMPIRAN 1 Pengujian kinerja Intent Recognition. ............................................................................................................. 23 2 Pengujian kinerja sistem perbaikan terotomasi............................................................................................. 26 3 Pengujian sistem menggunakan metode black box. ..................................................................................... 27
1
PENDAHULUAN Latar Belakang Komputer telah digunakan dalam dunia pendidikan lebih dari 20 tahun. Computer-based Tutorial (CBT) dan Computer Aided Instruction (CAI) adalah sistem yang pertama kali diperkenalkan sebagai usaha untuk mengajar siswa menggunakan komputer. Dalam sistem seperti ini, instruksi terhadap siswa tidak diberikan secara unik kepada perseorangan, tetapi instruksi diberikan sama untuk setiap siswa. Keputusan bagaimana mengajarkan materi kepada siswa tidak memperhatikan kemampuan siswa, sehingga semua siswa akan diajar dengan cara yang sama, tidak peduli apakah dia siswa yang cepat belajar maupun siswa yang agak lambat menerima materi. Sistem pembelajaran cerdas menyempurnakan kelemahan tersebut dengan memperhatikan kemampuan siswa, kemudian mengajarkan materi sesuai kemampuan masingmasing siswa. Selain itu, sistem pembelajaran cerdas juga dapat mengetahui kelemahankelemahan siswa, sehingga dapat diambil keputusan pedagogig untuk mengatasinya. Dilihat dari berbagai sisi, sistem pembelajaran cerdas , sangat mirip dengan sistem pembelajaran yang diberikan oleh pengajar secara private. Didasarkan pada ilmu kognitif dan kecerdasan buatan, sistem pembelajaran cerdas telah membuktikan keberhasilannya menyampaikan pelajaran dengan baik dalam berbagai bidang ilmu pengetahuan. sistem pembelajaran cerdas mendapatkan sambutan yang sangat antusias dari berbagai pihak karena beberapa alasan, antara lain: (1) meningkatkan kemampuan siswa, (2) pemahaman kognitif yang semakin baik, (3) waktu yang diperlukan siswa memahami materi pelajaran lebih singkat (Franek 2003). Penerapan sistem pembelajaran cerdas dalam memonitor dan mengajarkan bahasa pemrograman telah dikembangkan dan di evaluasi selama bertahun-tahun. Dalam banyak hal, penerapan sistem pembelajaran cerdas dalam mengajarkan bahasa pemrograman telah memberikan sumbangan yang cukup signifikan dalam perkembangan bidang sistem pembelajaran cerdas itu sendiri. Termasuk diperkenalkannya konsep model siswa,
representasi pengetahuan, dan penerapan konsep pedagogig. Modul evaluasi pada sistem pembelajaran cerdas merupakan kajian yang aktual, terutama untuk menyusun modul evaluasi agar sesuai dengan domain materi pembelajaran bahasa pemrograman. Modul evaluasi pada sistem pembelajaran cerdas dengan domain materi pembelajaran bahasa pemrograman mempunyai keunikan tersendiri. Pada umumnya, modul evaluasi pada sistem pembelajaran cerdas hanya menilai hasil jawaban siswa atas pertanyaan berjenis pilihan ganda dan isian sederhana. Di sisi lain, modul evaluasi pada sistem pembelajaran cerdas dengan domain materi pembelajaran bahasa pemrograman, harus mampu mengevaluasi jawaban siswa atas pertanyaan es ai dengan jawaban berupa kode sumber program. Sykes dan Franek (2003) menyusun modul yang disebut Intent Recognition untuk memeriksa kode sumber B ahasa Java yang dibuat oleh siswa. Intent Recognition mengevaluasi kode sumber siswa dengan memeriksa lebih teliti kode sumber tersebut menggunakan lexer, parser, pengenalan kesalahan, sistem penjelas, dan strategi perbaikan terotomasi. Modul Intent Recognition bertujuan untuk memahami makna semantik dari kode sumber siswa dan secara efektif mengajarkan siswa bahasa pemrograman lewat metode learning-by-doing. Intent Recognition memberikan solusi bagaimana mengevaluasi hasil jawaban siswa yang berupa kode sumber program. modul evaluasi pada sistem pembelajaran cerdas akan menggunakan metode Intent Recognition yang digabungkan dengan output grader sebagai komponen utama. Dengan konsep ini diharapkan dapat disusun modul evaluasi yang dapat menilai jawaban siswa secara lebih objektif dan mengajarkan bahasa pemrograman kepada siswa secara lebih efektif. Tujuan Tujuan dari penelitian ini adalah: 1
Menyusun modul evaluasi sistem pembelajaran cerdas, modul ini bertugas untuk melakukan evaluasi terhadap hasil jawaban siswa dari soal yang diberikan kepada siswa. Jenis pertanyaannya adalah esai dengan jawaban berupa kode sumber
2
bahasa C. Output dari modul ini adalah nilai hasil jawaban siswa. 2
Menyusun sistem tutorial yang akan memberikan petunjuk kepada siswa bagaimana memperbaiki kesalahan sintaks yang terjadi dalam jawaban siswa atas soal yang diberikan.
Ruang Lingkup Penelitian ini dititikberatkan pada proses penyusunan modul evaluasi untuk mengenali kode sumber bahasa C sederhana. Kode sumber yang diperiksa terbatas hanya pada kode sumber yang ada dalam jendela editor. Semisal terdapat preprocessor directrive #include , file header dalam include tidak diperiksa. Fungsi lain yang terdapat dalam file .c juga tidak diperiksa, hanya ada satu fungsi yang digunakan, yaitu fungsi main. Kesalahan yang dikenali oleh modul evaluasi hanya terbatas pada kesalahan sintaks. Kesalahan logika (semantik) dalam program belum termasuk dalam subjek penelitian ini. Tidak semua kesalahan dapat diperbaiki secara terotomasi. Hanya kesalahan penulisan identifier dan kesalahan karena pengurangan atau penambahan satu token yang dapat diperbaiki secara terotomasi.
TINJAUAN PUSTAKA Sistem Pembelajaran Cerdas Sistem Pembelajaran Cerdas (Intelligence Tutoring System, ITS) adalah suatu sistem yang memanfaatkan teknik tingkat lanjut dalam mendeskripsikan dan meningkatkan proses pengajaran. Gambar 1 menjelaskan arsitektur sistem pembelajaran cerdas. Implementasi sistem pembelajaran cerdas telah berkembang menjadi suatu sistem yang mampu “memahami” dan berlaku selayaknya pengajar dalam lingkungan pengajaran private. Sistem pembelajaran cerdas memberikan fleksibilitas dalam mempresentasikan materi dan kemampuan memahami karakteristik siswa. Keunggulan sistem pembelajaran cerdas dibandingkan proses pengajaran dalam kelas besar adalah kemampuannya dalam memahami karakteristik unik setiap siswa dan menyampaikan materi pembelajaran sesuai dengan karakteristik siswa tersebut (Franek 2003). Kecerdasan sistem pembelajaran cerdas diwujudkan dalam kemampuan pedagogignya untuk menyampaikan materi sesuai karakteristik siswa yang diajarnya, memberikan tugas, dan menilai kemampuan siswa. Pengguna
Manfaat Penelitian ini diharapkan memberikan satu langkah ke depan dalam proses pengembangan sistem pembelajaran cerdas di lingkungan Departemen Ilmu Komputer. Terwujudnya sebuah sistem pembelajaran cerdas dapat membantu pengajar dan siswa dalam proses pembelajaran bahasa pemrograman, khususnya bahasa C. Dalam lingkup lebih luas, penelitian ini diharapkan menjadi jembatan bagi penelitian sejenis yang mengambil disiplin ilmu Teori Bahasa dan Otomata di lingkungan Departemen Ilmu Komputer IPB. Bahasa pemrograman sekarang ini berkembang dengan pesat, terutama bahasa pemrograman yang spesifik terhadap satu area disiplin tertentu. Usaha untuk meneliti aspek-asp ek dalam bahasa pemrograman tersebut sangat diperlukan untuk meningkatkan kompetensi mahasiswa Ilmu Komputer di dunia pendidikan maupun dunia industri.
Model Komunikasi
Modul Pedagogig
Modul Siswa
Unit Materi Kurikulum Unit Soal
Parameter Sistem
Modul Pakar Modul Evaluator
Profil Siswa
Pemindai Jawaban Sistem Penjelas
Gambar 1 Arsitektur Sistem Pembelajaran Cerdas Bahasa C (Wasmana 2005). Model Komunikasi Modul Komunikasi digunakan sebagai media interaksi dengan pengguna. Bentuk-bentuk dialog ditampilkan secara grafis dan informatif. Seluruh komponen interaksi disusun dengan menggunakan kotak dialog, tombol, dan pilihan –
3
pilihan yang secara dominan dapat diakses melalui keyboard dan mouse. Modul Pakar Modul pakar berfungsi sebagai pengatur proses pedagogig dan menghitung tingkat kognitif yang diterapkan sistem kepada siswa. Pada modul pakar, strategi penyusunan materi didasarkan pada model taksonomi tujuan instruksional (taksonomi bloom’s pada ranah kognitif). Parameter input yang digunakan untuk melakukan evaluasi adalah profil siswa dan hasil interaksi siswa dengan sistem. Secara lebih detail, komponen tersebut adalah: 1
Profil siswa a Pembobotan terhadap ketertarikan terhadap materi (menyukai, sangat menyukai, biasa saja, tidak menyukai) b Pemahaman terhadap algoritma pemrograman (sangat paham, paham, kurang paham, tidak paham sama sekali) c IPK yang selanjutnya dikategorikan menjadi kurang, cukup, dan baik. d Model pembelajaran yang diinginkan e Tingkat kognitif siswa 2 Parameter sistem a Waktu yang dibutuhkan dalam proses belajar suatu materi dibandingkan terhadap waktu rata-rata pada materi yang bersangkutan. b Nilai evaluasi yang diperoleh pada akhir bab dengan melihat tingkat kognitif berdasarkan taksonomi Bloom’s. Parameter ini memiliki peranan terpenting dalam penentuan tingkat pedagogig siswa. c Tingkat pedagogig pada materi sebelumnya. d Jumlah kemunculan dan banyaknya referensi yang diakses. Hasil akhir dari modul pakar adalah: a Rekomendasi terhadap pemilihan materi evaluasi (sulit, normal, mudah). b Penentuan tingkat pedagogig pada materi bab yang terkait atau bab selanjutnya (sulit, normal, mudah). c Mengatur model bantuan sistem yang berbentuk penjelasan istilah atau bentuk soal latihan (sulit, normal, mudah).
Modul Pedagogig Hasil dari proses identifikasi pengetahuan yang diperoleh dari pakar selanjutnya diterjemahkan sebagai bentuk modul pedagogig. Komponen pada modul ini terbagi dalam tiga sub modul, yaitu: 1
Unit kurikulum yang memuat aturan perkuliahan yang berlaku. Proses aturan ini selanjutnya disebut sebagai sekuen perkuliahan. Untuk memudahkan dalam pembagian secara logis, proses sekuen ini dibagi menjadi dua proses, yaitu: • Sekuen konsep, memuat keterkaitan materi pada tingkat bab (suku bahasan utama). • Sekuen chunk, memuat keterkaitan sub bahasan terkecil pada setiap bab. Penentuan kognitif seorang siswa ditentukan oleh sekuen konsep. Sedangkan untuk proses evaluasi dan pemindaian tingkat akurasi pengetahuan ditentukan oleh sekuen chunk . 2 Unit materi yang memuat materi – materi perkuliahan dengan tingkat penjelasan yang berbeda. Tingkat penjelasan ini didasarkan pada tingkat kognitif siswa dan model pedagogig yang yang telah diterapkan dalam sistem pada sesi pembelajaran sebelumnya. Secara umum terdapat tiga tingkat penjabaran materi yang diberikan sistem, yaitu: lambat, normal, cepat. Masing – masing penjelasan ini dipersiap kan untuk setiap bab bahasan. Selain itu, unit materi dilengkapi dengan bentuk – bentuk fragment pengetahuan yang mencerminkan satu sub komponen bahasan terkecil (chunk). 3 Unit soal yang memuat beragam bentuk soal yang bertujuan menguji kemampuan siswa dalam menguasai materi perkuliahan. Setiap soal memiliki karakteristik yang sesuai dengan ranah kognitif dan tingkat pedagogig yang dimiliki siswa. Model pedagogig yang dikembangkan menggunakan konsep model overlay. Pada model ini, unit materi berisi seluruh konsep yang harus dipelajari siswa dan diasumsikan bahwa siswa mengetahui sebagian dari konsep tersebut. Proses pembelajaran dianggap sebagai proses mengisi lubang – lubang kosong yang ada dalam
4
pengetahuan siswa. Proses ini terus dilakukan hingga mereka telah dipandang cukup menguasai materi yang diberikan (Martin 2004). Modul Siswa Pada modul siswa ini akan terekam data siswa, komponen data yang terekam berkaitan dengan proses adaptasi sistem terhadap kemampuan siswa (Prentzas et al. 2002). Untuk lebih memperjelas latar belakang siswa yang berkaitan dengan materi yang diberikan, maka selain informasi interaksi dengan sistem, profil siswa turut direkam di dalam sistem (Wasmana 2005). Modul Evaluasi Modul evaluasi berfungsi dalam proses evaluasi jawaban siswa dari soal yang diberikan oleh sistem. Proses evaluasi dilakukan berdasarkan jenis soal yang diberikan. Untuk jenis soal pilihan terbatas tidak terdapat perlakuan khusus dari sistem dalam proses evaluasi. Sistem mencocokkan jawaban siswa dengan jawaban seharusnya dan memberikan nilai jika jawaban benar. Untuk kejadian jawaban salah, sistem evaluasi akan memberikan penjelasan letak kesalahan yang dilakukan berdasarkan pilihan yang dilakukan siswa. (Wasmana 2005) Token Token adalah kumpulan karakter yang menyusun suatu bahasa. Dalam ilmu bahasa, token dapat disamakan dengan kata. Token-token ini dibentuk dari karakter-karakter berdasarkan suatu aturan tertentu yang disebut sebagai lexer rule. Kode sumber bahasa pemrograman merupakan kumpulan karakter-karakter yang masih belum bermakna. Untuk memperoleh maknanya karakter-karakter itu harus dikelompokan. Pengelompokan ini mempunyai aturan tertentu sehingga akan menghasilkan tipetipe token, misalnya: keywords, operator, identifier dan komentar. Token-token ini kemudian dikirimkan kepada parser untuk kemudian digabungkan dengan token-token lainnya untuk membentuk statement (kalimat) (Grune 2001).
Lexer Lexer merupakan bagian awal dari sebuah recognition, tugasnya adalah mengubah aliran karakter yang tidak bermakna menjadi potonganpotongan token yang sesuai dengan spesifikasi grammar dari domain bahasanya. Lexer juga membuang karakter-karakter yang tidak bermakna misalnya komentar, spasi, tab, dan karakter baris baru (new line). Hasil dari lexer berupa aliran token-token yang kemudian akan diproses oleh parser. Dengan mengubah aliran karakter menjadi aliran token, lexer akan memudahkan parser dalam mengenali struktur program dengan lebih baik. Tanpa adanya lexer, parser harus mengenali struktur program dari aliran karakter yang kurang bermakna dibanding aliran token (Grune 2001). Parser Parser memeriksa struktur kode sumber dengan menggunakan aturan-aturan dalam tata bahasa (grammar) tertentu. Grammar inilah yang menentukan apakah suatu urutan token dikatakan valid atau tidak. Parser mendapatkan input aliran token dari lexer. Token-token ini kemudian dimasukan dalam aturan-aturan parser untuk mengetahui apakah urutan token-token tersebut membentuk tata bahasa yang sesuai atau tidak. Jika terjadi kesalahan tata letak token dalam tata bahasa, parser akan mengembalikan kesalahan yang mengindikasikan adanya kesalahan dalam kode sumber (Grune 2001). Grammar Grammar didefinisikan sebagai formalisasi dari struktur sebuah bahasa pemrograman (Grune 2000). Grammar merupakan sekumpulan aturan (rule) untuk membentuk sebuah bahasa pemrograman. Dalam konteks bahasa indonesia, grammar adalah aturan-aturan pembentukan huruf menjadi kata dan pembentukan kata menjadi kalimat. Dalam konteks bahasa pemrograman, grammar mendefinisikan aturan pembentukan huruf atau simbol menjadi token dan token menjadi statement. Sebuah grammar terdiri dari kumpulan production rules. Dengan menggunakan notasi Context-Free Grammar, production rules terdiri dari dua bagian, sisi sebelah kiri dan sisi sebelah kanan, dipisahkan dengan simbol panah yang
5
mengarah ke kanan (à). Sisi sebelah kiri merupakan nama dari production rule; sisi sebelah kanan mendefisinikan aturan pembentukan token atau statement. Berikut ini adalah sintaks umum suatu production rule: expression à ‘(‘ expression OPERATOR expression ‘)’ Setiap production rule bisa digolongkan menjadi dua: lexer rule dan parser rule. Lexer rule mendefinisikan aturan pembentukan token dari aliran huruf/simbol; sedangkan parser rule mendefinisikan aturan pembentukan statement dari aliran token (Parr 2007). Seperti dalam contoh di atas, expression adalah parser rule sedangkan OPERATOR adalah lexer rule. Deterministic Finite Outomata (DFA) DFA adalah sebuah mesin yang digunakan untuk memvalidasi sebuah input. DFA mempunyai input dan kumpulan state yang menentukan apakah sebuah rangkaian input tersebut diterima oleh mesin atau tidak. DFA mempunyai aturan bahwa untuk sebuah transisi dari satu state ke state yang lain harus ada tepat satu input. Jika ada satu input yang sama untuk dua buah transisi maka akan menyebabkan transisi tersebut ambigu. DFA terdiri atas: 1 2 3
4 5
Sebuah kumpulan finite state, dilambangkan sebagai Q. Sebuah kumpulan simbol input, dilambangkan sebagai ? . Fungsi transisi yang menerima argumen simbol input dan state, mengembalikan sebuah state. Dilambangkan sebagai d. Sebuah start state, salah satu state dalam Q. Sekumpulan final state F, yang merupakan subset dari Q.
DFA sering dinotasikan sebagai lima tuple seperti contoh di bawah ini: A = {Q, ? , d, q0 , F}
METODOLOGI PENELITIAN Kerangka Pemikiran Penelitian ini mengembangkan lebih lanjut modul evaluasi pada sistem pembelajaran cerdas yang dikembangkan oleh Wasmana (2005).
Sistem y ang dikembangkan memiliki model stand alone dan tidak mendukung proses komunikasi data. Penelitian ini akan melalui tahap-tahap seperti yang digambarkan dalam Gambar 2. Penelitian diawali dengan studi literatur, kemudian penentuan metode pengembangan sistem dan dilanjutkan dengan fase pengembangan sistem. Fase pengembangan sistem diawali dengan analisis kebutuhan dilanjutkan dengan perancangan, implementasi dan diakhiri dengan pengujian. Studi Literatur Implementasi Penentuan Metode Pengembangan Sistem
Pengujian
Analisis Kebutuhan Deployment Perancangan
Gambar 2 Diagram Metodologi Penelitian. Studi Literatur Studi literatur diawali dengan menentukan acuan utama penelitian. Acuan utama penelitian ini adalah Java Intelligent Tutoring System (JITS) yang dikembangkan oleh Edward Sykes dan Franya Franek . Dari penelitian JITS, diperoleh pengetahuan mengenai metode pemeriksaan kode sumber bahasa pemrograman menggunakan Intent Recognition. Studi literatur dilanjutkan dengan mencari metode untuk mengimplementasikan Intent Recognition. Hal ini harus dilaksanakan penulis karena implementasi JITS tidak dapat diperoleh. Implementasi Intent Recognition adalah sebuah sistem language recognition dengan menggunakan konsep lexer dan parser . Parr (1999) menulis tutorial tentang membuat recognizer sederhana dari awal, litetatur ini cukup memberikan gambaran awal bagaimana sebuah recognizer bekerja. Penentuan Metode Pengembangan Sistem Metode pengembangan sistem yang digunakan adalah Waterfall. Gambar 3 menggambarkan bagan pengembangan metode Waterfall. Metode Waterfall diawali dengan
6
analisis, dilanjutkan dengan perancangan dan implementasi, diakhiri dengan pengujian. Metode pengujian yang digunakan adalah black box testing. Metode pengujian ini hanya terbatas menguji fungsionalitas dari sistem. Pengujian dilakukan dengan mengikuti langkahlangkah yang didefinisikan dalam dokumen test case yang telah disediakan sebelumnya. Analisis Kebutuhan Desain Sistem
Implementasi Modul evaluasi dibuat dalam Tahap Implementasi. Proses pembuatan modul evaluasi diawali dengan menyusun parser dan lexer, dilanjutkan dengan menyusun sistem penjelas dan diakhiri dengan sistem Perbaikan Terotomasi. Implementasi modul evaluasi berupa kode program dan tampilan aplikasi didokumentasikan secara lengkap. Kendala dan issue yang muncul dalam tahap implementasi dicatat sebagai bahan masukan untuk penelitian selanjutnya. Pengujian
Implementasi Sistem Integrasi dan Pengujian Sistem Penggunaan dan Pemeliharaan
Gambar 3 Alur pengembangan sistem (System Development Life Cycle) dengan metode waterfall menurut Pressman (2001).
Tahap pengujian dimaksudkan untuk mengetahui sejauh mana kinerja Sistem Evaluasi dalam memenuhi tujuan penelitian ini. Pengujian juga dimaksudkan mengurangi kesalahan (bug) sistem. Proses pengujian dilaksanakan dengan beberapa tahap, antara lain: pengujian kinerja sistem, pengujian dengan metode black box testing dan pengujian dengan metode analisis algoritma.
Analisis Kebutuhan Tahap analisis kebutuhan mendefinisikan kebutuhan ap a saja yang harus dipenuhi oleh sistem. Kebutuhan yang harus didefinisikan mencakup kebutuhan fungsional dan kebutuhan non fungsional. Kebutuhan fungsional mendefinisikan fungsi-fungsi dasar yang harus diimplementasikan, kebutuhan fungsional ini yang nantinya akan membedakan modul evaluasi yang dibuat dan modul evaluasi yang ada dalam JITS. Perancangan Tahap perancangan mendefinisikan bentuk abstrak dari modul evaluasi. Arsitektur modul evaluasi disusun untuk memenuhi kebutuhan fungsional yang telah didefinisikan dalam tahap sebelumnya. Setiap bagian penting dari modul evaluasi dirancang lebih mendetail menggunakan notasi dan diagram. Algoritma yang digunakan dalam modul evaluasi didefinisikan menggunakan notasi ilmiah beserta abstraksi berupa flowchart.
HASIL DAN PEMBAHASAN Analisis 1
Kebutuhan Fungsional
Kebutuhan fungsional mendefinisikan tiga aspek penting dalam modul evaluasi, yaitu: strategi penilaian jawaban siswa, strategi pengenalan kesalahan dan strategi perbaikan terotomasi. Ketiga aspek di atas merupakan fungsionalitas utama dari modul evaluasi. Ketiga aspek kebutuhan fungsional dapat dipecah-pecah menjadi poin-poin penting sebagai berikut: a
Memahami variasi sintaks. Siswa harus diperbolehkan untuk menggunakan variabel yang berbeda, struktur kondisi dan struktur iterasi yang berbeda. b Memahami variasi implementasi. Algoritma yang berbeda untuk konsep yang sama harus bisa dikenali. c Mengenali kesalahan. Jika terdapat kesalahan harus ada penjelasan yang lengkap.
7
d Membantu siswa memperbaiki kesalahan. Selain penjelasan yang lengkap atas kesalahan, siswa juga dibantu dalam memperbaiki kesalahan dengan memberikan petunjuk solusi yang benar. e Mengenali batasan-batasan. Jika terdapat kesalahan yang tidak diketahui oleh sistem, harus diberikan keterangan yang jelas, hal ini berkaitan dengan faktor reliabilitas. f Memberikan penilaian atas jawaban siswa. Penilaian yang diberikan didasarkan beberapa parameter dan kondisi, tidak hanya dari kebenaran jawaban. 2
S trategi Penilaian
Proses penilaian jawaban siswa menggunakan metode grading. Metode grading memerlukan kumpulan pasangan data input/output untuk setiap soal. Data input/output disimpan dalam struktur penyimpanan data. Ketika proses penilaian akan berlangsung, sistem akan membaca data input/output dari sumber data dan menyimpannya dalam memori. Langkah berikutnya dalam strategi penilaian adalah mengkompilasi kode sumber hasil jawaban siswa menjadi file executable. Data input akan dimasukkan ke dalam file executable. Agar proses pemasukan data ini berhasil, kode sumber hasil jawaban siswa harus menyertakan kode untuk menerima input berupa data input. File executable juga harus mengeluarkan output sesuai dengan format data output. Penilaian akan didasarkan pada perbandingan output dari file executable dengan data output. Agar penilaian akurat, kumpulan pasangan data input/output disediakan sebanyak mungkin, semakin banyak data input/output maka semakin akurat nilai yang dihasilkan. 3
Strategi Pengenalan Kesalahan
Kode sumber hasil jawaban siswa tidak selalu bebas dari kesalahan. modul evaluasi harus mampu mengenali kesalahan dalam kode sumber. Cara yang paling efektif untuk mengenali kesalahan dalam kode sumber adalah mengembangkan aplikasi yang bisa ”mengenali” kode sumber bahasa C. Aplikasi demikian disebut language recognizer. Language recognizer adalah aplikasi yang dapat
menentukan apakah sebuah kalimat mematuhi aturan dalam tata bahasa atau tidak (Parr 2007). Kesalahan yang ditemukan oleh language recognizer dikategorikan dalam beberapa kategori. Pengkategorian kesalahan memudahkan modul evaluasi menyusun penjelasan kesalahan. Kesalahan dengan kategori yang sama dapat dijelaskan dengan pola yang sama. Penjelasan kesalahan secara kasus per kasus sangat tidak efisien, pengguna tidak memerlukan penjelasan panjang lebar bertele-tele, tetapi penjelasan yang singkat dan padat tentang kesalahan yang dibuatnya. 4
Strategi Perbaikan Terotomasi
Kecerdasan modul evaluasi diwujudkan dalam kemampuannya memperbaiki kesalahan tertentu pada kode sumber secara terotomasi. Siswa cukup memberikan persetujuan “y a” atau “tidak” terhadap langkah perbaikan terotomasi, tanpa perlu secara manual memperbaiki kesalahan. Siswa dapat menyetujui atau menolak proses perbaikan terotomasi, dan siswa dapat membatalkan semua langkah perbaikan terotomasi yang diajukan oleh sistem. 5
Kebutuhan Non Fungsional a
Kebutuhan Perangkat Keras Prosesor : Intel Pentium 800 MHz Memori : 256 M B DDR RAM Hardisk : 40 GB VGA : 32 MB Keyboard dan Mouse b Kebutuhan Perangkat Lunak 1 Sistem Operasi Microsoft Windows XP Professional 2 Java 6 Runtime Environment 1 2 3 4 5
Perancangan 1
Arsitektur Sistem
Berdasarkan analisis kebutuhan sistem, disusunlah arsitektur modul evaluasi sep erti yang terlihat pada Gambar 4. Proses penilaian jawaban siswa ditunjukkan oleh diagram lurus dari atas hingga bawah. Jika terdapat kesalahan dalam kode sumber jawaban siswa, maka Intent Recognition akan mengambil alih dan mulai melakukan serangkaian langkah membantu siswa menemukan, mengerti dan memperbaiki kesalahan. Alur eksekusi program pada Gambar
8
4 dilaksanakan untuk setiap satu soal dalam modul evaluasi. start
student
menggunakan C compiler dan menghasilkan file executable. Kemudian file executable tersebut dijalankan dengan memasukkan data input. Output yang dihasilkan file executable akan dicocokan menggunakan output data yang diambil dari struktur data yang telah disediakan sebelumnya. Berikut ini langkah-langkah yang akan diambil oleh modul output grader.
Kode sumber bahasa C
1 Parse kode sumber bahasa C
2 C parser sukses?
Intent Recognition
Sistem Penjelas Kompilasi kode sumber
Proses evaluasi jawaban oleh output grader
3
Sistem Perbaikan Otomatis
4 Tugas berikutnya atau keluar
Gambar 4 Arsitektur Modul Evaluasi.
5
Kode sumber bahasa C hasil pekerjaan siswa melalui proses kompilasi menggunakan Digital Mars C Compiler yang menghasilkan file executable (exe). File yang XML berisi input output data dibaca dan disimpan dalam memori, data ini lah yang digunakan sebagai patokan benar atau tidaknya hasil pekerjaan yang dilakukan oleh siswa File eksekusi hasil kompilasi dari kode sumber bahasa C dijalankan dan data input dimasukkan dalam standard input (stdin). Operasi ini akan menghasilkan output dari program. hasil output dari program akan dibandingkan dengan data output yang diperoleh dari data input/output. dari hasil perbandingan ini dapat ditentukan apakah pekerjaan siswa benar atau salah.
Perancangan Struktur Penyimpanan Data
Langkah-langkah di atas dapat digambarkan dalam sebuah bagan seperti pada Gambar 5.
Struktur penyimpanan data aplikasi harus sefleksible mungkin dan semudah mungkin dimanipulasi. Ada beberapa alternatif penyimpanan data yang lazim digunakan dalam aplikasi, seperti misalnya: relational database, text file, serializable object atau dokumen XML.
Compiler yang digunakan adalah DMC dari Digital Mars. Sedangkan metode untuk menjalankan Sistem output grader dilakukan dengan memasukkan data ke standard input (stdin) dan mengambil output dari standard output (stdout) dari program hasil kompilasi.
2
Data yang harus disimpan adalah: a b c d e 3
Soal dan pertanyaan Jawaban Data evaluasi Hasil evaluasi Tingkat kesulitan soal
Perancangan Output Grader
Output grader bertugas untuk menilai hasil jawaban siswa. Output grader merupakan modul implementasi dari strategi penilaian. Proses penilaian akan dilaksanakan jika siswa memasukkan kode yang benar tanpa ada kesalahan. Kode sumber akan dikompilasi
Set elah output grader selesai dilaksanakan, akan dihitung persentase keberhasilan tes ini. Semakin banyak item dalam output grader diharapkan semakin akurat hasil penilaian terhadap pekerjaan siswa. Penilaian terhadap pekerjaan siswa diperoleh dari rasio antara tes yang benar dan jumlah tes. Nilai = (Jawaban benar / Jumlah tes) * 100
9
Program hasil kompilasi kode sumber Memasukkan data input ke dalam program hasil proses kompilasi
Baca data input dari penyimpanan data
Baca data output dari penyimpanan data
Membandingkan data output dengan output dari program hasil kompilasi
Hasil evaluasi output grader
Gambar 5 Langkah-langkah dalam modul Output Grader . 4
Perancangan Intent Recognition
Beberapa jenis sistem pembelajaran cerdas, memerlukan solusi yang spesifik terhadap persoalan yang diberikan kepada siswa, kemudian jawaban siswa akan dicocokan karakter demi karakter dengan solusi tersebut. Bentuk sistem pembelajaran cerdas tersebut sangat kaku dan tidak dapat mengakomodasi jawaban siswa yang sangat bervariasi. Intent Recognition menyempurnakan kelemahan ini dengan berusaha mengerti jawaban siswa tanpa harus membandingkanya huruf demi huruf dengan solusi yang telah ditentukan terlebih dahulu. Intent Recognition praktis merupakan language recognition tools untuk mengenali bahasa C. Kata Intent berarti bahwa proses pemeriksaan bahasa C oleh Intent Recognition disertai dengan ”tujuan” tertentu selain hanya memeriksa saja. Intent Recognition akan memeriksa kode sumber jawaban siswa dengan tujuan:
lexer dan mencocokkannya dengan kumpulan aturan-aturan yang mendefinisikan tata bahasa C. Kumpulan aturan yang mendefinisikan tata bahasa C disebut C Language Grammar Specification. Seperti sudah dibahas di bagian sebelumnya, terdapat dua jenis rule: lexer rule dan parser rule. Setiap rule pada dasarnya merupakan satu mesin DFA (Deterministic Finite Automata). Lexer rule adalah DFA yang memuat rangkaian langkah dan state untuk mengubah karakter menjadi token. Sedangkan parser rule adalah DFA yang memuat rangkaian langkah dan state untuk memvalidasi urutan token, apakah sudah memenuhi grammar atau tidak. Perbedaan utama lexer rule DFA dan parser rule DFA adalah set input yang diterima lexer rule adalah karakter dengan hasil string yang diterima DFA adalah token. Parser rule mempunyai set input berupa token dengan hasilnya berupa statement (kalimat) yang valid. DFA dapat divisualisasikan menggunakan notasi graph. Gambar 6 menggambarkan DFA yang menerima string Identifier dalam bahasa C sebagai valid input. String Identifier dalam bahasa C harus diawali dengan huruf atau karakter $ atau _, kemudian boleh diikuti dengan huruf, angka, $ dan _. Definisi DFA: 1 2 3
4 5
Q = {q0 , q1 } ? = {$, _, 0..9, a..z, A..Z} d = { d(q0 ,$) = q1 , d(q0 ,_) = q1 , d(q0 ,a..z) = q1 , d(q0 ,A...Z) = q1 , d(q1 ,$) = q1 , d(q1 ,_) = q1 , d(q1 ,a..z) = q1 , d(q1 ,A...Z) = q1 , d(q1 ,0..9) = q1 } q0 F = {q0 ,q1 }
a Mencari kesalahan dalam kode sumber. b Menjelaskan kesalahan. c Mencatat kesalahan yang bisa diperbaiki secara terotomasi. d Mencatat semua token dalam tabel token. Bagian utama dari Intent Recognition adalah lexer dan parser untuk memeriksa kode sumber siswa. Lexer akan membaca karakter per karakter kode sumber siswa. Kemudian mengubah aliran karakter menjadi aliran token. Parser akan mengambil setiap token yang dihasilkan oleh
Gambar 6 DFA untuk menerima string Identifier dalam bahasa C. DFA pada Gambar 6 di atas termasuk ke dalam kategori DFA yang merepresentasikan
10
lexer rule, hal ini terlihat jelas dari simbol input, ?, yang terdiri dari karakter. Definisi DFA: 1 2 3
4 5
Q = {q0 , q1 , q2 , q3 , q4 , q5 } ? = {’if’, ’)’, ’(’, expression, statement, ’else’} d = { d(q0 , ’if’)=q1 , d(q1 , ’(’)=q2 , d(q2 , expression)=q3 , d(q3 , ’)’)=q4 , d(q4 , statement)=q5 , d(q5 , ’else’)=q6, d(q6, statement)=q7 } q0 F = {q5 , q7 }
Start
Tujuan pertama dari Intent Recognition adalah mencari kesalahan dalam kode sumber. Proses pencarian kesalahan terjadi dalam parser rule. Ketika DFA berusaha mencocokkan aturan dalam fungsi transisi (d) dengan token yang berhasil dikenali oleh lexer rule, DFA akan melaporkan kesalahan jika fungsi transisi tidak dipenuhi. Setiap kesalahan akan mempunyai kategori, hal ini untuk memudahkan penjelasan kesalahan oleh Intent Recognition dan memudahkan sistem perbaikan terotomasi dalam memperbaiki kesalahan. Intent Recognition mempunyai tabel simbol yang mencatat semua simbol Identifier yang valid dalam kode sumber. Ketika DFA menemukan sebuah Identifier, Intent Recognizer akan tahu apakah Identifier itu sedang didefinisikan atau sedang digunakan. Jika Identifier sedang didefinisikan, maka Intent Recognition akan menambahkan simbol tersebut dalam tabel simbol. Jika Identifier sedang digunakan, maka Intent Recognition akan mencari Identifier dalam simbol tabel. Jika Identifier belum ada pada tabel simbol, maka telah terjadi kesalahan dalam kode program.
Gambar 7 DFA untuk memvalidasi sintaks if dalam bahas a C. Gambar 7 menerangkan DFA yang berasal dari parser rule untuk memvaliadasi sintaks if dalam bahasa C. Token ’if’ berada di depan kemudian harus diikuti dengan token ’(’ setelah itu diikuti oleh rule lain yang disebut expression. Token berikutnya adalah ’)’ diikuti dengan statement. Statement ini bisa merupakan apa saja, bisa saja statement tersebut adalah if, hal ini mengijinkan bahasa C untuk mempunyai nested if. Setelah statement, ada token ’else’. Token setelah ’else’ adalah rule lain yaitu statement. Seperti yang telah disinggung sebelumnya, statement bisa apa saja, bisa juga if lain, pola ini yang mengijikan adanya bentuk else if dalam bahasa C.
Algoritma transformasi token akan dipanggil untuk mencari kemungkinan apakah token Identifer bisa ditransformasikan menjadi token lain yang ada dalam tabel simbol. Jika Identifier berhasil ditransformasi menjadi Identifier yang cocok dengan tabel simbol, Identifier tersebut dicatat sebagai kesalahan yang bisa diperbaiki. Jika Identifier tidak berhasil ditransformasi menjadi Identifier yang cocok, maka Intent Recognition hanya akan memberikan penjelasan kesalahan dan mengkategorikannya sebagai kesalahan yang tidak dapat diperbaiki secara terotomasi. Cara ini memenuhi tujuan ketiga Intent Recognition, y aitu mencatat kesalahan yang dapat diperbaiki secara terotomasi. Intent Recognition mempunyai kemampuan untuk menambahkan, menghapus satu token untuk membuat kode sumber menjadi valid. Jenis kesalahan seperti ini juga dicatat oleh Intent Recognition sebagai kesalahan yang dapat diperbaiki secara terotomasi. Sistem penjelas juga termasuk dalam Intent Recognition. Sistem penjelas bertugas untuk menjelaskan bagaimana kesalahan akan dijelaskan kepada siswa. Setiap kategori kesalahan akan mempunyai template penjelasan
11
yang sama. Menjelaskan setiap kesalahan dengan penjelasan yang berbeda merupakan pekerjaan yang sangat kompleks. Sistem penjelas menjalankan tujuan ketiga Intent Recognition: menjelaskan kesalahan dalam kode sumber. Aturan utama yang harus dipenuhi oleh Intent Recognition adalah menghindari propagasi kesalahan. Propagasi kesalahan adalah kesalahan yang diakibatkan oleh kesalahan sebelumnya. Propagasi kesalahan akan membuat Intent Recognition menemukan terlalu banyak kesalahan dan sistem penjelas menampilkan terlalu banyak kesalahan daripada seharusnya. Intent Recognition mencatat semua token baik yang valid atau tidak dalam tabel token. Tabel token diperlukan oleh sistem perbaikan terotomasi. Setiap token akan diberi nomor indeks yang unik. Misalnya untuk penghapusan satu token dan token tersebut banyak terdapat dalam kode sumber, diperlukan suatu identifier unik untuk setiap token. Algoritma Transformasi Token
d xy ditransformasikan dengan pemindahan posisi menjadi TS(yx) Misalnya, L={while}, dan terdapat string “Wihle” , ‘h’ dan ‘i’ adalah kesalahan letak
yang terbalik (T S), sedangkan ‘W’ adalah kesalahan penggantian simbol dengan simbol yang lainnya (T R). Wihle –TRà wihle –TSà while
Algoritma Kesalahan
1.
2.
a
Penggantian sebuah simbol dengan simbol yang lainnya (T R). b Penyisipan simbol (T I). c Penghapusan simbol (T D ). d Letak yang terbalik antara dua simbol (T S). Keempat kesalahan di atas dapat direpresentasikan dalam empat transformasi TR , TI, TD , dan TS . Transformasi-transformasi tersebut dirumuskan sebagai berikut. Misalkan x dan y adalah karakter yang ada dalam token, sedangkan a dan b adalah karakter yang akan ditambahkan atau dihapus dari token. xby ditransformasikan dengan penggantian satu huruf menjadi T R(xay) untuk a <> b b xay ditransformasikan dengan penyisipan satu huruf menjadi T I(xy) untuk semua a c xy ditransformasikan dengan penghapusan satu huruf menjadi T D(xay) untuk semua a
dan
Pencatatan
Untuk melakukan perbaikan kesalahan Intent Recognition mengambil langkah-langkah algoritmik sebagai berikut, sebagian langkah diilhami oleh konsep Intent Recognition yang digagas oleh Franek (2003):
Misalkan L adalah himpunan tidak kosong yang terdiri dari simbol-simbol yang digunakan dalam bahasa C. Asumsikan bahwa sebuah string yang tidak terdapat dalam L dapat diturunkan dari string dalam L dengan melakukan serangkaian transformasi kesalahan. Modul Intent Recognition mengenal empat buah buah tipe kesalahan sintaks:
a
Pemeriksaan
3.
Lexer memeriksa kode sumber yang ditulis siswa dan berusaha mengubahnya menjadi token. Misalkan S adalah aliran karakter yang akan dirubah menjadi token T. Jika T adalah Identifier, a Parser akan memeriksa apakah parser sedang dideklarasikan atau sedang digunakan. b Jika sedang dideklarasikan, maka T akan dimasukkan dalam tabel simbol. c Jika sedang digunakan T akan dicocokkan dengan Identifier dalam tabel simbol. d Jika parser tidak menemukan T dalam tabel simbol, maka transformasi TR , TI, TD dan TS akan dijalankan untuk mendapatkan token yang valid. e Jika transformasi berhasil, Intent Recognition akan mencatat kesalahan sebagai kesalahan yang dapat diperbaiki secara terotomasi. Kemudian panggil sistem penjelas untuk menampilkan kesalahan. f Jika transformasi gagal cukup panggil sistem penjelas untuk menampilkan kesalahan, dan beri keterangan sebagai kesalahan yang bisa diperbaiki secara terotomasi. Parser akan memvalidasi token menggunakan parser rule. a Jika valid maka token akan disimpan oleh parser sebagai valid token. b Jika tidak valid, lakukan percobaan untuk menghapus atau menambahkan satu token. Jika berhasil catat sebagai
12
kesalahan yang dapat diperbaiki secara terotomasi.
Lexer memeriksa kode sumber dan mengubah karakter menjadi token
Proses pemeriksaan dan pencatatan kesalahan oleh Intent Recognition digambarkan pada Gambar 8. 5
Perancangan Terotomasi
Sistem
Lexer menemukan token Identifier?
Perbaikan
Sistem perbaikan terotomasi bekerja sangat erat dengan Intent Recognition. Ketika Intent Recognition memeriksa kode sumber dan terjadi kesalahan dalam kode sumber, Intent Recognition akan memeriksa apakah kesalahan bisa diperbaiki secara terotomasi. Proses perbaikan terotomasi dilaksanakan setelah Intent Recognition selesai memeriksa semua kode sumber. Kesalahan yang bisa diperbaiki secara terotomasi dicatat oleh Intent Recognition. Kesalahan penulisan token Identifier, yang dap at diperbaiki menggunakan algoritma transformasi token dicatat dalam satu tabel. Sedangkan kesalahan karena penambahan atau pengurangan satu token dicatat dalam tabel yang lain. Pemisahan ini untuk mempermudah proses perbaikan terotomasi.
tidak
token Identifier ada dalam tabel simbol?
Transformasi T R, T I, T D, T S digunakan untuk mendapatkan token Identifier yang valid
tidak
ya Transfromasi tidak berhasil? ya Token baru dibuat dan dicatat oleh IR Token diproses oleh parser
Perbaikan kesalahan penulisan Identifier dilakukan terlebih dahulu. Proses perbaikan sangat sederhana, menemukan nomor urut token dalam tabel token, kemudian mengganti token tersebut dengan token yang benar. Tidak ada perubahan nomor urut token. Proses perbaikan kesalahan karena penambahan atau pengurangan satu token lebih rumit dibanding perbaikan kesalahan penulisan Identifier. Jika kesalahannya karena penambahan satu token, proses perbaikan harus menemukan nomor urut token yang berlebih tersebut, kemudian menghapusnya. Proses pengapusan ini dicatat dalam tabel perubahan token, karena akan mempengaruhi nomor urut token. Sebaliknya jika kesalahannya karena ada satu token yang tidak lengkap, proses perbaikan terotomasi harus menemukan token terakhir sebelum token yang hilang. Kemudian menyisipkan satu token pada posisi yang telah ditentukan. Proses penyisipan juga dicatat dalam tabel perubahan token.
ya
token berhasil divalidasi oleh parser?
ya Token dimasukkan dalam tabel token Penambahan atau penghapusan satu token dicatat oleh Intent Recognition
sistem penjelas menjelaskan kesalahan tidak
Apakah menambahkan atau menghapus satu token berhasil?
tidak
ya
Gambar 8 Algoritma p emeriksaan dan pencatatan kesalahan oleh Intent Recognition. Proses perbaikan terotomasi berjalan secara interaktif. Siswa dapat memutuskan untuk menjalankan proses perbaikan kesalahan terotomasi atau tidak. Pilihan yang bisa diambil oleh siswa ada tiga: a
Yes: siswa menerima proses perbaikan terotomasi.
13
b No: siswa menolak perbaikan terotomasi yang sedang dilaksanakan. c Cancel: siswa membatalkan semua perbaikan terotomasi yang akan dilaksanakan. 6
Perancangan Antarmuka
Antarmuka modul dalam Gambar 9: Jendela Project
evaluasi
digambarkan
Menu bar, Tool bar Jendela Kode
Jendela Soal Jendela Output
Gambar 9 Perancangan Antarmuka Modul Evaluasi. Gambar 9 memperlihatkan empat buah jendela utama: a
Jendala kode: menampilkan kode sumber jawaban siswa. Jendela kode merupakan text editor yang mempunyai fasilitas seperti: copy, paste, cut, find, undo, redo, save dan nomor baris. b Jendela project: menampilkan struktur data dari modul evaluasi, setiap soal ditampilkan dalam bentuk tree. Jendela project juga menampilkan file .c hasil jawaban siswa atas setiap pertanyaan. c Jendela soal: menampilkan pertanyaan secara lengkap, termasuk data input/output yang digunakan oleh output grader . d Jendela output: menampilkan penjelasan kesalahan kode sumber dan keterangan tentang event yang sedang terjadi dalam modul evaluasi. Implementasi 1
Implementasi Data
Struktur
Penyimpanan
Struktur penyimpanan data yang dipilih adalah XML. Format XML yang fleksibel menjadi kelebihan utama XML dibanding format penyimpanan data lain, seperti basis data relasional.
Berikut ini adalah struktur dokumen XML yang digunakan dalam modul evaluasi untuk merepresentasikan satu buah soal: 1
2 <soal id="1"> 3 faktorial 4 buat sebuah aplikasi yang menghitung bilangan faktorial 5 6 <sintaks-khusus> 7 <elemen>for 8 <elemen>if 9 10 <jawaban-jawaban> 11 <jawaban id="1" asupan="0" keluaran="1"/> 12 <jawaban id="2" asupan="1" keluaran="1"/> 13 <jawaban id="3" asupan="2" keluaran="2"/> 14 <jawaban id="4" asupan="3" keluaran="6"/> 15 16 mudah 17 <waktu-mengerjakan>3 18 tidak 19 20 ; int main(){ int a, b; ]]> 21 22 23 24 25
Tag ITS adalah tag root dalam dokumen XML ini. Setiap dokumen ITS ini bisa diibaratkan satu modul latihan soal untuk setiap satuan pengajaran, misalny a per bab. Dalam setiap modul latihan soal, terdapat beberapa soal yang harus diselesaikan oleh siswa. Dalam setiap definisi soal akan disertakan data, antara lain: a b c d e f
Id soal. Nama soal. Pertanyaan. Sintaks khusus yang harus terdapat dalam jawaban siswa. Data untuk output grader. Tingkat kesulitan soal.
14
Start to test… ************* In: 2 Out: 4 Status: Correct In: 3 Out: 8 Status: Correct In: 4 Out: 16 Status: Correct In: 5 Out: 32 Status: Correct ************ Total: 4 test Correct: 100% Wrong: 0%
g Waktu normal yang dibutuhkan siswa untuk mengerjakan soal (dalam satuan menit) h Status soal, apakah sudah terjawab atau belum. i Hasil jawaban siswa berupa kode sumber. j Template atas dan template bawah yang ditujukan untuk output grader . Pengajar mendefinisikan dokumen soal sebagai bahan evaluasi sekaligus pembelajaran bagi siswa. Dokumen yang berbentuk XML ini idealnya harus divalidasi menggunakan XML Schema atau DTD (Data Transformation Diagram), namun untuk saat ini masih belum dicakup dalam penelitian ini. 2
Implementasi Output Grader
Output grader diimplementasikan menjadi class Grader. Di dalam class Grader terdapat dua buah method compile dan grade. Method compile bertugas mengkompilasi kode sumber bahasa C menjadi file executable, method compile mempunyai tipe kembalian boolean. Jika proses kompilasi berhasil, method compile akan mengembalikan true, dan nilai false dikembalikan jika proses kompilasi gagal. Modul
evaluasi
memanggil
method
compile untuk menget ahui apakah terdapat
kesalahan atau tidak dalam kode sumber. Jika method compile mengembalikan nilai false, berarti terdapat kesalahan dalam kode sumber. Modul evaluasi selanjutnya akan memanggil Intent Recognition untuk menganalisa kode sumber. Method grade digunakan untuk menjalankan proses grading. Salah satu parameter input dari method grader adalah object dari class Soal yang didalamnya terdapat data pasangan input dan output. Parameter lainnya tentu saja adalah file executable yang dihasilkan jika method compile mengembalikan nilai true. Method grade akan mengeksekusi executable file dengan memasukkan data input, kemudian mengambil hasil output dari hasil eksekusi tersebut. Hasil output akan dibandingkan dengan data output. Jika sama, maka kode sumber yang ditulis siswa benar, jika berbeda artinya terdapat kesalahan logika dalam penulisan kode sumber. Berikut ini ditampilkan contoh hasil keluaran dari output grader :
3
Implementasi Intent Recognition
ANTLR (ANother Tool for Language Recognition) adalah sebuah pustaka Java yang menyediakan alat untuk membuat language recognition, language generator dan translator. ANTLR menyediakan bahasa mark-up tingkat tinggi untuk mendefinisikan grammar dari sebuah bahasa, kemudian membuat lexer dan parser untuk mengenali grammar dari bahasa tersebut. Bahasa mark-up tersebut adalah grammar specification. Grammar specification merupakan sekumpulan rule-rule yang mirip regular expression. Seperti yang telah dibahas dalam perancangan, terdapat dua jenis rule, yaitu lexer rule dan parser rule. Lexer rule digunakan untuk mendefinisikan bagaimana memotong-motong karakter menjadi token, berikut ini contoh implementasi dari lexer rule untuk mengenali Identifier seperti diterangkan DFA dalam Gambar 6: IDENTIFIER : Letter (Letter|'0'..'9')* ; fragment Letter : 'a'..'z' | 'A'..'Z' | '$' | '_' ;
Dua buah lexer rule di atas digunakan untuk mendefinisikan token dengan tipe Identifier. Identifier adalah token yang terdiri dari kombinasi huruf a-z, A–Z, $ dan _. Dalam konsep bahasa, lexer rule digunakan untuk mengubah huruf menjadi kata. Parser rule digunakan untuk memeriksa apakah urutan dari token sudah sesuai dengan grammar (tata bahasa) atau belum. Setiap bahasa, termasuk C, mempunyai tata bahasa yang harus dipatuhi, kesalahan urutan token membuat
15
program tersebut melanggar tata bahasa yang sudah ditentukan. Dalam konteks bahasa indonesia, mirip dengan pengertian: apakah suatu urutan kata (token) sudah sesuai dengan kaidah Subjek Predikat Objek Keterangan (grammar) . Sebagai contoh, di bawah ini adalah parser rule untuk mengecek tata bahasa C untuk kondisi if-else seperti diterangkan DFA dalam Gambar 7. conditional_statement : 'if' '(' expression ')' statement ('else' statement)? ;
Grammar specification akan diterjemahkan menjadi Java class menggunakan ANTLR tool generator. Hasil terjemahannya adalah dua buah class: CLexer.java dan CParser.java. Setiap parser rule akan diterjemahkan menjadi sebuah public method dalam CParser.java dan setiap lexer rule akan diterjemahkan menjadi public method dalam CLexer.java. Gambar 10 adalah UML class diagram yang menggambarkan struktur class implementasi Intent Recognition dan sistem perbaikan terotomasi. Class ParserFacade memegang kendali proses pemeriksaan kode sumber. Method parse dari class ParserFacade akan memanggil class CLexer dan CParser, kemudian memerintahkan keduanya untuk mulai memeriksa kode sumber. Kode untuk memanggil lexer dan parser dalam class ParserFacade: 1 CharStream inputStream = new ANTLRFileStream(file.getPath()); 2 CLexer lexer = new CLexer(inputStream); 3 CommonTokenStream stream = new CommonTokenStream(lexer); 4 CParser parser = new CParser(stream); 5 parser.translation_unit();
Method translation_unit pada class CParser di atas memerintahkan parser untuk mulai memeriksa kode sumber. Setiap kali parser memeriksa kode sumber, method nextToken dari CLexer dipanggil untuk mengambil token berikutnya. Ketika parser rule gagal mengenali kode sumber, CParser akan membuat salah satu dari delapan subclass RecognitionException yang ada dalam Tabel 1.
Gambar 10 UML class diagram Intent Recognition dan Sistem Perbaikan Terotomasi. Class BaseRecognizer adalah superclass CParser yang mempunyai method emitErrorMessage yang bertugas untuk menjelaskan kesalahan yang ada dalam kode sumber. dari
Tabel 1 Daftar Jenis Kesalahan yang Dikenali oleh Lexer dan Parser. Jenis Kesalahan Recognition
Mismatched Token Mismatched Tree Node
Failed Predicate Mismatched Set
Keterangan Semua jenis kesalahan merupakan subclass dari Recognition. Mengindikasikan bahwa token yang dicari oleh parser tidak ada. M engindikasikan bahwa token yang dicari untuk membentuk Abstract Syntax Tree tidak ditemukan. Hasil evaluasi token oleh semantic predicate gagal Lexer berusaha mencocokkan sekumpulan simbol, tetapi gagal
16
Jenis Kesalahan No Viable Alternatives
Early Exit
Mismatched Range
Mismatched Not Set
Keterangan Kesalahan karena lookahead yang didefinisikan tidak cukup panjang untuk menentukan antara dua alternatif. Dengan kata lain grammar yang didefinisikan bersifat ambigu. Parser sampai pada rule yang menyaratkan kecocokan dengan satu alternatif atau lebih ( (..)+ ), tetapi rule tidak dapat mencocokkan dengan apapun. Lexer berusaha mencocokkan karakter yang sedang aktif dengan range karakter, dan ternyata gagal. Lexer berusaha mencocokkan kebalikan dari kumpulan simbol (~), tetapi gagal
Penjelasan terhadap kesalahan sangat sederhana, di mana setiap jenis kesalahan dijelaskan dengan minimal satu cara, sehingga minimal ada tujuh macam penjelasan kesalahan dalam kode sumber. D i bawah ini adalah cuplikan implementasi method emitErrorMessage y ang menerangkan kesalahan dengan jenis Mismatched Token. 1
if (e instanceof MismatchedTokenException ) 2 { 3 MismatchedTokenException mte = MismatchedTokenException) e; 4 String tokenName="
"; 5 if ( mte.expecting == Token.EOF ) { tokenName = "EOF"; 6 } else { 7 tokenName = tokenNames[mte.expecting]; 8 } 9 msg = "input " + getTokenErrorDisplay(e.token) + " tidak cocok" + " seharusnya "+tokenName; 10 }
Class CParser juga memeriksa apakah kesalahan bisa diperbaiki secara terotomasi. Seperti yang telah dibahas di bagian perancangan, terdapat dua jenis kesalahan yang dapat diperbaiki secara terotomasi. Kesalahan pertama adalah kesalahan penulisan Identifier. Kesalahan ini termasuk dalam jenis kesalahan Failed Predicate. Jika
kesalahan Failed Predicate ditemukan, CParser akan memanggil method getClosestToken dari class TokenTransformationManager untuk mendapatkan token Identifier yang paling mirip dengan token yang sedang diperiksa. Method getClosestToken mengimplementasikan algoritma transformasi token. Empat proses transformasi token TR , TI, TD , TS dilaksanakan terhadap token yang diperiksa, kemudian dicocokkan dengan simbol tabel. Jika proses transformasi berhasil mencocokkan token yang sedang diperiksa dengan token-token yang berada dalam tabel simbol, maka kesalahan Failed Predicate dapat diperbaiki secara terotomasi. Informasi kesalahan tersebut dicatat dengan membuat object dari class TokenTransformation. Setelah informasinya dicatat, informasi tersebut disimpan dalam class TokenTransformationManager . Kesalahan kedua adalah kesalahan Mismatched Token. Kesalahan Mismatched Token terjadi karena CParser berharap untuk menemukan suatu token tertentu ternyata yang ditemukan adalah jenis token yang lain. Misalnya setelah token ’(’ ditemukan, maka CParser akan mengharapkan token ’)’ akan ditemukan pada titik tertentu dalam kode sumber. Jika ternyata yang ditemukan adalah token dengan jenis lainnya, maka kesalahan ini dikategorikan sebagai Mismatched Token. Tidak semua jenis kesalahan Mismatched Token dapat diperbaiki secara terotomasi. Kesalahan Mismatched Token yang dapat diperbaiki dengan cara menambahkan atau menghapus satu token adalah kesalahan yang dapat diperbaiki secara terotomasi. Kesalahan Mismatched Token yang dapat diperbaiki dalam dua langkah penambahan atau penghapusan token, tidak dapat diperbaiki secara terotomasi. Class TokenCompletion mencatat informasi kesalahan dan class TokenCompletionManager menyimpan semua informasi tersebut. 4
Implementasi Terotomasi
Sistem
Perbaikan
Sistem perbaikan terotomasi berjalan setelah Intent Recognition selesai memeriksa semua kode sumber. Sistem perbaikan t erotomasi menggunakan informasi kesalahan dari class TokenCompletionManager dan class TokenTransformationManager sebagai basis untuk melakukan perbaikan secara terotomasi.
17
Proses perbaikan terotomasi dilaksanakan dalam dua tahap. Tahap pertama adalah memperbaiki kesalahan yang ada dalam class TokenTransformationManager . Informasi kesalahan tersebut akan dikirim ke class TokenChangeManager, kemudian class TokenChangeManager akan merubah token yang ada dalam text editor. Proses perbaikan kesalahan Mismatched Token dalam TokenTransformationManager sangat sederhana. Token yang salah akan digantikan oleh token yang benar, tidak ada perubahan nomor indeks token, hanya pergantian teks biasa. Tahap kesalahan
kedua adalah yang
proses ada
perbaikan dalam TokenCompletionManager. Informasi kesalahan akan dikirimkan ke class TokenChangeManager, kemudian akan diputuskan apakah perubahan yang terjadi merupakan penyisipan satu token atau penghapusan satu token, berdasarkan pada informasi yang terkandung dalam object TokenCompletion. Proses penyisipan atau penghapusan kesalahan direkam oleh TokenChangeManager, hal ini dikarenakan terjadi perubahan nomor indeks dari tabel token. Penyisipan satu token akan menyebabkan indeks token setelah penyisipan bertambah satu, dan penghapusan satu token akan menyebabkan indeks token setelah penghapusan berkurang satu. Jika perubahan indeks token ini tidak dihitung secara cermat, TokenChangeManager akan menyisipkan atau menghapus token di tempat yang salah. Sistem perbaikan terotomasi mempunyai hubungan langsung dengan kode sumber yang ada dalam text editor. Setiap kali sistem perbaikan terotomasi merubah kode sumber, perubahan tersebut langsung terlihat pada text editor. Class javax.swing.text.Document menyimpan semua text yang ditampilkan oleh text editor. Jika isi dari class Document dirubah, maka tampilan dari text editor juga berubah. Di bawah ini kode yang digunakan oleh sistem perbaikan terotomasi untuk mengganti token yang salah dengan token yang benar pada class Document: 1 2
public static void transformToken( Document doc, int index, String newToken){ int listIndex = getListIndex(doc, index);
3 4 5 6 7 8 9
5
int position = getPosition(doc, index); List tokens = getTokenList(doc); String oldToken = (String)tokens.get(listIndex); doc.remove(position, oldToken.length()); doc.insertString(position, newToken, null); tokens.set(listIndex, newToken); }
Proses Tutorial
Proses perbaikan kesalahan oleh Intent Recognition, tidak dilakukan secara otomatis untuk semua kesalahan, namun melibatkan siswa untuk melakukan klarifikasi atas perbaikan kesalahan yang dilakukan oleh Intent Recognition. Hal ini akan menyebabkan hanya perubahan yang disetujui oleh siswa yang akan benar-benar dilakukan. Dengan demikian siswa diajak untuk berfikir bagaimana memperbaiki kesalahan dengan sesedikit mungkin bergantung pada Intent Recognition. Berikut ini dialog yang akan terjadi antara siswa dengan IR: inr I,val=1 For ( I = 0 ; I <= 4 ; I++{ Val *= 2; }
IR: “apakah maksud anda adalah keyword “int”?” Siswa: Ya Intent Recognition akan melakukan perubahan terhadap string “inr” menjadi “int” dan parser akan memvalidasi perubahan ini karena user telah mengklarifikasi perubahan. Hasil perbaikan: int I,val=1 For ( I = 0 ; I <= 4 ; I++{ Val *= 2; }
IR: “apakah maksud anda menambahkan “;” setelah “val=1” “? Siswa: Ya Hasil perbaikan: int I,val=1; For ( I = 0 ; I <= 4 ; I++{ Val *= 2; }
IR: “apakah maksud anda adalah keyword “for” ?“ Siswa: Ya Hasil perbaikan: int I,val=1; for ( I = 0 ; I <= 4 ; I++{
18
Val *= 2;
}
}
IR: “apakah maksud anda menambahkan “)” diantara “I++” dan “{“ “? Siswa: Ya Hasil perbaikan: int I,val=1; for ( I = 0 ; I <= 4 ; I++){ Val *= 2; }
IR: “apakah maksud anda adalah variabel “val” “? Siswa: Ya Hasil perbaikan: int I,val=1; for ( I = 0 ; I <= 4 ; I++){ val *= 2;
Proses tut orial ini bersifat dinamik, siswa tidak harus mengikuti proses tutorial hingga semua kesalahan berhasil diperbaiki. Siswa bisa dengan mudah kembali ke text editor untuk memperbaiki kesalahannya secara langsung tanpa menunggu Intent Recognition melakukannya, kemudian memproses jawaban yang baru tersebut dari awal. 6
Implementasi Antarmuka Sistem
Antarmuka sistem disusun menurut kaidah usability yang baik. Dengan menggunakan komponen-komponen yang dimiliki oleh NetBeans Platform, sehingga tampilan aplikasi menjadi sangat menarik dan intuitif.
Gambar 11 Tampilan A ntarmuka Modul Evaluasi Tampilan aplikasi dibagi menjadi empat jendela utama seperti terlihat dalam Gambar 11. Jendela navigasi disebelah kiri digunakan untuk menampilkan soal-soal dan hasil pengerjaan siswa dalam bentuk Tree. Jendela utama disebelah kanan digunakan untuk menampilkan soal dan text editor untuk menuliskan jawabannya. Text editor dilengkapi dengan kemampuan editing standard: copy, cut, paste, undo dan redo. Jendela bagian bawah menampilkan output aplikasi. Output berupa penjelas an dari sistem penjelas tentang kesalahan yang dibuat oleh
siswa atau keterangan aktifitas yang terjadi dalam modul evaluasi. Jendela output juga digunakan sebagai kontrol untuk memperoleh interaksi dari user apakah memerlukan bantuan sistem perbaikan otomatis atau tidak. Output grader juga akan memanfaatkan jendela output untuk mencetak proses pengujian program siswa menggunakan data input/output yang telah didefinisikan untuk setiap soal. Secara umum, semua yang terjadi dalam sistem akan ditampilkan dalam jendela output.
19
7
Issue dalam Implementasi Sistem
ANTLR menyediakan banyak fitur yang bisa memotong waktu penulisan grammar hingga separuh lebih. Namun lingkungan pengembangan aplikasi ANTLR tidak cukup produktif. Pertama kita harus mendefinisikan grammar dengan menggunakan Grammar Specification Language, kemudian membangkitkan lexer dan parser menjadi file Java. Langkah berikutnya adalah melakukan kompilasi file Java menjadi class. Setelah itu lexer dan parser baru bisa dites menggunakan contoh bahasa yang akan dikenali.
Semua langkah tersebut dilaksanakan dalam aplikasi berbasis console, sehingga terasa sangat menyulitkan. Namun, beberapa waktu lalu direlease sebuah IDE dengan nama AntlrWorks. IDE ini digunakan untuk mengembangkan aplikasi ANTLR yang telah dilengkapi dengan tampilan yang intuitif, text editor dengan code completion, fasilitas debugging dan visualisasi ANTLR rule dalam bentung NFA ataupun DFA. Gambar 12 memperlihatkan tampilan dari AntlrWorks.
Gambar 12 AntlrWorks membantu mengembangkan aplikasi ANTLR. Text editor yang digunakan dapat telah dilengkapi dengan operasi dasar text editor, sehingga memudahkan user untuk menuliskan jawabannya. NetBeans Platform adalah framework dan pustaka pengembangan aplikasi desktop di Java yang masih sangat muda. Berbeda dengan pustaka swing yang telah mapan, NetBeans Platform tergolong masih muda. Oleh karena itu mencari sumber pembelajaran dan teman yang dapat ditanyai mengenai NetBeans platform sangat sulit. Konsep MVC (Model, View, Controller) yang diterapkan dalam NetBeans Platform pada
awalnya sangat membingungkan dan membutuhkan waktu cukup lama untuk memahami alur pengembangan aplikasi. Namun setelah dikuasai, produktifitas menjadi meningkat sangat tajam. Dengan usaha yang tidak terlalu besar, aplikasi yang dihasilkan sangat memuaskan. Librari yang disediakan NetBeans platform sangat banyak, walaupun dokumentasinya minimalis. 8
Kelebihan Sistem
Dengan desain antarmuka yang intuitif, sistem terlihat profesional dan mudah digunakan oleh user. Menu, toolbar dan icon yang digunakan disesuaikan dengan kebutuhan user,
20
untuk mempermudah pekerjaan user dan tidak membingungkan.
Tabel 2 Hasil Pengujian Modul Evaluasi Uji
Ok
Black box Testing
9
9
100
Pengujian Intent Recognition dalam mengenali struktur dasar bahasa C tanpa kesalahan
13
13
100
Pengujian Intent Recognition dalam mengenali kesalahan sederhana
13
9
69
NetBeans Platform telah dilengkapi dengan sistem docking yang superior. Jendela aplikasi dapat dipindahkan ke sana kemari sesuai selera user, sehingga user dapat mengkustomisasi tampilan sistem sesuai dengan preference masing-masing.
Pengujian Intent Recognition dalam mengenali kesalahan yang kemungkinan dapat diperbaiki secara terotomasi
14
9
64
9
Pengujian Kinerja Sistem Perbaikan Terotomasi
9
7
78
Jendela output sangat informatif memberikan informasi lengkap tentang apa yang sedang terjadi dalam sistem, sehingga user dengan dapat dengan mudah memantau kegiatan yang telah dilaksanakannya. Format penyimpanan data berbasis XML sangat fleksibel dan mudah dimengerti oleh pengajar. Hanya dengan berbekal text editor, pengajar bisa dengan mudah mendefinisikan modul soal untuk user. Penambahan dan pengurangan modul soal sangat gampang, hanya dengan menambahkan file XML yang telah dibuat, maka modul tersebut secara otomatis akan dikenali oleh sistem.
Kekurangan Sistem
Sistem yang dikembangkan dengan Java dan NetBeans platform memerlukan PC yang mempunyai sumber daya memadai. PC lama yang mempunyai sumber daya terbatas membuat kinerja sistem terasa lambat dan tidak responsif. Format penyimpanan data yang berupa XML memungkinkan siswa untuk berbuat curang dengan secara langsung merubah isi dari modul soal. Pengujian Kinerja Sistem Evaluasi Pengujian kinerja sistem evaluasi dibagi menjadi tiga bagian, bagian pertama adalah pengujian fungsionalitas antarmuka sistem dengan metode black box testing, hasil pengujian dapat dilihat di lampiran 3. Bagian kedua adalah pengujian kinerja Intent Recognition dengan melakukan serangkaian test untuk mengukur keberhasilan Intent Recognition dalam memeriksa kode sumber, hasil tes kinerja Intent Recognition dapat dilihat pada Lampiran 1. Bagian terakhir adalah pengujian kinerja sistem perbaikan terotomasi, hasilnya dapat dilihat pada Lampiran 2. Hasil pengujian modul evaluasi dapat dilihat pada Tabel 2:
Pengujian
%
Keterangan
Tabel simbol masih sederhana Proses pencarian kesalahan terlalu umum, seharusnya kasus per kasus Proses pencarian kesalahan terlalu umum, seharusnya kasus per kasus Proses perbaikan kesalahan terlalu umum, seharusnya kasus per kasus
Hasil pengujian menunjukkan bahwa Intent Recognition dapat mengenali 100% kode yang benar. Tetapi proses pendeteksian kesalahan dan perbaikan kesalahan masih harus ditingkatkan lagi untuk memperoleh persentase 100%. Kekurangan Intent Recognition terletak pada ”konteks”, Intent Recognition memeriksa kode program dengan aturan umum, tidak kasus per kasus. Pengujian Kompleksitas Modul Evaluasi
Algoritma
Pada
Analisis kompleksitas algoritma dalam modul evaluasi pada sistem pembelajaran cerdas: 1
LL(*) parser Parser dengan metode ini mempunyai efisiensi terburuk O(n2 ), tanpa adanya ambiguitas, efisiensinya adalah O(n).
2
Memoization Memoization digunakan untuk menghindari non deterministik dalam LL(*)
21
parser, mempunyai efisiensi O(n) dalam best case dan O(n2 ) dalam worse case. 3
Backtracking Backtracking adalah pilihan yang membutuhkan komputasi intensif karena dapat menyebabkan LL(*) parser mempunyai efisiensi exponensial, namun backtracking digunakan secara terbatas dalam kasus-kasus t ertentu saja, sehingga tidak semua kasus menggunakan backtracking. Efisiensi terburuk dari backtracking adalah O(n2 ).
4
Algoritma perbaikan otomatis a
Perbaikan kesalahan penulisan identifier Algoritma perbaikan kesalahan sintaks sangat sederhana dengan hanya mengetes apakah suatu pola tertentu dapat didekati dengan salah satu dari emp at metode pergantian: T R, T I, T D , T S. Efisiensi algoritmanya adalah linier O(n).
b Perbaikan kesalahan penghapusan atau penambahan satu token Algoritma untuk melakukan kesalahan semantik terbatas pada penghapusan satu token dan penambahan satu token. Algoritma ini akan mencari posisi dari token yang akan dihapus atau ditambahkan. Efisiensinya adalah linier O(n). KESIMPULAN DAN SARAN Kesimpulan Sistem pembelajaran cerdas menjanjikan solusi optimal untuk mengajarkan bahasa pemrograman kepada siswa. Metode pembelajaran private dapat dilaksanakan secara intensif menggunakan sistem pembelajaran cerdas. Modul evaluasi mengajarkan bahasa pemrograman kepada siswa dengan metode learning by doing. Metode learning by doing adalah metode paling tepat untuk mengajarkan bahasa pemrograman kepada siswa. Intent Recognition mengenali kode sumber yang dibuat oleh siswa, jika dalam proses pengenalan kode sumber ditemukan kesalahan,
sistem penjelas akan memberikan penjelasan yang memadai. Sistem perbaikan terotomasi membantu siswa memperbaiki kesalahan dalam kode sumber siswa, proses perbaikan kesalahan dilaksanakan secara interaktif. Kinerja Intent Recognition dalam mengenali kode sumber sudah 100% benar, tetapi kinerja Intent Recognition untuk mengenali kesalahan dan memperbaiki kode sumber secara terotomasi masih dibawah 100%. Hasil ini dikarenakan implementasi tabel simbol yang hanya menyimpan simbol saja, sedangkan metadata dari simbol tidak disimpan. Penyebab lainnya adalah proses pencarian kesalahan dilaksanakan dengan analisis umum untuk semua kasus, seharusnya ada analisis untuk kasus per kasus. Saran Penelitian ini dapat dilanjutkan dengan usaha untuk menyatukan semua modul sistem pembelajaran cerdas menjadi satu aplikasi yang lengkap dan dapat digunakan. Kinerja Intent Recognition yang berhasil disusun dalam penelitian ini masih dibawah 100%. Diperlukan usaha lebih lanjut untuk meningkatkan kinerja Intent Recognition dalam memeriksa kesalahan dan memperbaiki kesalahan secara terotomasi. Perbaikan tersebut dapat dilaksanakan dengan menambahkan unsur “konteks” pada proses pemeriksaan kesalahan. Perwujudan dari unsur “konteks” adalah tabel simbol yang menyimpan metadata dari setiap simbol dengan lebih lengkap. Tabel simbol tidak hanya menyimpan simbol saja, tetapi juga menyimpan informasi metadata dari simbol tersebut, misalnya tipe data, scope dan range data. Pengembangan Intent Recognition untuk bisa mengenali kesalahan logika. Salah satu cara untuk mengenali kesalahan logika adalah menggunakan metode static analysis . Metode static analysis lazim digunakan untuk mencari pola-pola kesalahan logika yang sering muncul dalam kode sumber. Pengembangan lebih lanjut sistem pembelajaran cerdas tidak hanya terbatas pada pengajaran bahasa C, tetapi juga bahasa pemrograman lain. Misalnya: bahasa pemrograman Java untuk mata kuliah Sistem Berorientasi Object dan SQL untuk mata kuliah Basis Data.
22
DAFTAR PUSTAKA Wasmana P. 2005. Pengembangan Modul Pakar pada Sis tem Pembelajaran Cerdas [tesis]. Bogor: Program Pascasarjana, Institut Pertanian Bogor. Fitriani A. 2005. Penyusunan Modul Pedagogig Sistem Pembelajaran Cerdas Dengan Ontology Model [Skripsi]. Bogor : Departemen Ilmu Komputer, Institut Pertanian Bogor. Sykes ER dan Franek F. 2003. A Prototype for an Intelligent Tutoring System for Students Learning to Program in Java. Sykes ER dan Franek F. 2003. Web-Based Architecture of an Intelligent Tutoring System for Remote Students Learning to Program Java. Sykes ER dan Franek F. 2003. Inside the Java Intelligent Tutoring System Prototype: Parsing Student Code Submissions with Intent Recognition. Parr T. 2007. The Definitive ANTLR Reference. West Sussex, England: Pragmatig Programming, LTD. Boudreau T, Tulach J, Wielenga G. 2007. Rich client programming: plugging into the NetBeans platform. Sun Microsystems. Pressman R. 2001. Software Engineering. West Sussex, England: John Willey & Sons, LTD. Parr T. 1999. Building Recognizers By Hand. http://www.antlr.org Grune D, Henri EB, Jacobs CJH, Langendoen KG. 2000. Modern Compiler Design. West Sussex, England: John Willey & Sons, LTD.
23
Lampiran 1 Glossary
Grader
ANTLR
Aplikasi yang menilai software hanya berdasarkan pada input dan output yang dihasilkan oleh softwre tersebut.
ANother Tool for Language Recognition adalah librari yang menyediakan bahasa tingkat tinggi untuk menyusun language recognizer. Language Recognizer Aplikasi yang digunakan untuk mengenali suatu bahasa pemrograman, terdiri dari gabungan antara lexer dan parser. AntlrWorks Aplikasi IDE (Integrated Development Environment) untuk membuat aplikasi language recognition dengan menggunakan ANTLR. AntlrWorks menyediakan text editor, visualisasi DFA dan NFA, debugging dan syntax highlighting . Production Rule Komponen dasar dalam sebuah grammar. Merupakan aturan untuk membuat sebuah kalimat dalam grammar tersebut. Terdiri dari lexer rule dan parser rule. Lexer Rule Salah satu jenis production rule yang bertugas untuk mendefinisikan aturan-aturan perubahan karakter menjadi token. Parser Rule Salah satu jenis production rule yang bertugas untuk mendefinisikan aturan-aturan pembentukan kalimat dari token-token yang dihasilkan lexer rule. Regular Expression Bahasa sederhana untuk mendefinisikan sebuah pola dalam string. Parser rule dan lexer rule menggunakan banyak sintak regular expression. Grammar Specification Kumpulan production rule yang menspesifikasikan sebuah bahasa pemrograman tertentu. Expression Kumpulan dari beberapa token yang menyusun bentuk operasi dasar seperti operasi aritmatika dan operasi logika. Statement Kumpulan dari token dan expression yang membentuk satu elemen utuh dalam bahasa pemrograman.
Java Bahasa pemrograman yang awalnya dikembangkan oleh Sun Microsystem, mempunyai sintak mirip dengan C++ dan merupakan bahasa pemrograman berbasis objek. Java berkembang menjadi teknologi yang handal digunakan untuk membuat solusi apapun, mulai dari embeded , mobile, desktop , web dan enterprise application . Swing Librari GUI yang tersedia dalam bahasa Java. Menyediakan komponen GUI yang lengkap dan fleksibel, seperti frame, panel, textbox dan sebagainya. UML Unified Modelling Language adalah notasi yang digunakan untuk merepresentasikan desain aplikasi yang berbasis objek. UML adalah abstraksi dari struktur aplikasi. UML digunakan dalam mendesain aplikasi berbasis objek, karena sifatnya yang abstrak, UML lebih mudah dipahami dan dimengerti dibanding melihat langsung kode sumber. MVC Model, View, Controller adalah pattern dalam aplikasi yang berusaha memisahkan komponen aplikasi berdasarkan fungsinya. Pemisahan ini memudahkan tim pengembang untuk tidak saling terikat secara erat dan dapat menyusun pembagian tugas dalam tim dengan lebih mudah. NetBeans Integrated Development Environment (IDE) yang dikembangkan oleh Sun Microsystem utamanya sebagai tools pengembangan java. NetBeans Platform Kumpulan librari yang dikembangkan untuk membuat NetBeans IDE. Librari ini dapat digunakan untuk membuat plugin dalam NetBeans IDE atau membuat aplikasi lain. XML eXtended Markup Language adalah bahasa markup yang digunakan utamanya sebagai penyimpanan data sederhana. XML sangat fleksibel dan standard, banyak digunakan sebagai format pertukaran data antar aplikasi atau digunakan sebagai format penyimpanan konfigurasi dari suatu aplikasi.
24
Lampiran 2 Pengujian kinerja Intent Recognition 1
Pengujian Intent Recognition dalam mengenali struktur dasar bahasa C tanpa kesalahan. Kode Keterangan Status *) #include <stdio.h> Struktur kode program standard untuk Ok int main(){ menjawab pertanyaan. Terdapat bagian input int input, output; (scanf) dan bagian output (printf ) scanf("%d",&input); printf("%d",output); return 0; } output = input * input; if(input > 10){ output = input * 10; } if(input > 10){ output = input * 10; } else { output = input * input; } if(input > 10){ output = input * 10; } else if(input<5) { output = input * input; } if(input > 10){ output = input * 10; } else if(input<5) { output = input * input; } else { output = input * input / 15; } if(input > 10 && input != 0){ output = input * 10; } if(input > 10){ output = input * 10; if(input < 5) output += 12; } int i; for(i=0;i0;j--){ output-=input/j; } } i = input; while(i>1){ output += input / i + 12; } i = input; do{ output += input / i + 12; }while(i>1); switch(input){ case 1: output = input * input; break; case 2: output=input * in put + i; break; case 3: output = input / input; break; default: output = 0;}
Kode program sederhana untuk mengolah input menjadi output . Struktur if sederhana dalam C.
Ok
Struktur if-else sederhana dalam bahasa C.
Ok
Struktur if-else if sederhana dalam bahasa C
Ok
Struktur if-else if- else sederhana dalam bahasa C
Ok
Struktur if dengan expresi yang lebih dari satu operasi logika.
Ok
Struktur if bersarang (nested)
Ok
Struktur dasar iterasi for
Ok
Iterasi for bersarang (nested)
Ok
Iterasi while sederhana
Ok
Iterasi do-while sederhana
Ok
Penggunaan struktur switch-case sederhana
Ok
*) Status keberhasilan pengenalan kode program
Ok
25
2
Pengujian Intent Recognition dalam mengenali kesalahan sederhana. Kode
Int input, output; scanf("%d",&input); output = variabel; printf("%d",output); return 0; Int input, output, input; output = input * input output = input * ; For(i=0;i<10;i++{ output += input * i; } For(i=0;i<10;i++){ output += input * i; do{ output += input / i + 12; } { output += input / i + 12; }while(i>1); while(){ output = input * 21; } include <stdio.h> #include <stdio.h #include stdio.h Int input, output; double x; output = x;
Kesalahan Penggunaan variabel yang belum didefinisikan
Status *) Ok
Pendeklarasian variabel yang sama lebih dari sekali Tidak ada token ; di akhir sebuah baris Statement yang tidak lengkap Iterasi for yang tidak lengkap, token ‘)’ tidak ada
Ok
Stetement for yang tidak dilengkapi dengan token ‘}’ Iterasi do yang tidak diakhiri dengan while
Ok
Iterasi yang seharusnya diawali do dan diakhiri while, tetapi do -nya tidak ada
Gagal
Tidak ada ekspresi didalam while()
Ok
Ekspresi include yang tidak diawali token # Ekspresi include yang tidak diakhiri tanda > include yang tidak diawali < dan diakhiri > Assingment antara dua buah tipe data yang berbeda
Ok Gagal Gagal Gagal
Ok Ok Ok
Ok
*) Status keberhasilan pendeteksian kesalahan. 3
Pengujian Intent Recognition dalam mengenali kesalahan yang kemungkinan dapat diperbaiki secara terotomasi. Kode
Int input, output; output = inpu * 21; Int input, output; output = inputx * 21; Int input, output; output = ipnut * 21; Int input, output; output = Input * 21; scanf("%d",&input) scanf("%d",&input; scanf "%d",&input); if(input > 10) output = input } if(input > 10){ output = input scanf("%d",&input)); scanf (("%d",&input); if(input > 10){{ output = input } if(input > 10){ output = input }} Fir(i=0;i<=input;i++){ }
* input;
* input;
* input;
* input;
Kesalahan Penghilangan satu karakter, inpu seharusnya input; Penambahan satu karakter, inputx seharusnya input; Pertukaran posisi antara dua karakter, ipnut seharusnya input. Substitusi satu karakter dengan karakter lain, Input yang seharusnya input Penghilangan satu token ‘;’ Penghilangan satu token ‘)’ Penghilangan satu token ‘(’ Penghilangan satu token ‘{‘
yang
Status *) Ok
yang
Ok
yang
Ok
yang
Ok Ok Ok Ok Gagal
Penghilangan satu token ‘}’
Gagal
Penambahan satu token ‘)’ Penambahan satu token ‘(’ Penambahan satu token ‘{‘
Ok Ok Gagal
Penambahan satu token ‘}’
Gagal
Pergantian keywords for menjadi fir
Gagal
*) Status keberhasilan dikenali sebagai kesalahan yang dapat diperbaiki
26
Lampiran 3 Pengujian kinerja sistem perbaikan terotomasi Kode
Kesalahan Hasil Perbaikan Penghilangan satu karakter, int input, output; output = input * 21; inpu yang seharusnya input; int input, output; Penambahan satu karakter, int input, output; output = inputx * 21; output = input * 21; inputx yang seharusnya input; int input, output; Pertukaran posisi antara dua int input, output; output = ipnut * 21; karakter, ipnut yang output = input * 21; seharusnya input. int input, output; Substitusi satu karakter dengan int input, output; output = Input * 21; karakter yang lain, Input yang output = input * 21; seharusnya input scanf("%d",&input) Penghilangan satu token ‘;’ scanf("%d",&input); dari statement scanf("%d",&input; Penghilangan satu token ‘)’ scanf("%d",&input); dari statement scanf "%d",&input); Penghilangan satu token ‘(’ scanf "%d",&input ; dari statement scanf("%d",&input)); scanf("%d",&input); Penambahan satu token ‘)’ scanf (("%d",&input); scanf (("%d",&input)); Penambahan satu token ‘(’ *) Status perbaikan terotomasi dari kode yang salah menjadi kode yang benar int input, output; output = inpu * 21;
Status *) Ok Ok Ok
Ok
Ok Ok Gagal Ok Gagal
27
Lampiran 4 Pengujian m odul evaluasi menggunakan metode Black box testing
