SKRIPSI DETEKSI KEMIRIPAN SOURCE CODE PADA BAHASA PEMROGRAMAN JAVA MENGGUNAKAN METODE ANALISIS LEKSIKAL
Diajukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana Teknik
HOLIS HERMANSYAH E1E1 11 035
JURUSAN TEKNIK INFORMATIKA FAKULTAS TEKNIK UNIVERSITAS HALU OLEO KENDARI 2016
i
ii
iii
iv
INTISARI Holis Hermansyah, E1E1 11 035 DETEKSI KEMIRIPAN SOURCE CODE PADA PEMROGRAMAN JAVA MENGGUNAKAN METODE LEKSIKAL
BAHASA ANALISIS
Skripsi, Fakultas Teknik, 2016 (xii+53+lampiran) Kata kunci : Source Code, Analisis leksikal,Java,Token,Plagiarism Laboratorium Pemrograman Jurusan Teknik Infomatika Fakultas Teknik Universitas Halu Oleo sebagai tempat pembelajaran bagi para mahasiswa informatika yang mengikuti kelas pemrograman selalu memberikan praktikum sebagai salah satu media pengukur tingkat pemahaman mahasiswa dalam hal membuat program. Banyaknya source code yang harus diperiksa oleh Dosen atau Assisten Laboratorium mengakibatkan sulitnya melakukan pemeriksaan serta sulitnya mengukur kredibilitas masing-masing tugas milik mahasiswa Metode deteksi kemiripan kode menggunakan Analisis Leksikal dapat digunakan untuk merubah kode menjadi token unik. Token ini digunakan untuk mengidentifikasi struktur program yang diperiksa. Sebelum proses pencocokan token menggunakan array, terlebih dahulu token yang terbentuk dari kedua source code yang diperiksa di sorting atau diurutkan berdasarkan abjad. Setelah itu dilakukan proses pencocokan string menggunakan array per posisi array. Semakin besar kemiripan alur dan kode program maka semakin besar kemungkinan kode tersebut merupakan plagiat. Nilai presentase kemiripan kode program yang dihasilkan dari proses pencocokan token ini yang nantinya digunakan sebagai acuan penentuan plagiarisme dengan ketentuan jika nilai presentase lebih besar atau sama dengan 70 % maka source dianggap plagiat, namun jika lebih kecil dari 70% tidak dianggap sebagai plagiat.
v
ABSTRACT Holis Hermansyah, E1E1 11 035 Source Code Similarity Detection in Java Programming Language Using Lexical Analysis Method Mini Thesis, Faculty of Engineering, 2016 (xii+53+attachments) Keyword : Source Code, Lexical Analysis, Java, Token, Plagiarism Programming Laboratory of Informatics Engineering Department of Engineering Faculty, Halu Oleo University is a learning place for college students majoring in informatics to follow programming class that become one of the standard to determine the student’s level of understanding in creating a program. Similarity detection method using Lexical analysis can be used to convert the programming code into an unique token. This token later used to identify the structure of a program that is being examined. After that, the token that already formed from two different source codes will be sorted alphabetically before entering the string matching process by using arrays. The string matching process will do the matching based on the position of each array. The more the similarities of the structure and the program codes, the more likely the code represented as plagiarism. The percentage value resulting from the token matching process later will be used as reference to determine the percentage of plagiarism in the program. If the similarities percentage greater than 70%, the examined source codes can be considered as plagiarism, but if it less than 70% the examined source codes will be not considered as plagiarism.
vi
KATA PENGANTAR
Assalamualaikum Wr. Wb.
Segala puji dan syukur penulis panjatkan kehadirat Allah SWT, karena atas rahmat dan ridho-Nya penulisan skripsi yang berjudul “Deteksi Kemiripan Source Code Pada Bahasa Pemrograman Java Menggunakan Metode Analisis Leksikal” ini dapat disusun dan diselesaikan sebagai syarat menyelesaikan studi di Jurusan Teknik Informatika Fakultas Teknik Universitas Halu Oleo Kendari. Pada kesempatan ini dengan segala kerendahan hati penulis haturkan sebuah ucapan terima kasih yang sebesar-besarnya kepada : 1.
Allah SWT yang telah menciptakan dan menuntun penulis hingga dapat menyelesaikan skripsi ini.
2.
Ayahanda Jamidin, ibunda Saliyah, saudaraku Nuryoni, S.Pi, Sunarty, S.Ip, dan Nurmiftahuddin, S.Hut atas doa dan dukungan moral yang diberikan kepada penulis.
3.
Bapak Bambang Pramono, S.Si.,MT dan Bapak Subardin, ST., MT sebagai dosen pembimbing skripsi yang banyak memberikan masukan dan saran serta ketersediaan untuk meluangkan waktunya dengan penulis untuk memberikan arahan – arahan yang sangat berguna.
4.
Andi Iswahyuningsih, ST , Na’firul Hasna Ariyani dan Hasrul Dimas Asgari yang turut membantu penulis dalam menyelsaikan tugas akhir ini.
5.
Kawan-kawan di jurusan Teknik Informatika, khususnya angkatan 2011 dan kawankawan di Fakultas Teknik pada umumnya yang memberikan saran dan semangatnya selama proses penyelesaian skripsi ini.
Dengan keterbatasan pengalaman, pengetahuan maupun pustaka yang ditinjau, penulis menyadari bahwa tugas akhir ini masih banyak kekurangan dan perlu pengembangan lebih lanjut agar benar-benar bermanfaat. Oleh sebab itu, penulis sangat mengharapkan kritik dan saran agar
tugas akhir ini lebih sempurna serta sebagai
masukan bagi penulis untuk penelitian dan penulisan karya ilmiah di masa yang akan datang.
vii
Akhir kata, penulis berharap tugas akhir ini memberikan manfaat bagi kita semua.
Kendari,
April 2016
Penulis
viii
DAFTAR ISI HALAMAN JUDUL ...................................................................................... i HALAMAN PENGESAHAN ........................................................................ ii HALAMAN PERNYATAAN ....................................................................... iv INTI SARI ...................................................................................................... v ABSTRACT ................................................................................................... vi KATA PENGANTAR ................................................................................... vii DAFTAR ISI .................................................................................................. ix DAFTAR TABEL ........................................................................................... xi DAFTAR GAMBAR ..................................................................................... xii BAB I PENDAHULUAN .............................................................................. 1 1.1 Latar Belakang ................................................................................. 1 1.2 Rumusan Masalah ............................................................................ 2 1.3 Batasan Masalah .............................................................................. 2 1.4 Tujuan Penelitian ............................................................................. 2 1.5 Manfaat Penelitian ........................................................................... 3 1.6 Sistematika Penulisan ...................................................................... 3 1.7 Tinjauan Pustaka .............................................................................. 4 BAB II LANDASAN TEORI ......................................................................... 6 2.1 Plagiarisme ....................................................................................... 6 2.1.1 Pengertian Plagiarisme............................................................. 6 2.1.2 Jenis-Jenis Plagiarisme ............................................................ 6 2.2 Source Code ...................................................................................... 8 2.3 Analisis Leksikal ............................................................................... 8 2.3.1 Tipe-Tipe Token ...................................................................... 9 2.3.2 Tahap Analisis Leksikal ........................................................... 11 2.3.3 Implementasi Analisis Leksikal ............................................... 12 2.4 Pemrograman Java ............................................................................ 12 2.5 Netbeans ............................................................................................ 13 2.6 Perancangan Sistem .......................................................................... 14 2.6.1 Pengertian UML (Unified Modeling Language) .................... 14 2.6.2 Bangun Dasar Metodologi UML ............................................ 15 2.6.3 Tujuan Penggunaan UML…………………………………...19 2.7 Flow Chart......................................................................................... 19 BAB III METODOLOGI PENELITIAN........................................................ 21 3.1 Waktu dan Tempat Penelitian .......................................................... 21 3.1.1 Waktu Penelitian ..................................................................... 21 3.1.2 Tempat Penelitian ................................................................... 21 3.2 Metode Pengumpulan Data ............................................................... 21 3.3 Metode Pengembangan Sistem ......................................................... 22 BAB IV ANALISIS DAN PERANCANGAN SISTEM ................................ 24 4.1. Analisis Sistem ................................................................................... 24
ix
4.1.1 Sistem Yang Sedang Berjalan ............................................... 24 4.1.2 Sistem Yang Diusulkan......................................................... 24 4.2 Perancangan Sistem .......................................................................... 25 4.2.1 Diagram Usecase .................................................................... 25 4.2.2 Diagram Activity ..................................................................... 25 4.2.3 Diagram Squence .................................................................... 27 4.3 Analisis Kebutuhan Sistem ............................................................... 28 4.3.1 Kebutuhan Data Masukan ....................................................... 28 4.3.2 Kebutuhan Data Keluaran ....................................................... 28 4.4 Flowchart .......................................................................................... 29 4.5 Perancangan Antar Muka (Interface)................................................ 30 4.6. Ilustrasi Metode Analisis Leksikal Terhadap Perencanaan Aplikasi 30 4.6.1 Analisis Leksikal ..................................................................... 30 4.6.2 Sorting ..................................................................................... 35 4.6.3 Perhitungan Nilai Kemiripan .................................................. 38 BAB V IMPLEMENTASI DAN PENGUJIAN SISTEM .............................. 44 5.1. Implementasi Sistem .......................................................................... 44 5.1.1 Interface Aplikasi.................................................................... 44 5.2. Pengujian Sistem ............................................................................... 46 5.2.1 Pengujian Fungsionalitas Aplikasi .......................................... 46 5.2.2 Hasil Analisa ........................................................................... 50 BAB VI PENUTUP ........................................................................................ 53 6.1. Kesimpulan ....................................................................................... 53 6.2. Saran .................................................................................................. 53 DAFTAR PUSTAKA LAMPIRAN
x
DAFTAR TABEL
Tabel 2.1 Tipe-Tipe Token .............................................................................. 9 Tabel 2.2 Simbol Use Case Diagram .............................................................. 17 Tabel 2.3 Simbol Squence Diagram ................................................................ 18 Tabel 2.4 Simbol Activity Diagram ................................................................ 18 Tabel 2.5 Simbol Flow Chart .......................................................................... 20 Tabel 3.1 Waktu Penelitian ............................................................................. 21 Tabel 4.1 Hasil Analisis Leksikal Source Asli ................................................ 32 Tabel 4.2 Hasil Analisis Leksikal Source Pembanding................................... 34 Tabel 4.3 Hasil Sorting Source Asli ................................................................ 35 Tabel 4.4 Hasil Sorting Source Pembanding ................................................... 36 Tabel 5.1 Daftar Nama Class Source Asli ....................................................... 51 Tabel 5.2 Daftar Nama Class Source Pembanding ......................................... 51 Tabel 5.3 Hasil Analisa Pengujian Sistem ...................................................... 52
xi
DAFTAR GAMBAR Gambar 2.1 Flowchart Tahap Analisis Leksikal .......................................... 11 Gambar 4.1 Diagram Usecase ...................................................................... 25 Gambar 4.2 Diagram Activity Menu Scanning ............................................ 26 Gambar 4.3 Diagram Activity Menu Open File ........................................... 26 Gambar 4.4 Diagram Activity Menu Help ................................................... 27 Gambar 4.5 Diagram Squence submenu Scanning ...................................... 28 Gambar 4.6 Flowchart program ................................................................... 29 Gambar 4.7 Desain Interface Aplikasi ......................................................... 30 Gambar 4.8 Source Asli ............................................................................... 31 Gambar 4.9 Source Pembanding .................................................................. 33 Gambar 5.1 Tampilan Progress Bar ............................................................. 44 Gambar 5.2 Tampilan Utama ....................................................................... 45 Gambar 5.3 Tampilan Dialog Open Source ................................................. 47 Gambar 5.4 Tampilan Source Code Yang Telah Di Input ........................... 47 Gambar 5.5 Tampilan Hasil Scanning Kemiripan........................................ 48 Gambar 5.6 Menampilkan Hasil Analisis..................................................... 48 Gambar 5.7 Menampilkan Token Yang Sama ............................................. 49 Gambar 5.8 Menampilkan Token Yang Tidak Sama ................................... 49 Gambar 5.9 Tampilan Help .......................................................................... 50 Gambar 5.10 Tampilan About ........................................................................ 50
xii
BAB I PENDAHULUAN
1.1.
Latar Belakang Laboratorium Rekayasa Perangkat Lunak Jurusan Teknik Infomatika
Fakultas Teknik Universitas Halu Oleo sebagai tempat pembelajaran bagi para mahasiswa informatika yang mengikuti kelas pemrograman selalu memberikan praktikum sebagai salah satu media pengukur tingkat pemahaman mahasiswa dalam hal membuat program. Pemrograman adalah proses menulis, menguji dan memperbaiki, dan memelihara kode yang membangun sebuah program komputer. Kode ini ditulis dalam berbagai bahasa pemrograman. Bahasa pemrograman merupakan alat yang sangat penting bagi programmer untuk mengimplementasikan algoritma. Tiap bahasa pemrograman memiliki kelebihan dan kekurangan tersendiri, dan programmer memiliki referensi tersendiri dalam memilih suatu bahasa pemrograman. Beberapa faktor penting seseorang dalam memilih bahasa pemrograman adalah syntax, editor, dokumentasi, performa, library, fleksibilitas, komunitas dan popularitas. Banyaknya source code yang harus diperiksa oleh Dosen atau Assisten laboratorium mengakibatkan sulitnya melakukan pemeriksaan serta sulitnya mengukur kredibilitas masing-masing tugas milik mahasiswa. Kode program terperiksa yang memiliki tingkat similarity (kemiripan) yang cukup tinggi antar kode dapat dijadikan acuan adanya tindakan-tindakan kecurangan seperti melakukan tindakan plagiat kode terhadap tugas mahasiswa lain. Metode deteksi kemiripan kode menggunakan analisis leksikal dapat digunakan untuk merubah kode menjadi node ataupun token unik masing-masing kode terperiksa. Semakin besar kemiripan maka semakin besar kemungkinan kode tersebut merupakan hasil plagiat. Pada judul yang diajukan, sistem akan melakukan analisis leksikal pada program yang diperiksa dalam hal ini bahasa pemrograman Java. Analisis ini meliputi pengubahan source code kedalam
1
2
bentuk token-token yang memiliki nama atau id yang unik, penghapusan komentar,serta penghapusan white space. Kemudian dilakukan pencocokan source code yang telah menjadi token yang memiliki kesamaan pada program pembanding berdasarkan struktur yang terbentuk. Jika ditemukan id token dan token yang sama pada posisi yang sama maka program akan mencatatnya dan kemudian menghitung tingkaat kemiripan source code tersebut dan memberikan nilai presentase (similarity). 1.2
Rumusan Masalah Rumusan masalah dalam penelitian ini adalah sebagai berikut:
1.
Bagaimana membangun aplikasi deteksi kemiripan Source code pada bahasa pemrograman java menggunakan metode analisis leksikal.
2.
Bagaimana akurasi aplikasi deteksi kemiripan source code tersebut dapat mendeteksi kemiripan dua source code.
1.3
Batasan Masalah Batasan masalah dalam penelitian ini adalah sebagai berikut:
1.
Source code yang diperiksa dalam aplikasi ini adalah source code java.
2.
File pembanding yang diperiksa adalah dokumen dalam bentuk class file java bukan dalam bentuk project.
3.
Source code yang diperiksa merupakan source code pemrograman dasar yang sekurang-kurangnya memiliki algoritma.
1.4
Tujuan Penelitian Tujuan dalam penelitian ini adalah sebagai berikut:
1.
Membangun sistem aplikasi deteksi kemiripan source code pada bahasa pemrograman java menggunakan metode analisis leksikal.
2.
Mengetahui akurasi kemiripan (similarty) antara satu file dengan file lainnya.
3
1.5.
Manfaat Penelitian Manfaat penelitian dalam penelitan ini adalah :
1.
Dapat membantu instansi pendidikan dalam mendeteksi hasil praktikum dan tugas yang diberikan.
2.
Mengetahui tingkat kemiripan (similarity) source code antara file yang satu dengan yang lain.
3.
Dengan mengetahui persentase kemiripan source code, sehingga dapat digunakan sebagai bahan pertimbangan untuk mendeteksi adanya tindakan plagiat.
4.
1.6.
Mempercepat proses pengoreksian dengan cepat dan efektif.
Sistematika Penulisan Sistematika dalam skripsi ini terdiri dari beberapa bagian utama yaitu
sebagai berikut: BAB I Pendahuluan Merupakan bab pendahuluan yang menguraikan latar belakang masalah, rumusan masalah, tujuan penelitian, manfaat penelitian, batasan masalah dan sistematika penulisan. BAB II Landasan Teori Membahas mengenai dasar-dasar teori pendukung yang digunakan dalam penelitian ini seperti plagiat, bahasa pemrograman java, metode leksikal, source code. BAB III Metodologi Penelitian Membahas mengenai waktu dan tempat penelitian, metode pengumpulan data, metode pengembangan sistem yang digunakan dalam penelitian tugas akhir ini. BAB IV Analisis dan Perancangan Sistem Pada bagian ini diuraikan analisis sistem yang akan dibuat dan kebutuhan sistem yang meliputi kebutuhan fungsional, kebutuhan non fungsional sistem.
4
Rancangan sistem meliputi rancangan arsitektur sistem, rancangan proses, rancangan prosedural, rancangan data, dan rancangan user interface. BAB V Implementasi dan Pengujian Sistem Menguraikan tentang implementasi dan pengujian dari perangkat lunak yang dibangun berdasarkan hasil analisis dan perancangan (desain) pada bab sebelumnya. BAB VI Penutup Menguraikan kesimpulan penelitian dan saran-saran sebagai bahan pertimbangan untuk pengembangan penelitian.
1.7.
Tinjauan Pustaka Penelitian ini didasarkan pada penelitian sebelumnya yang dilakukan oleh
Budhy (2014) yang berjudul “Deteksi Similarity Source Code Menggunakan Metode Deteksi Abstract Syntax Tree” dalam penelitian tersebut cara mendeteksi kemiripan code menggunakan Abstract Syntax Tree dapat digunakan untuk merubah code menjadi node ataupun token unik masing-masing code terperiksa. Semakin besar kemiripan maka semakin besar kemungkinan code tersebut merupakan hasil plagiat. Salah satu penelitian yang mendasari penelitian ini adalah penelitian yang dilakukn oleh Aulia, (2013) “Pemanfaatan Algoritma Rabin-Karp untuk Mengetahui Tingkat Kemiripan dari Source Code pada pemrograman lisp” dalam penelian tersebut membangun sistem deteksi plagiarism kode sumber lisp dengan tahapan pencocokan yang diawali dengan menghilangkan spasi pada string, membagi string ke substring substring, menghitung hash tiap substring menggunakan teknik rolling hash kemudian menghitung persentase kemiripan antar dokumen menggunakan Dice Similarity Coeficient. Redya Febriyanto dkk. (2006) dalam penelitiannya yang berjudul “Penerapan Algoritma Boyer-Moore Untuk Pengecekan Plagiatisme Source Code” dalam penelitian tersebut proses pendeteksian plagiatisme menggunakan penghitungan jumlah prosedur/fungsi, loop, if dan variable dengan pembobotan
5
sederhana. Aplikasi melakukan scanning keyword-keyword tertentu menggunakan Boyer-Moore untuk menentukan bagian dari source yang memenuhi kondisi tertentu. Setelah seluruh prosedur/fungsi selesai diperiksa maka langkah terakhir membandingkan elemen array dari source code yang dicurigai melakukan plagiatisme terhadap source yang asli. Jika didapati ada prosedur/fungsi yang sama maka akan dicatat sebagai satu kesamaan kemudian dilakukan perhitungan presentase kemiripan. Dari beberapa penelitian tersebut yang mendasari penulis untuk melakukan penelitian yang berjudul “Deteksi Kemiripan Source Code Pada Bahasa Pemrograman Java Menggunakan Metode Analisis Leksikal”. Yang membedakan dengan penelitian sebelumnya yaitu, pada penelitian ini tidak hanya mendeteksi source-nya saja melainkan juga dengan mendeteksi dari alur atau struktur source code yang diperiksa. Sebagai contoh pada program perulangan, walaupun isi source mempunyai banyak kesamaan namun secara logika source berbeda, misalkan source satu menggunakan perulangan for sedangkan yang source kedua menggunakan while, maka source tersebut tidak bias dianggap sebagai plagiat, begitu juga sebaliknya.
BAB II LANDASAN TEORI
2.1.
Plagiarisme
2.2.1. Pengertian Plagiarisme Plagiarisme merupakan tindakan kriminal yang sering terjadi dalam dunia akademis. Plagiarisme itu sendiri berasal dari kata latin “Plagiarus” yang berarti penculik dan “Plagiare” yang berarti mencuri. Jadi, secara sederhana plagiat berarti mengambil ide, kata-kata, dan kalimat seseorang dan memposisikannya sebagai hasil karyanya sendiri atau mengunakan ide, kata-kata, dan kalimat tanpa mencantumkan sumber dimana seorang penulis mengutipnya (Sastroasmoro, 2007). Dalam Kamus Besar Bahasa Indonesia (2008) disebutkan: "Plagiat adalah pengambilan karangan (pendapat dan sebagainya) orang lain dan menjadikannya seolah-olah karangan (pendapat) sendiri". Plagiat dapat di anggap sebagai tindak kriminal karena mencuri hak cipta orang lain. Di dalam dunia akademis, pelaku plagiarisme akan mendapat hukuman yang berat. Pelaku plagiat disebut plagiator.
2.2.2. Jenis-Jenis Plagiarisme Terdapat jenis jenis plagiarism, menurut Sudigdo Sastroasmoro dalam makalahnya berjudul Beberapa Catatan tentang Plagiarisme pada tahun 2007, mengklasifikasikan plagiarisme dalam empat jenis. Jenis plagiarisme berdasarkan klasifikasinya diantaranya: a. Jenis plagiarisme berdasarkan aspek yang dicuri Dalam klasifikasi ini terdiri atas 4 kategori yaitu kategori plagiarisme ide, plagiarisme isi, plagiarisme kata, kalimat, paragraf, dan plagiarisme total. Plagiarisme ide sering dikaitkan dengan penelitian replikatif. Penelitian reflikatif adalah penelitian yang berdasarkan atas ide orang lain. Apabila dalam melakukan penelitian, analisis yang digunakan sama dengan penelitian sebelumnya sama,
6
7
maka harus mencantumkan sumber dan alasan ilmiah mengapa penelitian ulang tersebut perlu dilakukan. b. Klasifikasi berdasarkan sengaja atau tidaknya plagiarisme Plagiarisme sengaja adalah mencuri atau dengan sengaja menjiplak hasill karya orang lain dengan kepentingannya sendiri. Hal ini dapat terjadi bila seseorang menjiplak ide, kata, frasa, kalimat atau pragraf tanpa mencantumkan sumbernya dan dilakukan dengan sadar untuk kepentingan sendiri. Plagiarisme tidak disengaja adalah plagiarisme yang terjadi karena ketidaktahuan. Ketidaktahuan ini biasa terjadi dalam menggunakan dokumentasi, teknik mengutip karya tulis, dan parafrase kalimat yang keliru. Meskipun plagirisme tidak disengaja namun sanksi yang dikenakan sama seperti plagiarisme yang disengaja. Hal
tersebut
dapat
dicegah dengan menunjukan bagaimana
menghindari plagiarisme. c.
Klasifikasi berdasarkan proporsi atau persentase kata, kalimat, paragraf yang dibajak
1.
Plagiarisme ringan, plagiarisme yang jumlah poporsi atau persentase kata,
kalimat, paragraf yang dibajak tidak melebihi 30 persen (< 30%). 2.
Plagiarisme sedang, plagiarisme yang jumlah poporsi atau persentase kata,
kalimat, paragraf yang dibajak antara 30-70 persen. 3.
Plagiarisme berat, plagiarisme yang jumlah poporsi atau persentase kata,
kalimat, paragraf yang dibajak lebih dari 70 persen (>70%). d. Berdasarkan pada pola plagiarisme Berdasarkan pada pola plagiarisme dibedakan menjadi dua yaitu plagiarisme kata demi kata (word for word plagiarizing) dan plagiarisme mosaik. Plagiarisme kata demi kata (word for word plagiarizing) adalah pola plagiarisme dengan melakukan penjiplakan sebagian kecil kalimat, dapat juga satu paragraf, atau seluruh isi meskipun di tulis dengan bahasa lain. Sedangkan plagiarisme mosaik adalah penyajian tidak dilakukan kata demi kata, tapi menyipkan kata atau frase dari beberapa karya orang lain tanpa menuliskan sumbernya sehingga memberi kesan kalimat tersebut adalah asli penulis.
8
2.2.
Source Code Dalam bahasa pemrograman, kita mengenal adanya Source Code, Dalam
ilmu komputer, source code (atau disebut juga source) adalah kumpulan pernyataan atau deklarasi bahasa pemrogramman komputer yang ditulis dan dapat di baca manusia. Source Code memungkinkan programmer untuk berkomunikasi dengan komputer menggunakan beberapa perintah yang telah terdefinisi. Source code merupakan sebuah program yang biasanya dibuat dalam satu atau lebih file teks, kadang-kadang disimpan dalam database yang disimpan sebagai prosedur dan dapat juga muncul sebagai potongan kode yang tercetak di buku atau media lainnya. Banyaknya koleksi file source code dapat diatur dalam direktori pohon, dalam hal ini mungkin juga dikenal sebagai source tree. Executable Binary atau yang lebih dikenal dengan Executable-code adalah kode yang bisa dieksekusi oleh komputer sedangkan source code tidak dapat dieksekusi oleh komputer. Sedangkan intermediate-code (kode antara) merupakan bentuk yang terletak diantara source-code dan executable-code (Arifin, 2011).
2.3.
Analisis Leksikal Menurut Henryw (2014) analisis leksikal merupakan fungsi analisis dalam
compiler yang bertugas mendekomposisi program sumber menjadi bagian-bagian kecil (token). Analisis leksikal atau scanner bertugas mengidentifikasi semua besaran pembangun bahasa (leksikal) yang ada pada source code. Scanner menerima masukan source code berupa serangkaian karakter kemudian memilahmilahnya menjadi bagian-bagian kecil yang mempunyai satu arti yang disebut token, seperti : konstanta, nama variabel, keyword, operator. Token-token ini akan menjadi masukan bagi analisis selanjutnya yaitu analisis sintaksis. Dari fungsi scanner secara umum seperti telah disebutkan di atas, maka tugas scanner secara rinci adalah: 1. Membaca serangkaian karakter dari source code. 2. Mengenalinya ke dalam satuan leksikal. 3. Mengubahnya menjadi token dan menentukan jenis tokennya. 4. Mengirimkan token ke proses analisis selanjutnya, yaitu analisis sintaksis.
9
5.
Mengabaikan karakter white space (spasi, enter, ganti baris, penanda akhir
file) dan komentar (remark) apabila ada di dalam source code. 6. Menangani error. 7. Menangani tabel simbol Scanner bekerja berdasarkan prinsip mesin Finite State Automata (FSA). Diagram keadaan dapat digunakan untuk membantu mengkonstruksi scanner. Besaran pembangun bahasa (leksikal) meliputi: 1. Identifier Identifier atau pengenal dapat berupa: a.
Kata tercadang atau kata kunci (reserve word) yang telah didefinisikan oleh
bahasa pemrograman. b.
Kata yang dideklarasikan sendiri oleh pemakai (si pembuat program) disebut
dengan variabel. 2.
Nilai konstanta
Nilai konstanta disini dapat berupa: integer, real, boolean, character, String, dan sebagainya. 3. Operator dan Delimineter a.
Operator aritmatika ( +, -, *, /
b.
Operator logika (<, =, >, <=, >=, !=, <>)
c.
Delimiter berguna sebagai pemisah atau pembatas, contoh:
d.
Karakter sebagai berikut ( ) { } ; . , :
e.
Karakter white space.
2.3.1. Tipe-Tipe Token Berikut ini contoh tipe-tipe token yang digunakan pada saat proses analisis leksikal pada bahasa java : Tabel 2.1 Tipe-Tipe Token No Token 1
Tipe Token
ID Token
Keyword
KW
class,abstract, assert, break, const, boolean, byte, case, catch, char, continue, default, do, double, else,
10
enum, extends, final, finally, float, for, goto, if, implements, import, instance of, int, interface, long, native,
new,
protected,
package,
public,
return,
private, short,
static, super, switch, synchronized, String, strictfp, this, throw, throws, transient, try, void, volatile, false, true, null, while 2
Variabel
Identifier
ID
3
;
Semicolon
SM
4
+
Plus Operator
PO
5
-
Minus Operator
MO
6
*
Multiplication Operator TO
7
,
Comma
FA
8
(
Left parenthesis
LP
9
)
Right Parenthesis
RP
10
{
Left Brace
LB
11
}
Right Brace
RB
12
[
Left Square
LS
13
]
Right Square
RS
14
<
Less Than
LT
15
>
Greater Than
GT
16
.
Dot
DT
17
%
Modulus
MD
18
1,2,3,4,5,6,7,8,9,0
Numeric
NM
19
==
Equals
EQ
20
=
Equals Operator
AO
21
!=
Not Equals
NE
22
& atau &&
Logical AND
LA
11
23
| atau ||
Logical OR
LO
24
A-Z / a-z
String
ST
25
/
Division Operator
DO
2.3.2. Tahap Analisis Leksikal Pada tahap analisa terjadi interaksi antara scanner dan parser. Scanner dipanggil saat parser memerlukan token berikutnya. Pendekatan ini lebih baik karena bentuk internal program sumber yang lengkap tidak perlu dibangun dan disimpan di memori sebelum parsing dimulai (Henryw, 2014).
Gambar 2.1 Flowchart Tahap Analisis Leksikal
12
2.3.3. Implementasi Analisis Leksikal Berikut ini contoh analisis leksikal (scanner) pada potongan program menggunakan bahasa java : public void main(String[]args){ for(int j=0;j<=5;j++){ System.out.println("Helo world.."); } }
Setelah listing program tersebut diproses menggunakan analisis leksikal maka akan menjadi seperti berikut :
KW KW ID LP KW
public void main ( String
AO NM SM ID LT
= 0 ; j <
DT ID DT ID LP
. out . println (
LS
[
AO
=
ST
"Helo world.."
RS ID RP LB KW LP KW ID
] args ) { for ( int j
NM SM ID PO PO RP LB ID
5 ; j + + ) { System
RP SM RB RB
) ; } }
2.4.
Pemrograman Java
Java adalah sebuah bahasa pemrograman yang dikembangkan sebagai komponen utama platform Java oleh Sun MicroSystems dan diluncurkan pada tahun 1995. Bahasa ini banyak mengadopsi sintaksis yang terdapat pada C dan C++ namun dengan sintaksis model objek yang lebih sederhana serta dukungan rutin-rutin aras bawah
yang
minimal.
Aplikasi-aplikasi
berbasis
java
umumnya
13
dikompilasi ke dalam p-code (bytecode) dan dapat dijalankan pada berbagai Java Virtual Machine (JVM). Java merupakan bahasa pemrograman yang bersifat umum/non-spesifik (general purpose), dan secara khusus didisain untuk memanfaatkan
dependensi
implementasi
seminimal
mungkin.
Karena
fungsionalitasnya yang memungkinkan aplikasi java mampu berjalan di beberapa platform sistem operasi yang berbeda, java dikenal pula dengan slogannya, "Tulis sekali, jalankan di mana pun". Saat ini java merupakan bahasa pemrograman yang paling populer digunakan, dan secara luas dimanfaatkan dalam pengembangan berbagai jenis perangkat lunak aplikasi ataupun aplikasi berbasis web. Versi awal Java ditahun 1996 sudah merupakan versi release sehingga dinamakan Java Versi 1.0. Java versi ini menyertakan banyak paket standar awal yang terus dikembangkan pada versi selanjutnya: 1. java.lang: Peruntukan kelas elemen-elemen dasar. 2.
java.io: Peruntukan kelas input dan output, termasuk penggunaan berkas.
3. java.util: Peruntukan kelas pelengkap seperti kelas struktur data dan kelaskelas penanggalan. 4. java.net: Peruntukan kelas TCP/IP, yang memungkinkan berkomunikasi dengan komputer lain menggunakan jaringan TCP/IP. 5. java.awt: Kelas dasar untuk aplikasi antarmuka dengan pengguna (GUI) 6. java.applet: Kelas dasar aplikasi antar muka untuk diterapkan pada penjelajah 2.5.
Netbeans Netbeans adalah salah satu aplikasi IDE yang digunakan programmer
untuk menulis, mengompile, mencari kesalahan, dan menyebarkan program. Netbeans ditulis dalam bahasa java namun dapat juga mendukung Bahasa pemrogramman lain (Miftahul, 2010). 1. Smart code completion: mengusulkan nama variabel dari suatu tipe,melengkapi keyword, dan mengusulkan tipe parameter dari method 2. Menggunakan code generator: dengan menggunakan fitur ini kita dapatmenggenerate constructor, setter and getter method, dll. 3. Error stripe: fitur yang menandai baris yang error dengan menghiglight merah.
14
4. Bookmarking: fitur yang digunakan untuk menandai baris yang suatu saat hendak kita modifikasi. 5. Go to commands: fitur yang digunakan untuk jump ke deklarasi variable,Source Code atau file yang ada pada project yang sama. Database yang didukung Netbeans a. JDBC merupakan spesifikasi standar dari javasoft API yang memungkinkan program java untuk mengakses sistem database manajemen. b. JDBC API terdiri dari satu set interface dan kelas yang ditulis dengan bahasa pemrogramman java. c. OJDBC (oracle java database conectivity) adalah driver yangmenghubungkan program java dan oracle. d. mysql-connector-java adalah driver yang menghubungkan program java dan mysql e. JDBC-ODBC f. mySQL-server 2.6.
Perancangan Sistem
2.6.1. Pengertian UML (Unified Modeling Language) UML (Unified Modeling Language) adalah ‘bahasa’ pemodelan untuk sistem atau perangkat lunak yang berparadigma ‘berorientasi objek”. Pemodelan (modeling) sesungguhnya digunakan untuk penyederhanaan permasalahanpermasalahan yang kompleks sedemikian rupa sehingga lebih mudah dipelajari dan dipahami( Rosa & Shalahuddin, 2013) Unified Modeling Language adalah metodologi kolaborasi antara metodemetode Booch, OMT (Object Modeling Technique), serta OOSE (ObjectOriented Software Enggineering) dan beberapa metoda lainnya, merupakan metodologi yang paling sering digunakan saat ini untuk analisa dan perancangan sistem dengan metodologi berorientasi objek mengadaptasi maraknya penggunaan bahasa pemrograman berorientasi objek (OOP). Berdasarkan pendapat yang dikemukakan sebelumnya, dapat ditarik kesimpulan bahwa Unified Modelling Language(UML) adalah sebuah bahasa
15
yang berdasarkan grafik atau gambar untuk menvisualisasikan, menspesifikasikan, membangun dan pendokumentasian dari sebuah sistem pengembangan perangkat lunak berbasis Objek (Object Oriented programming). 2.6.2. Bangunan Dasar Metodologi Unified Modeling Language (UML) Bangunan dasar metodologi Unified Modeling Language (UML) menggunakan tiga bangunan dasar untuk mendeskripsikan sistem/perangkat lunak yang akan dikembangkan yaitu: 1. Sesuatu (things) Ada 4 things dalam Unified Modeling Language (UML), yaitu: a. Structural things Merupakan bagian yang relatif statis dalam model Unified Modeling Language (UML). Bagian yang relatif statis dapat berupa elemen-elemen yang bersifat fisik maupun konseptual. b. Behavioral things Merupakan bagian yang dinamis pada model Unified Modeling Language (UML), biasanya merupakan kata kerja dari model Unified Modeling Language (UML), yang mencerminkan perilaku sepanjang ruang dan waktu. c. Grouping things Merupakan bagian pengorganisasi dalam Unified Modeling Language (UML). Dalam penggambaran model yang rumit kadang diperlukan penggambaran paket yang menyederhanakan model. Paket-paket ini kemudian dapat didekomposisi lebih lanjut. Paket berguna bagi pengelompokkan sesuatu, misalnya model-model dan subsistem. d. Annotational things Merupakan bagian yang memperjelas model Unified Modeling Language (UML) dan dapat berupa komentar-komentar yang menjelaskan fungsi serta ciri-ciri setiap elemen dalam model Unified Modeling Language (UML) . 2. Relasi (Relationship) Ada 4 (empat) macam relationship dalam Unified Modeling Language (UML), yaitu:
16
a. Kebergantungan Merupakan hubungan dimana perubahan yang terjadi pada suatu elemen mandiri (independent) akan mempengaruhi elemen yang bergantung pada elemen yang tidak mandiri (independent). b. Asosiasi Merupakan apa yang menghubungkan antara objek satu dengan objek lainnya, bagaimana hubungan suatu objek dengan objek lainnya. Suatu bentuk asosiasi adalah agregasi yang menampilkan hubungan suatu objek dengan bagianbagiannya. c. Generalisasi Merupakan hubungan dimana objek anak (descendent) berbagi perilaku dan struktur data dari objek yang ada diatasnya objek induk (ancestor). Arah dari atas kebawah dari objek induk ke objek anak dinamakan spesialisasi, sedangkan arah berlawanan sebaliknya dari arah bawah keatas dinamakan generalisasi. d. Realisasi Merupakan operasi yang benar-benar dilakukan oleh suatu objek. 3.
Diagram Ada berbagai macam diagram dalam Unified Modeling Language (UML), yaitu:
a. Diagram Usecase b. Diagram Class c. Diagram Package d. Diagram Sequence e. Diagram Collaboration f. Diagram StateChart g. Diagram Activity h. Diagram Deployment UML yang akan digunakan yaitu diagram usecase, sequence dan activity. 1. Diagram Usecase Diagram usecase menggambarkan fungsionalitas yang diharapkan dari sebuah sistem. Pada diagaram ini yang ditekankan adalah “apa” yang diperbuat
17
sistem dan bukan “bagaimana”. Menggambarkan kebutuhan sistem dari sudut pandang user.Mengfokuskan pada proses komputerisasi (automated processes). Menggambarkan hubungan antara Usecase dan actor Usecase menggambarkan proses sistem (kebutuhan sistem dari sudut pandang user). Tabel 2.2 Simbol usecase diagram Simbol
Deskripsi Aktor, mewakili peran orang sistem yang lain atau alat ketika berkomunikasi
Aktor
dengan usecase Usecase abstraksi dari interaksi antara
Nama use case
sistem dan actor Association
adalah
abstraksi
dari
penghubung antara actor dan usecase Menunjukan <
>
seluruhnya
bahwa
suatu
merupakan
usecase
fungsionalitas
dari usecase lainnya
Menunjukan <<extend>>
bahwa
suatu
usecase
merupakan tambahan fungsionalitas dari usecase lainnya Genealisasi,
menunjukan
spesialisasi
actor untuk dapat berpartisipasi dalam usecase (Sumber : Rosa A.S & M.Shalahuddin, 2013) 2. Diagram Sequence Diagram ini memperlihatkan interaksi yang menekankan pada pengiriman pesan (message) dalam suatu waktu tertentu.Diagram squence biasa digunakan untuk menggambarkan skenario atau rangkaian langkah-langkah yang dilakukan sebagai respons dari sebuah event untuk menghasilkan output tertentu.
18
Tabel 2.3 Simbol diagram squence Simbol
Nama
Deskripsi Objek entity, antarmuka yang saling
LifeLine
berinteraksi.
Spesifikasi dari komunikasi antar objek Message
yang
memuat
informasi-informasi
tentang aktifitas yang terjadi Spesifikasi dari komunikasi antar objek Message
yang
memuat
informasi-informasi
tentang aktifitas yang terjadi (Sumber : Rosa A.S & M.Shalahuddin, 2013) 3. Diagram Activity Diagram Activity memodelkan workflow proses dan urutan aktivitas dalam sebuah proses. Diagram ini sangat mirip dengan flowchart karena memodelkan workflow dari satu aktivitas ke aktivitas lainnya atau dari aktivitas ke status. Menguntungkan untuk membuat Diagram Activity pada awal pemodelan proses untuk membantu memahami keseluruhan proses. Diagram Activity juga bermanfaat untuk menggambarkan parallel behaviour atau menggambarkan interaksi antara beberapa usecase. Tabel 2.4 Simbol Diagram Activity Simbol
Deskripsi Titik awal
Titik akhir
Activity/action
19
Pilihan untuk mengambil keputusan dan mengakhiri kondisi Fork
&Join;
untuk
menunjukan
kegiatan yang dilakukan secara paralel dan digabungkan kembali (Sumber : Rosa A.S & M.Shalahuddin, 2013) 2.6.3. Tujuan Penggunaan UML Tujuan Penggunaan Unified Modeling Language (UML) adalah : 1. Memberikan bahasa pemodelan yang bebas dari berbagai bahasa pemrograman dan proses rekayasa. 2. Menyatukan praktek-praktek terbaik yang terdapat dalam pemodelan. 3. Memberikan model yang siap pakai, bahsa pemodelan visual yang ekspresif untuk mengembangkan dan saling menukar model dengan mudah dan dimengerti secara umum. 4. UML bisa juga berfungsi sebagai sebuah (blue print) cetak biru karena sangat lengkap dan detail. Dengan cetak biru ini maka akan bias diketahui informasi secara detail tentang coding program atau bahkan membaca program dan menginterpretasikan kembali ke dalam bentuk diagram (reserve enginering). 2.7.
Flowchart Algoritma merupakan suatu alur pemikiran seseorang yang harus dapat
dituangkan secara tertulis. Salah satu caranya adalah dengan menggunakan simbol-simbol yang memang sudah standar pada dunia komputer. Simbol itu disebut dengan flowchart (Antonius, 2010). Dengan menggunakan flowchart (diagram alir) maka seseorang programmer dapat memberikan idenya secara tertulis sehingga dapat dipahami oleh programmer lain, oleh klien, atau oleh tim kerjanya. Flowchart merupakan alur pemikiran yang dituangkan ke dalam bentuk simbol. Dengan demikian perlu dipelajari terlebih dahulu bentuk-bentuk simbol standar beserta kegunaan masing-masing. Berikut adalah tabel simbol-simbol flowchart :
20
Tabel 2.5 Simbol flowchart Deskripsi
Simbol Mulai
Selesai
Start
Finish
Aliran data
Proses / kejadian
Percabangan
Input
Output (Sumber : Antonius , 2010)
X=y+z
X>2
Masukan data
Tampilkan data
BAB III METODOLOGI PENELITIAN
3.1
Waktu dan Tempat Penelitian
3.1.1 Waktu Penelitian Waktu pelaksanaan penelitian tugas akhir dilaksanakan mulai dari bulan Februari 2016. Rincian kegiatan dapat dilihat pada tabel 3.1.
Tabel 3.1 Waktu penelitian Tahun 2016 No
Uraian
1
Studi Literatur
2 3 4
Analisis Desain Pembuatan Program Pengujian Pemeliharaan
5 6
Februari (Minggu ke-) 1 2 3 4
Maret (Minggu ke-) 1 2 3 4
April (Minggu ke-) 1 2
3.1.2 Tempat Penelitian Penelitian tugas akhir ini bertempat di Laboraturium Rekayasa Perangkat Lunak Fakultas Teknik Universitas Halu Oleo 3.2
Metode Pengumpulan Data Beberapa metode yang digunakan dalam pengumpulan data adalah sebagai
berikut: 1. Wawancara (Interview) Pengumpulan data dengan wawancara ini dilakukan untuk mencari data dan informasi tentang hal-hal yang dibutuhkan dalam penelitian. Wawancara dilakukan dengan dosen yang bertanggung jawab pada Laboraturium Perangkat
21
22
Lunak untuk mendapatkan informasi yang berhubungan dengan pengaambilan sample yang akan dilakukan. 2. Studi Literatur Guna mendapatkan data, gambaran dan keterangan yang lebih lengkap peneliti menggunakan studi literatur dengan cara mengumpulkan dan mempelajari literatur yang berkaitan dengan teori sistem perancangan aplikasi kesamaan Source Code pada bahasa pemrograman java dan metode leksikal. Sumber literatur berupa paper, jurnal, karya ilmiah, dan situs-situs penunjang. 3. Sampling Pada tahap ini peneliti membutuhkan suatu sampel data yang berupa file project dari tugas mahasiswa yang melakukan praktikum di Laboraturium Rekayasa Perangkat Lunak sebagai bahan uji coba pada aplikasi Deteksi Kemiripan Source Code Pada Bahasa Pemrograman Java Menggunakan Metode Analisis Leksikal.
3.3 Metode Pengembangan Sistem Metode
pengembangan
perangkat
lunak
yang
digunakan
dalam
pembangunan sistem ini adalah metode Waterfall yang terdiri dari beberapa tahap yaitu : 1. Studi Literatur Tahap pertama yang dilakukan peneliti yaitu mengumpulkan data, gambaran dan keterangan yang lebih lengkap dalam penelitian ini dengan cara mengumpulkan dan mempelajari literatur yang berkaitan dengan judul penelitian. Yang bersumber dari buku teks, paper, jurnal, karya ilmiah, dan situs-situs penunjang lainnya. 2. Analisis Tahap analisis adalah tahap dimana peneliti menganalisis permasalahan yang ada yaitu kriteria-kiteria dan persyaratan penerimaan peserta didik baru dan melakukan perhitungan.
23
3. Desain Pada tahap desain merupakan tahap peneliti merancang pembuatan tampilan awal atau interface dari aplikasi yang akan dibangun. Tampilan interface akan dirancang melalui data-data yang telah diperoleh pada saat tahap analisis. 4. Pembuatan Program Pada tahap pengkodean yaitu menerjemahkan aplikasi kedalam bahasa pemrograman yang telah ditentukan yaitu bahasa pemograman Java. 5. Pengujian Merupakan tahap pengujian terhadap aplikasi yang telah dibuat menjadi suatu perangkat lunak yang siap pakai dengan tujuan apakah sistem yang sudah jadi sudah sesuai dengan yang diharapkan. 6. Pemeliharaan Pada tahap pemeliharan yaitu tahap dimana melakukan koreksi dari berbagai error yang tidak ditemukam pada tahap-tahap sebelumnya sehingga dapat dilakukan perbaikan, agar dapat menghasilkan sistem yang lebih baik dari sebelumnya.
BAB IV ANALISIS DAN PERANCANGAN SISTEM
4.1.
Analisis Sistem
4.1.1. Sistem yang Sedang Berjalan Laboratorium Rekayasa Perangkat Lunak Jurusan Teknik Informatika Universitas Halu Oleo saat ini belum memiliki sistem yang dapat mendeteksi kemiripan source code untuk memeriksa adanya tindakan plagiat secara otomatis berbasis aplikasi komputer. Sistem yang sedang berjalan saat ini dalam mendeteksi kemiripan source code dilakukan secara manual, dimana Dosen atau Asisten laboratorium harus memeriksa satu persatu file source code yang diperiksa. Pendeteksian secara manual selain membutuhkan waktu yang lama juga tingkat ketelitiannya masih kurang. Hal ini disebabkan faktor ketelitian manusia berbeda dengan komputer. 4.1.2. Sistem yang Diusulkan Sistem yang diusulkan dalam pedeteksi kemiripan source code adalah sistem yang dilakukan secara otomatis. Aplikasi proses pendeteksi kemiripan source code yang diusulkan ini menggunakan metode Analisis Leksikal. File yang diperiksa dalam sistem ini adalah file class yang berekstensi .java. User memasukan dua buah file dimana file pertama merupakan file pembanding dan file kedua merupakan file yang akan diperiksa kemiripannya. Keluaran dari sistem ini adalah presentase tingkat kemiripan isi source code. Setelah user memasukan kedua file yang akan diperiksa maka sistem akan melakukan tahap analisis. Untuk melihat persentasi kemiripan user memilih menu scanning, maka presentase kemiripan akan tampil.
24
25
4.2.
Perancangan Sistem
4.2.1. Diagram Usecase
Gambar 4.1 Diagram Usecase Pada diagram Usecase, pengguna dapat mengakses form utama, membuka file, melakukan scanning, mengakses menu Help. 4.2.2. Diagram Activity 1.
Diagram Activity menu Scanning Pada diagram activity scanning, user dapat membuka dua file yang akan
dibandingkan. Setelah user memilih file yang akan dibandingkan user dapat memilih menu scanning untuk mengetahui presentase dari hasil perbandingan dari kedua file tersebut.
26
Gambar 4.2 Diagram Activity Menu Scanning
2. Diagram Activity submenu Open File Pada diagram activity menu Open File, user mengakses aplikasi, kemudian sistem menampilkan halaman utama, lalu user memilih menu Open File, sistem kemudian menampilkan dialog open file. Seperti dijelaskan pada gambar 3.2 berikut.
Gambar 4.3 Diagram Activity Menu Open File
27
3. Diagram Activity menu Help Pada menu Help user dapat membaca tutorial penggunaan aplikasi dengan cara pilih menu Help kemudian pilih sumenu Help
Gambar 4.4 Diagram Activity Menu Help
4.2.3. Diagram Sequence 1.
Diagram Sequence Menu Scanning Pada diagram Sequence dapat dilihat setelah user melakukan input file
maka sistem akan membaca dan akan menampilkan isi dari file tersebut. Setelah itu sistem akan melakukan proses analisis leksikal. Setelah user memilih submenu scanning, sistem akan melakukan pencocokan token berdasarkan posisi array dan
28
menghitung jumlah kemiripan sehingga akan keluar hasil presentase nilai similarity atau kemiripan source code dan waktu proses yang dibutuhkan.
Gambar 4.5 Diagram Sequences submenu scanning
4.3.
Analisis Kebutuhan Sistem
4.3.1. Kebutuhan Data Masukan Untuk data masukan yang dibutuhkan dari sistem ini adalah adanya file class java yang akan dihitung presentase kemiripannya minimal dua buah file class, selanjutnya sistem akan menggunakan metode analisis leksikal dan pencocokan string untuk menghasilkan output.
4.3.2. Kebutuhan Data Keluaran Data keluaran dari sistem yang telah di proses untuk kemudian ditampilkan kepada pengguna sistem yaitu presentase nilai kemiripan dan kesimpulan dari hasil presentase apakah file tersebut merupakan plagiat atau bukan.
29
4.4.
Flowchart Flowchart dari proses sistem yang dilakukan secara keseluruhan dapat
dijelaskan seperti gambar berikut:
Gambar 4.6 flowchart program
30
4.5.
Peracangan Antar Muka (Interface) Perancangan antar muka (interface) merupakan perancangan untuk melihat
desain awal dari sebuah sistem. Berikut adalah perancangan sistem interface dari peracangan aplikasi pendeteksi kemiripan source code.
Gambar 4.7 Desain interface aplikasi Gambar diatas merupakan rancangan desain dari halaman utama aplikasi yang terdiri dari tiga meu, yaitu: file, process dan help. Pada menu File terdiri submenu Open Source 1 dan Open Source 2 yang berfungsi untuk menginsert file dan exit. Pada menu Process terdiri submenu Scanning yang berfungsi untuk mencocokan kedua file Source code yang akan dibandingkan, show analisis untuk menampilkan hasil analisis, show similar untuk menampilkan token-token yang mempunyai kemiripan, show not similar untuk menampilkan token-token yang tidak sama dan reset untuk merefresh halaman utama ke default. Pada menu Help merupakan batuan tentang bagaimana menjalankan aplikasi. Terdiri dari submenu help dan about. 4.6.
Ilustrasi Metode Analisis Leksikal Terhadap Perencanaan Aplikasi
4.6.1. Analisis Leksikal Tahap ini merupakan tahap awal sebelum dilakukan perhitungan kemiripan kedua source code yang akan diperiksa. Setelah source code dimasukan
31
maka sistem otomatis akan mentransformasikan source code tersebut kedalam bentuk token berdasarkan id masing-masing tipe. Untuk daftar tipe-tipe token dapat dilihat pada tabel tipe token pada bab sebelumnnya. Berikut contoh analisis leksikal pada dua buah source code yang akan diperiksa kemiripannya. 1.
Source Asli
Gambar 4.8 source asli
Setelah dilakukan analisis leksikal maka source asli akan berbentuk seperti tabel 4.1
32
Tabel 4.1 Hasil Analisis Leksikal Source Asli. ID Token KW ID SM KW KW ID LB KW ID
Token package contoh ; public class Mobil { String warna
ID Token LP ST PO ID PO ST RP SM RB
Token ( "Mobil maju sejauh " + maju + " meter" ) ; }
ID Token SM RB KW KW KW ID LP KW LS
Token ; } public static void main ( String [
SM
;
KW
public
RS
]
KW ID SM KW ID SM KW KW ID LP KW ID RP LB KW
int jumlah_pintu ; float isi_tangki ; public void Maju ( int maju ) { int
KW ID LP KW ID RP LB KW ID AO NM SM ID AO ID
void Mundur ( int mundur ) { int mundurbelakang = 0 ; mundurbelakang = mundurbelakang
ID RP LB ID ID AO KW ID LP RP SM ID DT ID LP
args ) { Mobil BMW = new Mobil ( ) ; BMW . Maju (
ID
majukedepan
PO
+
NM
75
AO NM SM
= 0 ;
ID SM ID
mundur ; System
RP SM ID
) ; BMW
ID
majukedepan
DT
.
DT
.
AO ID PO ID
= majukedepan + maju
ID DT ID LP
out . println (
ID LP NM RP
Mundur ( 5 )
33
SM
;
ST
ID DT ID DT ID
System . out . println
PO ID PO ST RP
2.
"Mobil sejauh " + mundur + " meter" )
mundur
SM
;
RB RB
} }
Source Pembanding
Gambar 4.9 Source Pembanding
Setelah dilakukan analisis leksikal maka source pembanding ini akan berbentuk seperti tabel 4.2
34
Tabel 4.2 Hasil Analisis Source Pembanding ID Token KW ID SM KW KW ID LB KW ID SM KW ID SM KW ID SM KW KW ID LP KW ID RP LB KW
Token package contoh2 ; public class Mobil2 { String warna ; int jumlah_pintu ; float isi_tangki ; public void Maju ( int maju ) { int
ID Token LP ST PO ID PO ST RP SM RB KW KW ID LP KW ID RP LB KW ID AO NM SM ID AO ID
Token ( "Mobil maju sejauh " + maju + " meter" ) ; } public void Mundur ( int mundur ) { int mundurbelakang = 0 ; mundurbelakang = mundurbelakang
ID Token SM RB KW KW KW ID LP KW LS RS ID RP LB ID ID AO KW ID LP RP SM ID DT ID LP
Token ; } public static void main ( String [ ] args ) { Mobil BMW = new Mobil ( ) ; BMW . Maju (
ID
majukedepan
PO
+
NM
75
AO NM SM
= 0 ;
ID SM ID
mundur ; System
RP SM ID
) ; BMW
ID
majukedepan
DT
.
DT
.
AO ID PO ID
= majukedepan + maju
ID DT ID LP
out . println (
ID LP NM RP
Mundur ( 5 )
35
SM
;
ST
ID DT ID DT ID
System . out . println
PO ID PO ST RP
"Mobil sejauh " + mundur + " meter" )
mundur
SM
;
RB RB
} }
4.6.2. Sorting Proses ini merupakan proses mengurutkan token-token yang terbentuk dari kedua source code yang diperiksa menurut abjad. Proses ini dilakukan dengan tujuan supaya jika terdapat source code yang sama tetapi terdapat fungsi atau prosedure yang sama pada posisi yang berbeda tetap akan terdeteksi. Setelah kedua source code diurutkan, maka masing-masing akan berbentuk sebagai berikut. 1.
Source Asli Tabel 4.3. Hasil Sorting Source Asli
ID Token AO AO AO AO AO DT DT DT DT DT DT ID ID ID ID ID ID
Token = = = = = . . . . . . args BMW BMW BMW contoh isi_tangki
ID Token ID ID ID ID ID KW KW KW KW KW KW KW KW KW KW KW KW
Token println println System System warna class float int int int int int new package public public public
ID Token NM PO PO PO PO PO PO RB RB RB RB RP RP RP RP RP RP
Token 75 + + + + + + } } } } ) ) ) ) ) )
36
ID
jumlah_pintu
KW
public
RP
)
ID ID ID ID ID ID ID ID ID ID ID ID ID ID ID ID ID
main maju maju maju Maju Maju majukedepan majukedepan majukedepan Mobil Mobil Mobil mundur mundur mundur Mundur Mundur
KW KW KW KW KW KW LB LB LB LB LP LP LP LP LP LP LP
static String String void void void { { { { ( ( ( ( ( ( (
RP RS SM SM SM SM SM SM SM SM SM SM SM SM SM ST ST
LP
(
ST
LS
[
ST
) ] ; ; ; ; ; ; ; ; ; ; ; ; ; " meter" " meter" "Mobil maju sejauh " "Mobil mundur sejauh "
NM
0
NM NM
0 5
ID
mundurbelakang
ID mundurbelakang ID
mundurbelakang out out
ID ID 2.
Source Pembanding Tabel 4.4. Hasil Sorting Source Pembanding
ID Token AO AO AO AO AO DT
Token = = = = = .
ID Token ID ID ID ID ID KW
Token println println System System warna class
ID Token NM PO PO PO PO PO
Token 75 + + + + +
37
DT DT DT DT DT ID ID ID ID ID ID
. . . . . args BMW BMW BMW contoh2 isi_tangki
KW KW KW KW KW KW KW KW KW KW KW
float int int int int int new package public public public
PO RB RB RB RB RP RP RP RP RP RP
+ } } } } ) ) ) ) ) )
ID
jumlah_pintu
KW
public
RP
)
ID ID ID ID ID ID
main maju maju maju Maju Maju
KW KW KW KW KW KW
static String String void void void
RP RS SM SM SM SM
) ] ; ; ; ;
ID
majukedepan
LB
{
SM
;
ID
majukedepan
LB
{
SM
;
ID ID ID ID ID ID ID ID ID
majukedepan Mobil Mobil2 Mobil mundur mundur mundur Mundur Mundur
LB LB LP LP LP LP LP LP LP
{ { ( ( ( ( ( ( (
SM SM SM SM SM SM SM ST ST
LP
(
ST
LS
[
ST
; ; ; ; ; ; ; " meter" " meter" "Mobil maju sejauh " "Mobil mundur sejauh "
NM
0
NM NM
0 5
ID
mundurbelakang
ID mundurbelakang ID ID ID
mundurbelakang out out
38
4.6.3. Perhitungan Nilai Kemiripan Setelah kedua source code berbentuk token dan token-token telah terurut, maka proses selanjutnya adalah perhitungan nilai kemiripan kedua source menggunakan array. Panjang array sesuai dengan panjang token yang terbentuk. Pada contoh diatas panjang token adalah 117. Metode perhitungan kemiripan ini didasarkan atas posisi dan isi dari token tersebut. Jika pada posisi array ke-0 di cocokan dengan posisi array ke-0 pada source kedua sama, baik id token dan isi dari token maka program akan mencatat sebagi satu kemiripan. Kemdian program akan melanjutkan pada posisi array selanjutnya sampai posisi terakhir pada array. Jika panjang array pada kedua source berbeda dikarenakan banyaknya token yang terbentuk pada kedua source berbeda, maka pencocokan diberhentikan pada nilai array yang terpendek dan sisanya dianggap sebagai ketidaksamaan. Berikut ilustrasi perhitungan nilai kemiripan menggunakan array pada kedua source code yang telah berbentuk token.
Source Asli
Source Pembanding
AO
=
sama
AO
=
AO
=
sama
AO
=
AO
=
sama
AO
=
AO
=
sama
AO
=
AO
=
sama
AO
=
DT
.
sama
DT
.
DT
.
sama
DT
.
DT
.
sama
DT
.
DT
.
sama
DT
.
DT
.
sama
DT
.
DT
.
sama
DT
.
ID
args
sama
ID
args
ID
BMW
sama
ID
BMW
39
ID
BMW
sama
ID
BMW
ID
BMW
sama
ID
BMW
ID
contoh
beda
ID
contoh2
ID
isi_tangki
sama
ID
isi_tangki
ID
jumlah_pintu
sama
ID
jumlah_pintu
ID
main
sama
ID
main
ID
maju
sama
ID
maju
ID
maju
sama
ID
maju
ID
maju
sama
ID
maju
ID
Maju
sama
ID
Maju
ID
Maju
sama
ID
Maju
ID
majukedepan
sama
ID
majukedepan
ID
majukedepan
sama
ID
majukedepan
ID
majukedepan
sama
ID
majukedepan
ID
Mobil
sama
ID
Mobil
ID
Mobil
sama
ID
Mobil
ID
Mobil
beda
ID
Mobil2
ID
mundur
sama
ID
mundur
ID
mundur
sama
ID
mundur
ID
mundur
sama
ID
mundur
ID
Mundur
sama
ID
Mundur
ID
Mundur
sama
ID
Mundur
ID
mundurbelakang
sama
ID
mundurbelakang
ID
mundurbelakang
sama
ID
mundurbelakang
ID
mundurbelakang
sama
ID
mundurbelakang
ID
out
sama
ID
out
ID
out
sama
ID
out
ID
println
sama
ID
println
ID
println
sama
ID
println
ID
System
sama
ID
System
40
ID
System
sama
ID
System
ID
Warna
sama
ID
Warna
KW
class
sama
KW
class
KW
float
sama
KW
float
KW
int
sama
KW
int
KW
int
sama
KW
int
KW
int
sama
KW
int
KW
int
sama
KW
int
KW
int
sama
KW
int
KW
new
sama
KW
new
KW
package
sama
KW
package
KW
public
sama
KW
public
KW
public
sama
KW
public
KW
public
sama
KW
public
KW
public
sama
KW
public
KW
static
sama
KW
static
KW
String
sama
KW
String
KW
String
sama
KW
String
KW
void
sama
KW
void
KW
void
sama
KW
void
KW
void
sama
KW
void
LB
{
sama
LB
{
LB
{
sama
LB
{
LB
{
sama
LB
{
LB
{
sama
LB
{
LP
(
sama
LP
(
LP
(
sama
LP
(
LP
(
sama
LP
(
LP
(
sama
LP
(
LP
(
sama
LP
(
41
LP
(
sama
LP
(
LP
(
sama
LP
(
LS
[
sama
LS
[
NM
0
sama
NM
0
NM
0
sama
NM
0
NM
5
sama
NM
5
NM
75
sama
NM
75
PO
+
sama
PO
+
PO
+
sama
PO
+
PO
+
sama
PO
+
PO
+
sama
PO
+
PO
+
sama
PO
+
PO
+
sama
PO
+
RB
}
sama
RB
}
RB
}
sama
RB
}
RB
}
sama
RB
}
RB
}
sama
RB
}
RP
)
sama
RP
)
RP
)
sama
RP
)
RP
)
sama
RP
)
RP
)
sama
RP
)
RP
)
sama
RP
)
RP
)
sama
RP
)
RP
)
sama
RP
)
RP
)
sama
RP
)
RS
]
sama
RS
]
SM
;
sama
SM
;
SM
;
sama
SM
;
SM
;
sama
SM
;
SM
;
sama
SM
;
42
SM
;
sama
SM
;
SM
;
sama
SM
;
SM
;
sama
SM
;
SM
;
sama
SM
;
SM
;
sama
SM
;
SM
;
sama
SM
;
SM
;
sama
SM
;
SM
;
sama
SM
;
SM
;
sama
SM
;
ST
" meter"
sama
ST
" meter"
ST
" meter"
sama
ST
" meter"
ST
"Mobil maju
sama
ST
"Mobil maju
sejauh " ST
sejauh "
"Mobil mundur
sama
sejauh "
ST
"Mobil mundur sejauh "
Pada ilustrasi diatas dapat kita lihat bahwa, dari kedua source yang diperiksa terdapat 115 jumlah kemiripan dan terdapat 2 perbedaan saja yang ditemukan. Sehingga dari data tersebut kita dapat menentukan nilai kemiripan dengan ketentuan: Jumlah kesamaan
= 115
Jumlah perbedaan = 2 Jumlah elemen objek
= 117
= (115/117) x 100 % = 98,29 %
43
Karena hasil dari perhitungan lebih besar dari 70%, maka source code tersebut dianggap sebagai plagiat.
BAB V IMPLEMENTASI DAN PENGUJIAN SISTEM
5.1
Implementasi Sistem Pada tahap ini merupakan tahap penerapan sistem pada keadaan yang
sebenarnya agar dapat berfungsi sesuai kebutuhan, sehingga dapat diketahui apakah sistem yang dibuat sesuai dengan perancangan sebelumnya. Disini akan dijelaskan bagaimana sistem ini dengan memberikan contoh-contoh tampilan aplikasi yang terdapat pada aplikasi ini. 5.1.1 Interface aplikasi Adapun interface dan preview dari aplikasi Deteksi Kemiripan Source Code Pada Bahasa Pemrograman Java Menggunakan Metode Analisis Leksikal adalah sebagai berikut : 1.
Progress Bar Tampilan ini merupakan tampilan progress bar yang berjalan ketika pertama
kali aplikasi dijalankan.
Gambar 5.1. Tampilan progress bar 2.
Tampilan Utama Pada tampilan utama ini terdapat tiga menu yaitu menu file,process dan help.
Pada menu file terdapat tiga submenu file yaitu open source 1,open source 2 dan exit. Pada menu process terdapat lima submenu yaitu submenu scanning,show
44
45
analysis, show similar, show not similar dan reset. Sedangkan pada menu help terdapat dua submenu yaitu submenu help dan about.
Gambar 5.2 Tampilan utama a.
Submenu Open source
Merupakan submenu untuk menginput source yang akan diperiksa. Submenu open source 1 berfungsi menginput source pertama dan submenu open source 2 berfungsi untuk menginput source yang kedua kemudian source akan tampil pada masing-masing text editor. Setelah source
telah dimasukan maka akan
tampil properties dari kedua source berupa jumlah kata, jumlah simbol, jumlah angka, jumlah token dan letak source . b.
Submenu exit
Submenu ini berfungsi untuk keluar dari aplikasi c.
Submenu Scanning
Submenu ini berada pada menu Process, dimana submenu ini berfungsi untuk mengetahui presentase kemiripan source
code yang diperiksa. Setelah user
memilih submenu scanning maka akan tampil Jumlah token yang sama, jumlah token yang tidak sama, jumlah token yang diperiksa , presentase kemiripan, keterangan plagiat atau bukan plagiat dan waktu pada saat proses scanning.
46
d.
Submenu Show analysis
Submenu ini berfungsi untuk menampilkan hasil analisis leksikal setelah user menginput source yang akan diperiksa. Hasil analisis ini akan tampil pada text editor masing-masing source . e.
Submenu show similar
Merupakan submenu untuk melihat token-token mana saja yang memiliki kemiripan pada kedua source yang diperiksa f.
Submenu not similar
Merupakan submenu untuk menampilkan token-token yang tidak sama pada kedua source. g.
Submenu reset
Submenu ini berfungsi untuk mereset tampilan utama ke default h.
Submenu Help
Submenu ini akan menampilkan bantuan atau panduan cara menggunakan aplikasi dalam bentuk pdf. i.
Submenu About
Merupakan submenu untuk menampilkan informasi tentang aplikasi deteksi kemiripan source code ini.
5.2. Pengujian Sistem 5.2.1. Pengujian Fungsionalitas Aplikasi Pengujian ini dilakukan untuk memeriksa apakah semua menu dan submenu yang ada pada sistem dapat berfungsi dengan baik. Pengujian ini dilakukan dengan memasukkan source
code, scanning, menampilkan hasil
analisis, menampilkan token yang mirip dan yang tidak mirip pada source code yang diperiksa serta menampilkan menu help dan about. 1. Memasukan dua buah source code yang akan diperiksa kedalam text editor.
47
Gambar 5.3 Tampilan dialog open source 2. Setelah source code terinput maka pada menu utama akan tampil properties masing-masing source
code yang berupa jumlah kata,jumlah simbol,jumlah
angka dan total token yang terbentuk.
Gambar 5.4 Tampilan source code yang telah di input 3. Langkah selanjutnya yaitu melakukan proses scanning dengan menekan menu process dan memilih submenu scanning. Setelah sistem selesai menscan kedua source maka akan tampil jumlah token yang sama, jumlah token yang tidak sama, jumlah token yang diperiksa, presentase kemiripan, keterangan plagiat atau bukan
48
dalam bentuk radio button dan waktu yang diperlukan pada saat melakukan proses scanning.
Gambar 5.5 Tampilan hasil scanning kemiripan
4. Menampilkan hasil analisis keseluruahan
Gambar 5.6 Menampilkan hasil analisis
49
5. Menampilkan token yang sama/mirip
Gambar 5.7 Menampilkan token yang sama
6. Menampilkan token yang tidak sama/tidak mirip
Gambar 5.8 Menampilkan token yang tidak sama 7. Langkah selanjutnya yaitu menguji menu help. Pilih menu help kemudian pilih submenu help maka akan tampil bantuan penggunaan aplikasi dalam bentuk PDF.
50
Gambar 5.9 Tampilan Help
8. Selanjutnya menu about
Gambar 5.10 Tampilan About 5.2.2. Hasil Analisa Pada pengujian sistem yang dilakukan, sistem memeriksa dua source code yang masing-masing berjumlah 10 file class. Daftar file class yang di uji dapat di lihat pada tabel 5.1 dan tabel 5.2.
51
Tabel 5.1 Daftar Nama Class Source Asli
NO 1 2 3 4 5 6 7 8 9 10
SOURCE ASLI ∑ ∑ NAMA CLASS KATA SIMBOL BilPrima.java 42 48 CekNilai.java 94 120 HitungLingkaran.java 47 47 test1.java 20 25 test3.java 25 31 test5.java 28 36 NilaiUjian.java 75 104 scanner.java 33 33 MembuatPolaXDiJava.java 59 88 Main.java 100 123
∑ANGKA 2 5 2 2 2 4 10 0 3 1
TOTAL TOKEN 92 219 96 47 58 68 189 66 154 224
Tabel 5.2 Daftar Nama Class Source Pembanding SOURCE PEMBANDING NO 1 2 3 4 5 6 7 8 9 10
NAMA CLASS prima.java nilai.java Lingkaran.java test2.java test4.java test6.java nilaiujian.java inputNama.java NewMain2.java Main.java
∑ KATA
∑ SIMBOL
∑ANGKA
46 94 49 20 25 29 75 33 60 100
49 120 50 25 31 36 104 33 87 123
2 5 2 2 2 4 10 0 3 1
TOTAL TOKEN 97 219 101 47 58 69 189 66 154 224
Untuk hasil analisa pengujian sistem terhadap kinerja algoritma dapat dilihat pada tabel 5.3.
52
Tabel 5.3 Hasil Analisa Pengujian Sistem NO 1 2 3 4 5 6 7 8 9 10
∑TOKEN YG SAMA 23 16 26 41 52 22 169 60 152 224
∑TOKEN YG DIPERIKSA 92 219 96 47 58 68 189 66 154 224
KEMIRIPAN (%) 25 7,31 27,08 87,23 89,66 32,35 89,42 90,91 98,7 100
WAKTU (S) 0,31 0,55 0,23 0,11 0,11 0,16 0,5 0,14 0,31 0,44
Pada tabel 5.3 diatas terdapat 10 hasil pengujian, dimana pengujian nomor 1 merupakan hasil pengujian Antara source nomor 1 pada tabel 5.1 dan source nomor 1 pada tabel 5.2. Begitu juga dengan hasil pengujian pada nomor dua merupakan hasil pengujian Antara source nomor 2 pada tabel 5.1 dengan source nomor 2 pada tabel 5.2, begitu juga dengan hasil pengujian nomor 3 sampai 10 diuji berdasarkan urutan nomor tabel 5.1 dan tabel 5.2.
BAB VI PENUTUP
6.1
Kesimpulan Berdasarkan uraian dan hasil analisa yang telah dilakukan selama
pengembangan Aplikasi Deteksi Kemiripan Source Code Pada Bahasa Pemrograman Java Menggunakan Metode Analisis Leksikal ini, dapat diambil kesimpulan sebagai berikut : 1.
Pada dasarnya proses deteksi kemiripan source code ini dilakukan dengan
mendeteksi struktur atau alur serta source code dari program tersebut dengan metode analisis leksikal. 2.
Hasil dari aplikasi ini berupa nilai presentase kemiripan yang dapat
digunakan sebagai acuan penentuan adanya tindakan plagiarisme.
6.2
Saran Dalam pembuatan Aplikasi Deteksi Kemiripan Source Code Pada Bahasa
Pemrograman Java Menggunakan Metode Analisis Leksikal ini masih banyak terdapat kekurangan dan jauh dari kata sempurna. Untuk itu masih perlu dilakukan sebuah penyempurnaan. Berikut beberapa saran untuk pengembangan lebih lanjut dari aplikasi ini : 1.
Aplikasi ini mendeteksi kemiripan kode program hanya pada bahasa java,
untuk kedepannya diharapkan dapat mendeteksi lebih dari satu bahasa pemrograman. 2. code,
Jumlah file yang diperiksa pada aplikasi ini berjumlah dua buah source untuk
lebih
menghemat
waktu
pemeriksaan
kedepannya
dapat
dikembangkan dengan memeriksaa file lebih dari satu. 3.
Aplikasi medeteksi source code yang diperiksa berupa source java atau
bukan dengan cara membaca ekstensi file yang di input, untuk pengembangan lebih lanjut diharapkan bisa mendeteksi bahasa pemrograman dari isi dan strukturnya.
53
Daftar Pustaka Anonymous, 2011, Netbeans, http://infoini.com/2011/pengertian-netbeans.html. Diakses tanggal 2 Mei 2015. Arifin, 2011, Pengertian Source Code, https://rahmatarifin93. wordpress.com /2011/09/22 /pengertian-source-code/. Diakses tanggal 29 februari 2016. Aulia, Ahmad, 2013, Pemanfaatan Algoritma Rabin-Karp Untuk Mengetahui Tingkat Kemiripan Dari Source Code Pada Pemrograman Lisp, jurnal, Sekolah Teknik Elektro dan Informatika, Institut Teknologi Bandung. Budhy, eka, 2014, Deteksi Similarity Source Code menggunakan Metode deteksi abstract syntax tree, seminar, Seminar Nasional Sains dan Teknologi 2014. Fakultas Tenik, Universitas Muhammadiyah Jakarta. Febriyanto Redya,dkk, 2006, Penerapan Algoritma Boyer-Moore Untuk Pengecekan Plagiatisme Source Code, jurnal, Laboratorium Ilmu dan Rekayasa Komputasi, Institut Teknologi Bandung. Henryw, 2014. Teknik Kompilasi, http://henryw.blog.binusian.org/teknikkompilasi.html. Diakses tanggal 29 Februari 2016. Miftahul dan Bunafit Komputer, 2010, Membuat Aplikasi Database dengan Java, MySQL dan NetBeans. PT Elex Media Komputindo, Jakarta. RosaA dan M.Shalahuddin, 2010, Modul Pembelajaran Pemograman Berorientasi Objek, Modula: Bandung. Sastroasmoro, S, 2007, Beberapa Catatan Tentang Plagiarisme, Majalah Kedokteran Indonesia, Volum: 57, Nomor: 8, Agustus 2007.
LAMPIRAN
LAMPIRAN Lampiran 1 Analisis_leksikal.java package Proses; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; public class Analisis_Leksikal { private BufferedReader reader; private char curr; private static final char EOF = (char) (-1); public Analisis_Leksikal(String file) { try { reader = new BufferedReader(new FileReader(file)); } catch (Exception e) { e.printStackTrace(); } curr = read(); } private char read() { try { return (char) (reader.read()); } catch (IOException e) { e.printStackTrace(); return EOF; } } private boolean isNumeric(char c) { if (c >= '0' && c <= '9') { return true; } return false; } public boolean isAlpha(char c) { if (c >= 'a' && c <= 'z') { return true; } if (c >= 'A' && c <= 'Z') { return true; } return false; } public Token nextToken() { int state = 1;
int numBuffer = 0; String alphaBuffer = ""; int decBuffer = 0; boolean skipped = false; while (true) { if (curr == EOF && !skipped) { skipped = true; } else if (skipped) { try { reader.close(); } catch (IOException e) { e.printStackTrace(); } return null; } switch(state) { case 1: switch(curr) { case ' ': case '\n': case '\b': case '\f': case '\r': case '\t': curr = read(); continue; case ';': curr = read(); return new Token("SM", case '+': curr = read(); return new Token("PO", case '-': curr = read(); return new Token("MO", case '*': curr = read(); return new Token("TO", case '/': curr = read(); state = 14; continue; case ',': curr = read(); return new Token("FA", case '(': curr = read(); return new Token("LP", case ')': curr = read(); return new Token("RP", case '{': curr = read(); return new Token("LB", case '}': curr = read();
";"); "+"); "-"); "*");
","); "("); ")"); "{");
return new Token("RB", case '[': curr = read(); return new Token("LS", case '<': curr = read(); return new Token("LT", case '>': curr = read(); return new Token("GT", case ']': curr = read(); return new Token("RS", case '.': curr = read(); return new Token("DT", case '%': curr = read(); return new Token("MD", case '=': curr = read(); state = 8; continue; case '!': curr = read(); state = 9; continue; case '&': curr = read(); state = 10; continue; case '|': curr = read(); state = 11; continue; case '"': curr = read(); state = 13; alphaBuffer = ""; continue; default: state = 2; continue; }o case 2: if (isNumeric(curr)) { numBuffer = 0; numBuffer += (curr - '0'); state = 3; curr = read(); } else { state = 5; } continue; case 3: if (isNumeric(curr)) {
"}"); "["); "<"); ">"); "]"); "."); "%");
numBuffer *= 10; numBuffer += (curr - '0'); curr = read(); } else if (curr == '.') { curr = read(); state = 4; } else { return new Token("NM", "" + numBuffer); } continue; case 4: if (isNumeric(curr)) { decBuffer = 0; decBuffer += (curr - '0'); state = 7; curr = read(); } else { return new Token("ERROR", "Invalid input: " + numBuffer + "."); } continue; case 7: if (isNumeric(curr)) { decBuffer *= 10; decBuffer += (curr - '0'); curr = read(); } else { return new Token("NM", "" + numBuffer + "." + decBuffer); } continue; case 5: if (isAlpha(curr) || curr == '_') { alphaBuffer = ""; alphaBuffer += curr; state = 6; curr = read(); } else { alphaBuffer = ""; alphaBuffer += curr; curr = read(); return new Token("ERROR", "Invalid input:" + alphaBuffer); } continue; case 6: if ((isAlpha(curr) || isNumeric(curr) || curr == '_')) { alphaBuffer += curr; curr = read(); } else { if (alphaBuffer.equals("class") || alphaBuffer.equals("abstract") || alphaBuffer.equals("assert") || alphaBuffer.equals("break") || alphaBuffer.equals("const") || alphaBuffer.equals("boolean") || alphaBuffer.equals("byte") || alphaBuffer.equals("case") || alphaBuffer.equals("catch") ||
alphaBuffer.equals("char") || alphaBuffer.equals("continue") || alphaBuffer.equals("default") || alphaBuffer.equals("do") || alphaBuffer.equals("double") || alphaBuffer.equals("else") || alphaBuffer.equals("enum") || alphaBuffer.equals("extends") || alphaBuffer.equals("final") || alphaBuffer.equals("finally") || alphaBuffer.equals("float") || alphaBuffer.equals("for") || alphaBuffer.equals("goto") || alphaBuffer.equals("if") || alphaBuffer.equals("implements") || alphaBuffer.equals("import") || alphaBuffer.equals("instanceof") || alphaBuffer.equals("int") || alphaBuffer.equals("interface") || alphaBuffer.equals("long") || alphaBuffer.equals("native") || alphaBuffer.equals("new") || alphaBuffer.equals("package") || alphaBuffer.equals("private") || alphaBuffer.equals("protected") || alphaBuffer.equals("public") || alphaBuffer.equals("return") || alphaBuffer.equals("short") || alphaBuffer.equals("static") || alphaBuffer.equals("super") || alphaBuffer.equals("switch") || alphaBuffer.equals("synchronized") || alphaBuffer.equals("String") || alphaBuffer.equals("strictfp") || alphaBuffer.equals("this") || alphaBuffer.equals("throw") || alphaBuffer.equals("throws") || alphaBuffer.equals("transient") || alphaBuffer.equals("try") || alphaBuffer.equals("void") || alphaBuffer.equals("volatile") || alphaBuffer.equals("false") || alphaBuffer.equals("true") || alphaBuffer.equals("null") || alphaBuffer.equals("while")) { return new Token("KW", "" + alphaBuffer); } else if (alphaBuffer.equals("true") || alphaBuffer.equals("false")) { return new Token("BL", "" + alphaBuffer); } return new Token("ID", "" + alphaBuffer); } continue; case 8: if (curr == '=') { curr = read(); return new Token("EQ", "=="); } else { return new Token("AO", "="); } case 9: if (curr == '=') { curr = read(); return new Token("NE", "!="); } else { return new Token("ERROR", "Invalid input: !"); } case 10: if (curr == '&') { curr = read(); return new Token("LA", "&&"); } else { return new Token("ERROR", "Invalid input: &"); }
case 11: if (curr == '|') { curr = read(); return new Token("LO", "||"); } else { return new Token("ERROR", "Invalid input: |"); } case 13: if (curr == '"') { curr = read(); return new Token("ST", "\"" + alphaBuffer + "\""); } else if (curr == '\n' || curr == EOF) { curr = read(); return new Token("ERROR", "Invalid string literal"); } else { alphaBuffer += curr; curr = read(); } continue; case 14: if (curr == '/') { state = 15; curr = read(); } else if (curr == '*') { state = 16; curr = read(); } else { return new Token("DO", "/"); } continue; case 15: if (curr == '\n') { state = 1; } curr = read(); continue; case 16: if (curr == '*') { state = 17; } curr = read(); continue; case 17: if (curr == '/') { curr = read(); state = 1; } else { curr = read(); state = 16; } continue; } }
Lampiran 2 Token.java package Proses; public class Token { private String token; private String lexeme; public Token(String token, String lexeme) { this.token = token; this.lexeme = lexeme; } public String getTokenType() { return token; } public String getLexeme() { return lexeme; } @Override public String toString() { return token + "\t" + lexeme; } }
Lampiran 3 sort.java package Proses; import import import import import import import import
java.io.BufferedReader; java.io.FileReader; java.io.FileWriter; java.io.IOException; java.text.Collator; java.util.ArrayList; java.util.Collections; java.util.List;
/** * * @author zero */ public class sort { public static void sortFile(String namaFile) throws IOException { FileReader fileReader = new FileReader("C:\\LOG\\Analisis Leksikal File 1.txt"); BufferedReader bufferedReader = new BufferedReader(fileReader); List<String> lines = new ArrayList<String>(); String line = null; while ((line = bufferedReader.readLine()) != null) { lines.add(line); } bufferedReader.close(); Collections.sort(lines, Collator.getInstance()); FileWriter writer = new FileWriter("C:\\LOG\\Analisis Leksikal File 1.txt"); for (String str : lines) { writer.write(str + "\r\n"); } writer.close(); }
Lampiran 5 Frame Scanner.java package User_Interface; import import import import import import import import import import import import import
Proses.Baca_File; Proses.sort; java.io.BufferedWriter; java.io.File; java.io.FileWriter; java.io.IOException; java.util.StringTokenizer; java.util.logging.Level; java.util.logging.Logger; javax.swing.JFileChooser; javax.swing.JOptionPane; javax.swing.UnsupportedLookAndFeelException; org.fife.ui.rsyntaxtextarea.SyntaxConstants;
/** * * @author zero */ public class Scanner extends javax.swing.JFrame { private File a; String inFile; String outFile = "C:\\LOG\\Analisis Leksikal File 1.txt"; String outFile2 = "C:\\LOG\\Analisis Leksikal File 2.txt"; /** * Creates new form Scanner */ public Scanner() { String lookAndFeel = javax.swing.UIManager.getSystemLookAndFeelClassName(); try { javax.swing.UIManager.setLookAndFeel(lookAndFeel); } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException e) { } initComponents(); this.setExtendedState(MAXIMIZED_BOTH); refresh(); jTextArea1.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA ); jTextArea1.setCodeFoldingEnabled(true); jTextArea2.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA ); jTextArea2.setCodeFoldingEnabled(true); }
private void refresh() { jTextArea1.setText(""); jTextArea2.setText(""); jmlKata1.setText("0"); jmlSimbol1.setText("0"); jmlAngka1.setText("0"); path1.setText(""); totalToken1.setText("0"); jmlKata2.setText("0"); jmlSimbol2.setText("0"); jmlAngka2.setText("0"); totalToken2.setText("0"); path2.setText(""); jmlKesamaan.setText("0"); total_sintaks.setText("0"); hasil.setText("0 %"); buttonGroup1.clearSelection(); waktu.setText("0 second"); notsimilar.setText("0"); hapusFile(); } private void jumlahSimbol() { String simbol = " SM PO MO TO FA LP RP LB RB LS LT GT RS DT MD EQ AO NE LA LO DO"; StringTokenizer st = new StringTokenizer(simbol, " "); String pat = "C:\\LOG\\Analisis Leksikal File 1.txt"; String teks = Baca_File.bacaFile(pat); int jumlah = 0; int indeks = -1; while (st.hasMoreTokens()) { String kata = st.nextToken(); indeks = teks.indexOf(kata); while (indeks >= 0) { ++jumlah; indeks += kata.length(); indeks = teks.indexOf(kata, indeks); } } jmlSimbol1.setText(String.valueOf(jumlah)); } private void jumlahLexem() { String simbol = " KW ST ID"; StringTokenizer st = new StringTokenizer(simbol, " "); String pat = "C:\\LOG\\Analisis Leksikal File 1.txt"; String teks = Baca_File.bacaFile(pat); int jumlah = 0; int indeks = -1; while (st.hasMoreTokens()) { String kata = st.nextToken(); indeks = teks.indexOf(kata); while (indeks >= 0) { ++jumlah; indeks += kata.length(); indeks = teks.indexOf(kata, indeks);
} } jmlKata1.setText(String.valueOf(jumlah)); } private void jumlah() { String pat = "C:\\LOG\\Analisis Leksikal File 1.txt"; String teks = Baca_File.bacaFile(pat); int jumlah = 0; int indeks = -1; String kata = "NM"; indeks = teks.indexOf(kata); while (indeks >= 0) { ++jumlah; indeks += kata.length(); indeks = teks.indexOf(kata, indeks); } jmlAngka1.setText(String.valueOf(jumlah)); } private void totalToken() { String pat = "C:\\LOG\\Analisis Leksikal File 1.txt"; String teks = Baca_File.bacaFile(pat); StringTokenizer st = new StringTokenizer(teks, "\n"); int jumlah; jumlah = st.countTokens(); totalToken1.setText(String.valueOf(jumlah)); } private void jumlahSimbol2() { String simbol = " SM PO MO TO FA LP RP LB RB LS LT GT RS DT MD EQ AO NE LA LO DO"; StringTokenizer st = new StringTokenizer(simbol, " "); String pat = "C:\\LOG\\Analisis Leksikal File 2.txt"; String teks = Baca_File.bacaFile(pat); int jumlah = 0; int indeks = -1; while (st.hasMoreTokens()) { String kata = st.nextToken(); indeks = teks.indexOf(kata); while (indeks >= 0) { ++jumlah; indeks += kata.length(); indeks = teks.indexOf(kata, indeks); } } jmlSimbol2.setText(String.valueOf(jumlah)); } private void jumlahLexem2() { String simbol = " KW ST ID"; StringTokenizer st = new StringTokenizer(simbol, " "); String pat = "C:\\LOG\\Analisis Leksikal File 2.txt"; String teks = Baca_File.bacaFile(pat); int jumlah = 0; int indeks = -1;
while (st.hasMoreTokens()) { String kata = st.nextToken(); indeks = teks.indexOf(kata); while (indeks >= 0) { ++jumlah; indeks += kata.length(); indeks = teks.indexOf(kata, indeks); } } jmlKata2.setText(String.valueOf(jumlah)); } private void jumlah2() { String pat = "C:\\LOG\\Analisis Leksikal File 2.txt"; String teks = Baca_File.bacaFile(pat); int jumlah = 0; int indeks = -1; String kata = "NM"; indeks = teks.indexOf(kata); while (indeks >= 0) { ++jumlah; indeks += kata.length(); indeks = teks.indexOf(kata, indeks); } jmlAngka2.setText(String.valueOf(jumlah)); } private void totalToken2() { String pat = "C:\\LOG\\Analisis Leksikal File 2.txt"; String teks = Baca_File.bacaFile(pat); StringTokenizer st = new StringTokenizer(teks, "\n"); int jumlah; jumlah = st.countTokens(); totalToken2.setText(String.valueOf(jumlah)); } private void openFile1() { JFileChooser pilihfile = new JFileChooser("."); int pilih1 = pilihfile.showOpenDialog(this); if (pilih1 == JFileChooser.APPROVE_OPTION) { a = pilihfile.getSelectedFile(); inFile = pilihfile.getSelectedFile().toString(); if (a.getPath().endsWith(".java") || a.getPath().endsWith(".JAVA")) { Proses.Analisis_Leksikal lexer = new Proses.Analisis_Leksikal(inFile); try { BufferedWriter writer = new BufferedWriter(new FileWriter(outFile)); Proses.Token t; while ((t = lexer.nextToken()) != null) { writer.write(t.toString()); writer.newLine(); } writer.close();
sort.sortFile(); } catch (IOException ieo) { ieo.addSuppressed(ieo); } String teks = Baca_File.bacaFile(a.getAbsolutePath()); jTextArea1.setText(teks); jTextArea1.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA ); jTextArea1.setCodeFoldingEnabled(true); path1.setText(a.getPath()); jumlah(); jumlahLexem(); jumlahSimbol(); totalToken(); } else { JOptionPane.showMessageDialog(rootPane, "Please choose java file"); } } else { System.out.println("gagal membaca file"); } } private void openFile2() { JFileChooser pilihfile = new JFileChooser("."); int pilih1 = pilihfile.showOpenDialog(this); if (pilih1 == JFileChooser.APPROVE_OPTION) { a = pilihfile.getSelectedFile(); inFile = pilihfile.getSelectedFile().toString(); if (a.getPath().endsWith(".java") || a.getPath().endsWith(".JAVA")) { Proses.Analisis_Leksikal lexer = new Proses.Analisis_Leksikal(inFile); try { BufferedWriter writer = new BufferedWriter(new FileWriter(outFile2)); Proses.Token t; while ((t = lexer.nextToken()) != null) { writer.write(t.toString()); writer.newLine(); } writer.close(); sort.sortFile2(); } catch (IOException ieo) { ieo.addSuppressed(ieo); } String teks = Baca_File.bacaFile(a.getAbsolutePath()); jTextArea2.setText(teks);
jTextArea2.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA ); jTextArea2.setCodeFoldingEnabled(true); path2.setText(a.getPath()); jumlah2(); jumlahLexem2(); jumlahSimbol2(); totalToken2(); } else { JOptionPane.showMessageDialog(rootPane, "Please choose java file"); } } else { System.out.println("gagal membaca file"); } } private void similar() { jTextArea1.setText(""); jTextArea2.setText(""); String src1 = "C:\\LOG\\similar1.txt"; String src2 = "C:\\LOG\\similar2.txt"; String source1 = Baca_File.bacaFile(src1); String source2 = Baca_File.bacaFile(src2); StringTokenizer st = new StringTokenizer(source1, "\n"); StringTokenizer st2 = new StringTokenizer(source2, "\n"); String teks1 = ""; String teks2 = ""; while (st.hasMoreTokens()) { teks1 += st.nextToken() + "\n"; } while (st2.hasMoreTokens()) { teks2 += st2.nextToken() + "\n"; } jTextArea1.setText(teks1); jTextArea2.setText(teks2); } private void notsimilar() { jTextArea1.setText(""); jTextArea2.setText(""); String src1 = "C:\\LOG\\notsimilar1.txt"; String src2 = "C:\\LOG\\notsimilar2.txt"; String source1 = Baca_File.bacaFile(src1); String source2 = Baca_File.bacaFile(src2); StringTokenizer st = new StringTokenizer(source1, "\n"); StringTokenizer st2 = new StringTokenizer(source2, "\n"); String teks1 = ""; String teks2 = ""; while (st.hasMoreTokens()) { teks1 += st.nextToken() + "\n"; } while (st2.hasMoreTokens()) { teks2 += st2.nextToken() + "\n";
} jTextArea1.setText(teks1); jTextArea2.setText(teks2); } private void showResult() { jTextArea1.setText(""); jTextArea2.setText(""); String src1 = "C:\\LOG\\Analisis Leksikal File 1.txt"; String src2 = "C:\\LOG\\Analisis Leksikal File 2.txt"; String source1 = Baca_File.bacaFile(src1); String source2 = Baca_File.bacaFile(src2); StringTokenizer st = new StringTokenizer(source1, "\n"); StringTokenizer st2 = new StringTokenizer(source2, "\n"); String teks1 = ""; String teks2 = ""; while (st.hasMoreTokens()) { teks1 += st.nextToken() + "\n"; } while (st2.hasMoreTokens()) { teks2 += st2.nextToken() + "\n"; } jTextArea1.setText(teks1); jTextArea2.setText(teks2); } private void hapusFile() { File f1 = new File("C:\\LOG\\similar1.txt"); File f2 = new File("C:\\LOG\\similar2.txt"); File f3 = new File("C:\\LOG\\notsimilar1.txt"); File f4 = new File("C:\\LOG\\notsimilar2.txt"); f1.delete(); f2.delete(); f3.delete(); f4.delete(); } long start; long end; private void perhitunganKemiripan() { start = System.currentTimeMillis(); String path3 = "C:\\LOG\\Analisis Leksikal File 1.txt"; String path4 = "C:\\LOG\\Analisis Leksikal File 2.txt"; String simpan = "C:\\LOG\\similar1.txt"; String simpan2 = "C:\\LOG\\similar2.txt"; String simpan3 = "C:\\LOG\\notsimilar1.txt"; String simpan4 = "C:\\LOG\\notsimilar2.txt"; String teks = Baca_File.bacaFile(path3); String teks2 = Baca_File.bacaFile(path4); StringTokenizer st = new StringTokenizer(teks, "\n"); StringTokenizer st2 = new StringTokenizer(teks2, "\n"); int i = 0, x = 0, found = 0, notfound = 0; String[] f1 = new String[st.countTokens()]; String[] f2 = new String[st2.countTokens()];
if (st2.countTokens() > st.countTokens()) { int totToken = st2.countTokens() - st.countTokens(); while (st2.hasMoreTokens()) { while (st.hasMoreTokens()) { f1[i] = st.nextToken(); f2[x] = st2.nextToken(); if (f1[i].equals(f2[x])) { found = found + 1; Baca_File.tulisFile(f1[i], simpan); Baca_File.tulisFile(f2[x], simpan2); } else { notfound = notfound + 1; Baca_File.tulisFile(f1[i], simpan3); Baca_File.tulisFile(f2[x], simpan4); } x++; } double tot = found + notfound; int total = found + notfound; double persen = (found / tot) * 100; jmlKesamaan.setText(String.valueOf(found)); notsimilar.setText(String.valueOf(notfound)); total_sintaks.setText(String.valueOf(total)); hasil.setText(String.format("%.2f", persen) + " %"); if (persen >= 70) { jRadioButton1.setSelected(true); } else { jRadioButton2.setSelected(true); } end = System.currentTimeMillis(); waktu.setText(String.format("%.2f", (end - start) / 1000.00) + " seconds"); i++; break; } } else { int totToken = st.countTokens() - st2.countTokens(); while (st.hasMoreTokens()) { while (st2.hasMoreTokens()) { f1[i] = st.nextToken(); f2[x] = st2.nextToken(); if (f1[i].equals(f2[x])) { found = found + 1; Baca_File.tulisFile(f1[i], simpan); Baca_File.tulisFile(f2[x], simpan2); } else { notfound = notfound + 1; Baca_File.tulisFile(f1[i], simpan3); Baca_File.tulisFile(f2[x], simpan4); } x++; } double tot = Double.parseDouble(totalToken1.getText());
int total = Integer.parseInt(totalToken1.getText()); double persen = (found / tot) * 100; jmlKesamaan.setText(String.valueOf(found)); notsimilar.setText(String.valueOf(notfound)); total_sintaks.setText(String.valueOf(total)); hasil.setText(String.format("%.2f", persen) + " %"); if (persen >= 70) { jRadioButton1.setSelected(true); } else { jRadioButton2.setSelected(true); } end = System.currentTimeMillis(); waktu.setText(String.format("%.2f", (end - start) / 1000.00) + " seconds"); i++; break; } } } private void tulisSource1() { String input1 = "C:\\LOG\\source1.java"; Baca_File.write(jTextArea1.getText(), input1); Proses.Analisis_Leksikal lexer = new Proses.Analisis_Leksikal("C:\\LOG\\source1.java"); try { BufferedWriter writer = new BufferedWriter(new FileWriter("C:\\LOG\\Analisis Leksikal File 1.txt")); Proses.Token t; while ((t = lexer.nextToken()) != null) { writer.write(t.toString()); writer.newLine(); } writer.close(); sort.sortFile(); jumlah(); jumlahLexem(); jumlahSimbol(); totalToken(); } catch (IOException ieo) { ieo.addSuppressed(ieo); } } private void tulisSource2() { String input1 = "C:\\LOG\\source2.java"; Baca_File.write(jTextArea2.getText(), input1); Proses.Analisis_Leksikal lexer = new Proses.Analisis_Leksikal("C:\\LOG\\source2.java"); try { BufferedWriter writer = new BufferedWriter(new FileWriter("C:\\LOG\\Analisis Leksikal File 2.txt")); Proses.Token t; while ((t = lexer.nextToken()) != null) {
writer.write(t.toString()); writer.newLine(); } writer.close(); sort.sortFile2(); jumlah2(); jumlahLexem2(); jumlahSimbol2(); totalToken2(); } catch (IOException ieo) { ieo.addSuppressed(ieo); } }
