skripsi deteksi kemiripan source code pada bahasa

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
<<include>>
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);
}
}