Upload
buituyen
View
220
Download
1
Embed Size (px)
Citation preview
SKRIPSI
Pengembangan Aplikasi Content Management System Untuk
Mobile Learning Bagi Pengajar Berbasis Java
ADITYA PRASETIO
105091002893
PROGRAM STUDI TEKNIK INFORMATIKA
FAKULTAS SAINS DAN TEKNOLOGI
UNIVERSITAS ISLAM NEGERI SYARIF HIDAYATULLAH
JAKARTA
2010
ii
PENGEMBANGAN APLIKASI CONTENT MANAGEMENT
SYSTEM UNTUK MOBILE LEARNING BAGI PENGAJAR
BERBASIS JAVA
SKRIPSI
Sebagai Salah Satu Syarat untuk Memperoleh Gelar
Sarjana Komputer
Pada Fakultas Sains dan Teknologi
Universitas Islam Negeri Syarif Hidayatullah Jakarta
Oleh :
Aditya Prasetio
105091002893
PROGRAM STUDI TEKNIK INFORMATIKA
FAKULTAS SAINS DAN TEKNOLOGI
UNIVERSITAS ISLAM NEGERI SYARIF HIDAYATULLAH
JAKARTA
2010
iii
PENGEMBANGAN APLIKASI CONTENT MANAGEMENT SYSTEM
UNTUK MOBILE LEARNING BAGI PENGAJAR BERBASIS JAVA
FAKULTAS SAINS DAN TEKNOLOGI
UIN SYARIF HIDAYATULLAH JAKARTA)
Skripsi
Sebagai Salah Satu Syarat Untuk Memperoleh Gelar Sarjana Komputer
Pada Fakultas Sains dan Teknologi
Universitas Islam Negeri Syarif Hidayatullah Jakarta
Oleh:
ADITYA PRASETIO
105091002893
Menyetujui,
Pembimbing I,
Imam M. Shofi, MT NIP. 19720205 200801 1 010
Pembimbing II,
Viva Arifin, MMSI NIP. 19730810 200604 2 001
Mengetahui,
Ketua Program Studi Teknik Informatika
Yusuf Durrachman, M. Sc, MIT NIP. 19710522 200604 1 002
v
ABSTRAK
ADITYA PRASETIO (105091002893). Pengembangan Aplikasi Content Management System Untuk Mobile Learning Bagi Pengajar Berbasis Java. Di bawah bimbingan IMAM M. SHOFI dan VIVA ARIFIN.
Selama satu dekade terakhir, dunia pendidikan dan pelatihan sangat dipengaruhi oleh perkembangan teknologi. Fenomena ini akan semakin menguat mengingat teknologi ke depan akan semakin kompleks, powerfull, dan terjangkau secara ekonomi. Sebagai contoh paling populer, internet kini sudah menjadi kebutuhan penting bagi siapa pun yang terlibat dalam aktifitas pendidikan dan pelatihan, baik sebagai media maupun sumber belajar. Pada penelitian sebelumnya setiap aplikasi hanya terbatas pada satu pelajaran saja sehingga pengguna memerlukan aplikasi berbeda pada setiap pelajaran. Disamping itu pengguna harus mengunduh aplikasi tersebut ke handphone mereka, hal ini membuat content menjadi statis. Oleh karena itu, dirasa perlu untuk memngembangkan aplikasi mobile learning yang memiliki content dinamis. Adapun metodologi yang penulis gunakan dalam membuat aplikasi ini adalah menggunakan RAD, yang mempunyai lima tahapan, yaitu Communication, Planning, Modelling, Construction, dan Deployment. Penulis menggunakan bahasa pemrogaman Java, Framework Jmaki untuk AJAX, ORM Hibernate dan database MySQL dalam membuat aplikasi ini. Dengan adanya aplikasi ini maka akan mempermudah pengajar dalam memberikan materi belajar maupun soal latihan tanpa terbatas oleh ruang dan waktu sehingga diharapkan dapat meningkatkan efektifitas dalam belajar. .
Kata Kunci: Mobile learning, Content Management System, web dinamis, RAD.
vi
HALAMAN PERNYATAAN
DENGAN INI SAYA MENYATAKAN BAHWA SKRIPSI INI BENAR-
BENAR ASLI KARYA SENDIRI YANG BELUM PERNAH DIAJUKAN
SEBAGAI SKRIPSI ATAU KARYA ILMIAH PADA PERGURUAN TINGGI
ATAU LEMBAGA MANAPUN.
Jakarta, 31 Oktober 2010
Aditya Prasetio 105091002893
vii
KATA PENGANTAR
Segala puja puji dan syukur penulis panjatkan kehadirat Allah SWT atas
segala karunia serta petunjuk-Nya sehingga penulis dapat menyelesaikan
penulisan skripsi yang berjudul Pengembangan Aplikasi Content Management
System Untuk Mobile Learning Bagi Pengajar Berbasis Java ini dengan baik.
Shalawat serta salam penulis sanjungkan kepada Baginda Nabi Muhammad SAW,
keluarga serta sahabat beliau.
Setelah terselesaikannya penulisan skripsi ini, penulis ingin mengucapkan
terima kasih kepada pihak-pihak yang telah membantu penulis, baik berupa
bimbingan, moril maupun materiil, yang penulis tujukan kepada:
1. Bapak DR. Syopiansyah Jaya Putra, M.Sis, selaku Dekan Fakultas Sains
dan Teknologi, UIN Syarif Hidayatullah Jakarta.
2. Bapak Yusuf Durrachman, M.Sc, MIT, selaku Ketua Program Studi
Teknik Informatika, Fakultas Sains dan Teknologi, UIN Syarif
Hidayatullah Jakarta.
3. Bapak Imam M. Shofi, MT, selaku dosen pembimbing I yang telah
memberikan pengarahan dalam menyelesaikan penulisan skripsi ini.
4. Ibu Viva Arifin, MMSI, selaku dosen pembimbing II yang telah
memberikan bimbingan dan saran ditengah kesibukannya.
5. Mama (Almh. Sri Kadariyah) dan Papa (Alm. Achmad Soeharto) yang
telah melahirkan, mendidik, serta membimbing penulis. Terima kasih atas
segala pengorbanan, baik waktu, tenaga, biaya serta doa.
viii
Jakarta, 31 Oktober 2010
Penulis
6. Kakak (Putri Mira Gayatri, S.Psi) yang senantiasa memberikan dorongan
semangat dan doa untuk penulis dalam penyelesaian skripsi ini.
7. Teman-teman seperjuangan kelas TI-D 2005: Wildan, Zaky, Harry, Didi,
Ale, Ipul, Shodik, Ery, Fahmi, Rindy, Deni, Lia, Yusup, Novan, Mukhlis,
Zanba, Bayu, Randy. Teman-teman satu angkatan yang tidak dapat penulis
sebutkan satu persatu. Terima kasih semuanya.
8. Rekan-rekan di DNP Webdesign, Pak Dipto, Pak Dicky, Pak Anam, Mba
Yul, Koko, Eko atas motivasi dan pengertiannya.
9. Dan semua pihak yang telah membantu pelaksanaan dan penyusunan
skripsi ini yang tidak dapat penulis sebutkan satu persatu.
Penulis menyadari bahwa dalam skripsi ini tentu masih jauh dari
sempurna, seperti kata pepatah ”Tak Ada Gading Yang Tak Retak”. Oleh karena
itu penulis mengharapkan kritik dan saran yang bersifat membangun agar
penyusunan skripsi ini menjadi lebih baik lagi ke depannya.
Akhir kata, semoga skripsi ini bermanfaat khususnya bagi penulis sendiri
dan bagi yang membacanya.
ix
DAFTAR ISI
Halaman Judul ............................................................................................ i
Halaman Sampul ......................................................................................... ii
Lembar Pengesahan .................................................................................... iii
Lembar Persetujuan Penguji ..................................................................... iv
Abstrak ......................................................................................................... v
Halaman Pernyataan .................................................................................. vi
Kata Pengantar ........................................................................................... vii
Daftar Isi ...................................................................................................... ix
Daftar Tabel ................................................................................................. xii
Daftar Gambar ............................................................................................ xiii
BAB 1 PENDAHULUAN
1.1 Latar Belakang .................................................................................. 1
1.2 Rumusan Masalah ............................................................................. 3
1.3 Batasan Masalah ............................................................................... 3
1.4 Tujuan dan Manfaat Penelitian ......................................................... 4
1.4.1 Tujuan Penelitian ...................................................................... 4
1.4.2 Manfaat Penelitian .................................................................... 4
1.5 Metodologi Penelitian ....................................................................... 5
1.5.1 Metode Pegumpulan Data ........................................................ 5
1.5.2 Metode Pengembangan Perangkat Lunak ................................ 5
1.6 Sistematika Penulisan ....................................................................... 6
BAB 2 LANDASAN TEORI
2.1 Pengembangan Sistem ....................................................................... 8
2.2 Mobile Learning (m-Learning) .......................................................... 9
2.2.1 m-Learning berbasis Web ........................................................ 9
2.3 Content Management System (CMS) ................................................ 10
2.3.1 Learning Management System (LMS) ..................................... 11
x
2.4 JAVA ................................................................................................ 12
2.5 Hibernate 3 ......................................................................................... 12
2.6 Framework JMaki .............................................................................. 13
2.7 Database MySQL .............................................................................. 16
2.8 Sekilas tentang IDE Netbeans ........................................................... 17
2.9 Unit Testing ....................................................................................... 18
2.10 System Testing ................................................................................ 19
2.10.1 Recovery Testing ................................................................... 19
2.10.2 Security Testing ..................................................................... 20
2.10.3 Stress Testing ......................................................................... 21
2.10.4 Performance Testing .............................................................. 21
2.11 Desain Antar Muka .......................................................................... 22
2.12 Rapid Application Development ...................................................... 22
2.13 Studi literatur Sejenis ....................................................................... 24
BAB 3 METODOLOGI PENELITIAN
3.1 Metode Pengumpulan Data ............................................................... 32
3.1.1 Wawancara ............................................................................... 32
3.1.2 Studi Pustaka ............................................................................. 32
3.1.3 Studi Literatur Sejenis ............................................................... 33
3.2 Bahan dan Alat ................................................................................... 33
3.2.1 Perangkat Keras ........................................................................ 33
3.2.2 Perangkat Lunak ....................................................................... 34
3.3 Metode Pengembangan Sistem ......................................................... 34
BAB 4 HASIL DAN PEMBAHASAN
4.1 Communication ................................................................................. 40
4.1.1 Analisis Kebutuhan User .......................................................... 40
4.1.2 Alat dan Bahan ......................................................................... 40
4.2 Planning ............................................................................................ 41
4.3 Modelling .......................................................................................... 42
xi
4.3.1 Use Case Diagram .................................................................... 42
4.3.2 Entity Relational Diagram (ERD) ............................................. 51
4.3.3 Pemodelan Antar Muka ............................................................. 55
4.3.4 Pemodelan Kelas ....................................................................... 59
4.4 Construction ...................................................................................... 63
4.4.1 Implementasi Antar Muka ........................................................ 57
4.4.2 Unit Testing .............................................................................. 71
4.4.3 System Testing .......................................................................... 73
4.5 Deployment ....................................................................................... 83
4.5.1 Deployment .............................................................................. 83
4.5.2 Delivery Feedback .................................................................... 83
BAB 5 PENUTUP
5.1 Kesimpulan ....................................................................................... 84
5.2 Saran .................................................................................................. 85
Daftar Pustaka ............................................................................................. 86
Lampiran ..................................................................................................... 88
xii
DAFTAR TABEL
Tabel 2.1 Rekomendasi standar untuk mobile web ....................................... 10
Tabel 4.1 Planning Pembuatan Aplikasi ........................................................ 42
Tabel 4.2 Tabel Use Case User ..................................................................... 43
Tabel 4.3 Tabel Use Case Manajemen User .................................................. 44
Tabel 4.4 Tabel Use Case Materi ................................................................... 46
Tabel 4.5 Tabel Use Case Autentikasi User ................................................... 47
Tabel 4.6 Tabel Use Case Manajemen File ................................................... 49
Tabel 4.7 Tabel Use Case Manajemen Gambar ............................................. 50
Tabel 4.8 Tabel User ...................................................................................... 52
Tabel 4.9 Tabel Materi ................................................................................... 53
Tabel 4.10 Tabel Matkul ................................................................................ 53
Tabel 4.11 Tabel Kuliah ................................................................................. 54
Tabel 4.12 Tabel Image.................................................................................. 54
Tabel 4.13 Tabel File ..................................................................................... 54
Tabel 4.14 Tabel Security Testing pada halaman frontend ............................ 74
Tabel 4.15 Tabel Security Testing pada halaman Adminsitrator ................... 74
Tabel 4.16 Hasil Performance data pada Stress Testing ............................... 75
Tabel 4.17 Hasil Response Time data pada Stress Testing ............................ 76
Tabel 4.18 Hasil Bandwith Usage data pada Stress Testing .......................... 77
Tabel 4.19 Hasil Errors report data pada Stress Testing .............................. 78
Tabel 4.20 Hasil Performance data data pada Performance Testing ............ 79
Tabel 4.21 Hasil Response time data pada Performance Testing .................. 80
Tabel 4.22 Hasil Bandwith Usage data pada Performance Testing .............. 81
Tabel 4.23 Hasil Errors Report data pada Performance Testing .................. 82
Tabel 5.1 Rangkuman Hasil pengujian ......................................................... 84
xiii
DAFTAR GAMBAR
Gambar 2.1 Arsitektur jMaki ......................................................................... 14
Gambar 2.2 Arsitektur MySQL server ........................................................... 17
Gambar 2.3 Splash Screen NetBeans 6.7.1 ................................................... 19
Gambar 3.1 The RAD Model .......................................................................... 35
Gambar 3.2 Tahapan dan Rincian Pengembangan Sistem............................. 39
Gambar 4.1 Use Case Diagram Autentikasi User .......................................... 42
Gambar 4.2 Use Case Diagram Manajemen User ......................................... 44
Gambar 4.3 Use Case Diagram Manajemen Materi ...................................... 46
Gambar 4.4 Use Case Diagram Manajemen Course ...................................... 47
Gambar 4.5 Use Case Diagram Manajemen Gambar .................................... 49
Gambar 4.6 Use Case Diagram Manajemen File ........................................... 50
Gambar 4.7 Entity Relational Diagram (ERD) ............................................ 51
Gambar 4.8 Perancangan halaman Login ...................................................... 55
Gambar 4.9 Perancangan halaman Kelas ....................................................... 56
Gambar 4.10 Perancangan halaman Kuliah ................................................... 57
Gambar 4.11 Perancangan halaman Materi ................................................... 53
Gambar 4.12 Perancangan halaman Mata Kuliah .......................................... 58
Gambar 4.13 Perancangan halaman User ...................................................... 59
Gambar 4.14 Class Diagram pada package entity ......................................... 61
Gambar 4.15 Class Diagram pada package DAO .......................................... 62
Gambar 4.16 Halaman Login ......................................................................... 63
Gambar 4.17 Halaman Mata Kuliah .............................................................. 64
Gambar 4.18 Halaman Materi ........................................................................ 64
Gambar 4.19 Halaman User ........................................................................... 65
Gambar 4.20 Halaman Upload File ............................................................... 65
Gambar 4.21 Halaman Image Manager ......................................................... 66
Gambar 4.22 Halaman Materi untuk Tutor .................................................... 66
Gambar 4.23 Halaman User untuk Tutor ....................................................... 67
Gambar 4.24 Halaman Frontend daftar Dosen .............................................. 67
xiv
Gambar 4.25 Halaman Frontend daftar Mata Kuliah .................................... 68
Gambar 4.26 Halaman Frontend Profil Dosen .............................................. 68
Gambar 4.27 Halaman Frontend Materi ........................................................ 69
Gambar 4.28 Halaman Hasil Pencarian ......................................................... 69
Gambar 4.29 Pengujian pada handphone Nokia E63..................................... 70
Gambar 4.30 Pengujian pada handphone Nokia E51 .................................... 70
Gambar 4.31 Pengujian pada handphone Nokia C3 ...................................... 71
Gambar 4.32 Hasil Unit Testing class materi ................................................ 71
Gambar 4.33 Hasil Unit Testing class matkul ................................................ 72
Gambar 4.34 Hasil Unit Testing class user .................................................... 72
Gambar 4.35 Hasil Unit Testing class file ..................................................... 72
Gambar 4.36 Hasil Unit Testing class Image ................................................. 73
1
BAB I
PENDAHULUAN
1.1 Latar Belakang
Selama satu dekade terakhir, dunia pendidikan dan pelatihan sangat
dipengaruhi oleh perkembangan teknologi. Fenomena ini akan semakin menguat
mengingat teknologi ke depan akan semakin kompleks, powerfull, dan terjangkau
secara ekonomi. Sebagai contoh paling populer, internet kini sudah menjadi
kebutuhan penting bagi siapa pun yang terlibat dalam aktifitas pendidikan dan
pelatihan, baik sebagai media maupun sumber belajar.
Hal yang sama pun terjadi pada teknologi bergerak (mobile technology).
Perkembangan baik dalam hal jaringan (Wi-Fi, 3G, WiMAX) maupun peralatan
(smart phones, pocket PCs, tablet PCs, serta PDA) telah menyebabkan teknologi
ini berkembang cepat. Tak heran bila kemudian pengguna telepon bergerak saat
ini sangat mudah ditemui (Essa:1).
Memang, penggunaan telepon bergerak selama ini masih terfokus pada
kegiatan seperti menelpon, mengirim sms, mendengarkan musik, menonton video,
serta mengelola agenda pribadi. Tetapi belakangan, telepon bergerak maupun
peralatan bergerak lainnya seperti smart phone dan PDA mulai dieksplorasi
penggunaannya untuk kepentingan pembelajaran. Dengan sifat fleksibilitas dan
personalnya, peralatan bergerak tersebut dianggap dapat melahirkan model belajar
baru, yang kemudian dikenal dengan mobile learning.
2
Terhitung dari tahun 2006 muncul ketertarikan yang tinggi pada potensi
mobile learning, yang ditunjukkan dengan banyaknya project dan penelitian
tentangnya. Cobcroft, Towers, Smith & Bruns (2006) menyatakan lebih dari 400
publikasi tentang mobile learning termasuk didalamnya papers, konferensi,
reports, dan proyek penelitian.
Pada penelitian sebelumnya setiap aplikasi hanya terbatas pada satu
pelajaran saja sehingga pengguna memerlukan aplikasi berbeda pada setiap
pelajaran. Disamping itu pengguna harus mendownload aplikasi tersebut ke
handphone mereka, hal ini membuat content menjadi statis.
Berdasarkan content yang masih statis, maka penulis mengembangkan
sebuah Content Management System untuk mengisi materi, agar content aplikasi
dapat disesuaikan dengan kebutuhan dan tidak terbatas dengan satu mata pelajaran
saja. Aplikasi yang penulis kembangkan tidak membatasi pembelajar untuk
mengakses content pembelajaran apapun yang ada, dengan demikian pambelajar
dapat leluasa mendapatkan materi belajar. Untuk mengakses aplikasi yang penulis
kembangkan pengguna cukup menggunakan web browser pada telepon genggam
mereka.
Judul yang penulis angkat adalah “Pengembangan Aplikasi Content
Management System untuk Mobile Learning Bagi Pengajar Berbasis Java”.
Diharapkan penelitian ini akan mempermudah pengajar dalam memberikan materi
belajar tambahan maupun soal latihan, sehingga diharapkan dapat meningkatkan
efektifitas dalam belajar.
3
1.2 Rumusan Masalah
Masalah yang dapat dirumuskan dalam tugas akhir ini sebagai berikut :
1. Bagaimana mengembangkan sebuah aplikasi Content Management Sistem
untuk mobile learning yang diperlukan bagi pengajar.
2. Bagaimana membuat aplikasi web Content Management Sistem untuk mobile
learning yang dapat diakses melalui telepon genggam.
1.3 Batasan Masalah
Adapun batasan masalah untuk skripsi ini antara lain:
1. Mobile learning berperan sebagai pendamping untuk sistem belajar yang
ada.
2. Pengguna memerlukan handphone memiliki mobile browser untuk
mengakses sistem ini.
3. Pengajar memiliki hak untuk menambah isi materi yang sesuai dengan
bidang yang diajarnya.
4. File yang diperbolehkan untuk diupload adalah file berformat .doc, .docx,
ppt, pptx, xls, xlsx .pdf, .flv, dan MP3.
5. Pembelajar hanya bisa melihat materi yang telah dimasukkan oleh
pengajar serta mendownload file.
6. Pembelajar bebas memilih materi apa saja yang ada pada aplikasi m-
Learning, tidak terbatas oleh kelas dan semester yang diikutinya.
7. Bagian yang dapat diakses dengan handphone hanya pada frontend,
sedangkan bagian beckend diakses dengan komputer atau laptop.
4
8. M-Learning akan dibangun menggunakan teknologi Java 1.5 dengan IDE
Netbeans 6.7.1.
1.4 Tujuan dan Manfaat Penelitian
1.4.1 Tujuan Penelitian
Untuk mempermudah pengajar dalam memberikan materi belajar
maupun soal latihan tanpa terbatas oleh ruang dan waktu sehingga diharapkan
dapat meningkatkan efektifitas dalam belajar.
1.4.2 Manfaat Penelitian
Manfaat yang didapatkan dalam melakukan skripsi ini adalah :
a. Bagi Penulis :
1. Menambah wawasan penulis tentang teknologi berbasis Java dan
menerapkannya langsung.
2. Menambah wawasan penulis tentang mobile Learning.
3. Mendapatkan pemahaman mengenai metodologi penelitian,
khususnya Rapid Application Development (RAD).
b. Bagi Pengguna :
1. Memberikan independensi waktu dan tempat pada pengguna dalam
memberikan materi belajar dan soal latihan kepada pembelajar.
2. Berguna sebagai tambahan dalam belajar bagi pembelajar.
5
c. Bagi Universitas :
1. Mengetahui kemampuan mahasiswa dalam menguasai materi ilmu
yang telah diperoleh dibangku kuliah.
2. Mengetahui kemampuan mahasiswa dalam menerapkan ilmunya
dan sebagai bahan evaluasi.
3. Memberikan gambaran tentang kesiapan mahasiswa dalam
menghadapi dunia kerja dari hasil yang diperoleh selama kuliah.
1.5 Metodologi Penelitian
Metodologi Penelitian yang penulis gunakan adalah sebagai berikut :
1.5.1 Pengumpulan data
a. Wawancara
Teknik yang penulis gunakan dalam memperoleh data adalah dengan
cara mengajukan pertanyaan-pertanyaan kepada Kepala Pusat Data Teknik
informatika Fakultas Sains dan Teknologi (PUSDATIN FST).
b. Studi Pustaka
Mengumpulkan data dan informasi dengan cara membaca dan
mempelajari buku-buku literatur referensi serta situs-situs internet yang
berkenaan dengan topik yang dapat dijadikan acuan pembahasan dalam
penelitian ini.
1.5.2 Metode Pengembangan Perangkat Lunak
Metode pengembangan perangkat lunak yang penulis gunakan adalah
SDLC (System Development Live Cycle) model linear sequencial yang
6
sering disebut RAD (Rapid Application Development). Tahapannya
adalah sebagai berikut :
1. Communication.
2. Planning.
3. Modelling.
4. Construction (Implementation).
5. Deployment
1.6 Sistematika Penulisan
Penelitian ini terdiri dari lima bab, dengan penjelasan tiap-tiap bab sebagai
berikut :
BAB I : PENDAHULUAN
Pada bab ini berisi tentang Latar Belakang, Rumusan Masalah, Batasan Masalah,
Tujuan dan Manfaat Penelitian, Metodologi Penelitian serta Sistematika Penulisan
Penelitian.
BAB II: LANDASAN TEORI
Pada bab ini menjelaskan tentang teori perangkat keras dan perangkat lunak,
definisi sistem, analisa sistem, definisi perancangan sistem dan jenis program
yang digunakan.
BAB III: METODOLOGI PENELITIAN
Pada bab ini akan menguraikan dan memberikan penjelasan mengenai
perancangan perangkat lunak, perancangan sistem sehingga dapat diketahui
rencana yang akan dikerjakan.
7
BAB IV: PEMBAHASAN DAN IMPLEMENTASI
Pada bab ini akan menjelaskan mengenai pembuatan sistem dan pengujian sistem.
BAB V: PENUTUP
Bab ini berisi kesimpulan dari pembahasan masalah dan saran-saran berkenaan
dengan penelitian ini.
8
BAB II
LANDASAN TEORI
2.1 Pengembangan Sistem
Pengembangan sistem yaitu menyusun sistem yang baru untuk menggantikan
sistem yang lama secara keseluruhan atau perbaikan pada sistem yang telah ada
dengan harapan bahwa sistem yang baru dapat mengatasi sistem yang lama.
(Mcleod, J., 1996).
Pengembangan sistem dapat berarti menyusun suatu sistem yang baru untuk
menggantikan sistem yang lama secara keseluruhan atau memperbaiki sistem
yang telah ada.
Dengan telah dikembangkannya sistem yang baru, maka diharapkan akan
terjadi peningkatan-peningkatan ini antara lain:
1. Performance (Kinerja), yaitu terjadi peningkatan terhadap kinerja (hasil
kerja) sistem yang baru sehingga menjadi lebih efektif.
2. Throughput, yaitu jumlah dari pekerjaan yang dapat dilakukan suatu saat
tertentu.
3. Control (pengemdalian), yaitu peningkatan terhadap pengendalian untuk
mendeteksi dan memperbaiki kesalahan-kesalahan serta kecurangan-
kecurangan yang akan terjadi.
9
4. Service (pelayanan), bagaimana peningkatan terhadap pelayanan yang
diberikan oleh sistem.
2.2 Mobile Learning (m-Learning)
Mobile learning (m-Learning) adalah penggunaan teknologi wireless mobile
yang memungkinkan pengaksesan informasi dan meteri belajar kapanpun dan
dimanapun. Dengan demikinan, pembelajar memiliki control penuh atas tempat
dan waktu untuk belajar. Semua manusia memiliki hak yang sama dalam
mengakses informasi dan materi belajar untuk meningkatkan kualitas mereka
terlepas dari asal, status, dan budaya mereka (Mohamed. 2009: 1).
2.2.1 Mobile Learning Berbasis Web
Mobile learning berbasis web memiliki standard content yang dapat
diakses melalui web browser pada mobile devices yang dijelaskan oleh W3C
Mobile Web Initiative (MWI) yang merupakan sebuah kolaborasi industri dan
teknologi yang bertujuan untuk meningkatkan produksi content web dan akses
untuk pengguna mobile (Low.2007:20).
Mobile Web Best Practices 1.0 (W3C 2006a) adalah spesifikasi standard
dan contoh praktek dari mobile web-based content (Low.2007:20). Berikut
adalah garis besar rekomendasi yang dikeluarkan oleh W3C (W3C 2006a).
Dibawah rekomendasi dari Default Delivery Context, content untuk mobile
web bisa saja melebihi rekomendasi ini jika content dirancang untuk diakses
oleh perangkat yang berspesifikasi tinggi (Low.2007:21).
10
Tabel 2.1 Rekomendasi standar untuk mobile web
Web Text XHTML 1.0 Basic Profile (W3C 2006a)
WML 1.0
Character encoding UTF-8
Format web pages External CSS Level 1(W3C 2006a)
Link external CSS with LINK not @import
Colours 256 colour, Web Safe palette (W3C 2006a)
Maximum total page
weight
20 kilobytes (W3C 2006a)
10 kilobytes is a ‘usable’ page weight (W3C 2000a
s.5.3.2.3)
Transport protocol HTTP/1.0 or HTTP/1.1 (W3C 2006a)
Images (photographic)
JPEG, non-progressive
Specify image size (both width and height) in
mobile web page markup (W3C 2006a)
Images (graphic)
GIF 89a, 256 colour web-safe palette, noninterlaced,
non-transparent, non-animated
Specify image size (both width and height) in
mobile web page markup (W3C 2006a)
Usable screen width Phones: 120 px (W3C 2006a) – 320 px
PDAs: 240 px – 640 px
Sumber M-learning standards report (Low, 2007:13)
2.3 Content Management System (CMS)
Content Management System (CMS) adalah sebuah aplikasi berbasis web
yang memiliki system sedemikian rupa hingga memberikan kemudahan kepada
para pengguna sekaligus juga pengelolanya (Rachdian, 2005:4).
11
Content Management System (CMS) memiliki serangkaian prosedur yang
digunakan untuk mengatur alur kerja. Prosedur-prosedur ini dapat bersifat manual
maupun berbasis compute. Prosedur-prosedur ini didesain untuk:
1. Memungkinkan sejumlah orang untuk berkontribusi dan memasukkan
data.
2. Mengontrol akses data, sesuai dengan perannya.
3. Memudahkan penyimpanan dan penerimaan data.
Pada sebuah CMS, content yang diatur bersifat industri spesifik. Sebagai
contoh, content multimedia akan berbeda dengan desain dokumen untuk pesawat
jet. Banyak terminologi yang mengaturnya. Beberapa contoh yang umum
digunakannya CMS antara lain Web Content Management, Digital Asset
Management, Digital Records Management, Electronic Content Management, dan
Mobile Content Management, Learning Management System.
2.3.1 Learning Management System (LMS)
Learning Management System adalah system manajemen pembelajaran
berbasis web yang memungkinkan pengajar untuk mengakses dan
mendistribusikan materi belajar. Sistem ini juga memungkinkan murid untuk
melakukan aktifitas belajar seperti mengakses konten dan materi yang dibuat oleh
pengajar (Niazi, 2008: 3).
12
Dengan learning management system, pengajar yang berperan sebagai
pengelola konten belajar dapat membuat, dan mempublikasikan materi belajar
kepada siswa-siswanya.
2.4 JAVA
Java ditemukan oleh James Gosling, Patrick Naughton, Chris Warth, Ed
Frank, dan Mike Sheridan dibawah Sun Microsystem, Inc pada 1991.
Membutuhkan 18 bulan untuk mengembangkan versi pertamanya. Bahasa
pemrograman ini awalnya diberi nama Oak tapi kemudian diganti Java pada 1995.
Diantara implementasi awal dari Oak pada 1992 dan berganti nama menjadi Java
pada 1995, banyak orang yang berkontribusi dalam desain dan evolusinya. Bill
Joy, Arthur van Hoff, Jonathan Payne, Frank Yellin, dan Tim Lindholm adalah
kontributor kunci dalam proses pendewasaan dari prototype awal (Naughton,
Patrick. 1999: 10).
Java sendiri memiliki beberapa edisi untuk berbagai keperluan pengembang
perangkat lunak yaitu J2SE, J2EE, J2ME, dan yang terakhir adalah JavaFX.
Sebuah profile memberikan library tambahan untuk suatu kelas tertentu pada
sebuah perangkat. profile-profile menyediakan user interface (UI) API,
persistence, messaging library, dan sebagainya.
2.5 Hibernate 3
Bauer dan King (2005:2) menjelaskan Hibernate adalah framework yang
memediasi interaksi aplikasi dengan database, dengan demikian developer dapat
13
berkonsentrasi pada komponen logika bisnis. Dengan hibernate pengembang tidak
perlu mengikuti semua aturan dan disain hibernate ketika membuat logika bisnis
dan kelas-kelas.
Hibernate tidak saja melakukan pemetaan kelas Java ke tabel database,
tapi juga menyediakan fasilitas untuk query dan data retrieval dan secara
signifikan mempersingkat waktu pengembangan dibandingkan dengan data
handling secara manual pada SQL dan JDBC. Tujuan Hibernate adalah untuk
membebas tugaskan pengembang dari tugas-tugas persisten data (Bauer. 2003:1).
2.6 Framework jMaki
jMaki adalah framework ringan untuk membuat aplikasi Web centric 2.0
menggunakan tata letak CSS, widget-widget model, penangan JavaScript, dan
proxy generik untuk berinteraksi dengan web eksternal RESTful web services.
jMaki mengabstraksi JavaScript dan CSS dengan menyediakan widget default,
widget JavaScript dan CSS yang dibuat mudah diakses sehingga bisa
dikustomisasi oleh perancang. jMaki berfokus pada aspek memberikan JavaScript
untuk memungkinkan klien untuk berkomunikasi dengan berbagai teknologi
server-termasuk PHP, Java (JSP / JSF), dan Phobos dalam teknologi-server cara
netral.
14
Gambar 2.1 Arsitektur jMaki
Berikut ini adalah modul klien dan server yang membentuk jMaki.
Client Side Komponen:
1. jMaki Layouts: - Layout jMaki memberikan standar berdasarkan titik awal
untuk membuat aplikasi web menggunakan HTML dan CSS.
2. jMaki Clien Runtime: - Klien jMaki Runtime adalah JavaScript yang
bertanggung jawab untuk bootstrap semua widget dan melewati parameter
yang disediakan oleh server-side runtime ke sisi widget. Parameter yang
unik untuk setiap widget, dan JavaScript runtime akan memastikan bahwa
setiap contoh widget mendapatkan parameter yang benar yang dikirimkan
dari server-side runtime. Ketika parameter tidak disediakan runtime
menggunakan parameter default yang kemudian dapat disesuaikan untuk
masing-masing widget.
15
3. jMaki Client Services: Layanan API yang mudah digunakan untuk
melakukan XMLHttpRequest dan mempublikasikan subscribe pada klien
disediakan untuk semua widget sebagai alat komunikasi. jMaki Glue
dibangun di atas publish/subscribe suatu peristiwa. Hal ini memungkinkan
Anda untuk menentukan perilaku dan time widget-widget bersama
menggunakan JavaScript ketika event tertentu diterbitkan dengan suatu
topik. Timer jMaki memungkinkan penangan event JavaScript untuk
dipanggil atau peristiwa yang akan diterbitkan pada interval yang
ditetapkan. The Injector jMaki adalah layanan klien yang memungkinkan
Anda untuk membawa halaman eksternal ke setiap elemen div yang
ditentukan. The transfer Injector script dan CSS dengan konten halaman
global dan memungkinkan widget seperti iframe dapat diambil tanpa
masalah.
4. jMaki Widget Model - Model widget jMaki menyediakan sebuah model
komponen untuk komponen JavaScript yang reusable. Struktur didasarkan
pada HTML, JavaScript dan CSS. Anda dapat menggunakan struktur ini
untuk membuat widget sendiri atau widget wrapper dari toolkit yang
diberikan. jMaki menyediakan default widget wrapper dan server tie untuk
widget yang sering digunakan seperti Dojo, Yahoo UI, Prototipe, dan
beberapa widget asli milik jMaki. jMaki juga mendefinisikan format
widget.json yang merupakan cara umum untuk menggambarkan sehingga
mereka dapat diakses oleh perangkat.
16
Komponen server:
1. jMaki Server Runtime - Server jMaki Runtime bertanggung jawab untuk
mengikat JavaScript Client jMaki Runtime ke runtime server-side seperti
Java, PHP, atau runtime Phobos berbasis JavaScript. Runtime server
melakukan tracking dan merender semua script dan CSS berdasarkan jenis
library yang digunakan untuk memastikan bahwa script duplikat dan link
CSS tidak diduplikasi. Runtime server juga akan memastikan API kunci
(seperti GoogleMap dan Yahoo button) akan diterapkan bila perlu
didasarkan pada seperangkat konfigurasi kunci. Renders runtime server
membuat template HTML dan JavaScript serializes data sehingga setiap
widget akan menyediakan data yang tepat.
2. XmlHttpProxy - Modul XmlHttpProxy menyediakan sarana bagi widget
untuk mengakses JSON atau XML RESTful XML-based di luar dari
domain aplikasi web. Service tersebut termasuk RSS feed, layanan Yahoo
seperti geocoding, pencarian gambar Flickr, dan masih banyak lagi yang
akan datang. XmlHttpProxy memungkinkan widget untuk mengakses
layanan dengan cara yang seragam dengan menyediakan transformasi
XSL-to-JSON yang dapat dengan mudah disesuaikan.
2.7 Database MySql 5.1.30
MySQL merupakan Open Source SQL database yang paling popular, MYSQL
dibuat oleh MySQL AB. MySQL AB adalah sebuah perusahaan komersil yang
17
menyediakan servis seputar database MySQL (MySQL Reference Manual.
MySQL AB , 2001, pp.2).
Gambar 2.2 Arsitektur MySQL server
MySQL merupakan sebuah relational database management system, yang
menyimpan data pada tabel yang terpisah, hal ini dapat meningkatkan kecepatan
dan fleksibilitas. Tabel-tabel tersebut kemudian dihubungkan melalui relasi-relasi
tertentu sehingga memungkinkan untuk mengkombinasikan data dari berbagai
tabel sesuai dengan permintaan, melalui SQL yang telah menjadi bahasa standar
yang umum untuk mengakses database.
2.8 Sekilas tentang NetBeans 6.7.1
NetBeans IDE adalah sebuah integrated development environment (IDE)
untuk menulis, meng-compile, testing, dan debugging aplikasi untuk platform
Java maupun bahasa pemrograman lain. Netbeans IDE memiliki text editor,
18
perangkat disain visual, source code management, integrasi dengan database,
integrasi dengan server, dan lain-lain.
Gambar 2.3 Splash Screen NetBeans 6.7.1
2.9 Unit Testing
Unit testing berfokus pada verifikasi di unit terkecil dari disain perangkat
lunak. Menggunakan disain component-level sebagai penunjuk, control path yang
penting akan dites untuk mendapatkan error di dalam batas modul. Kompleksitas
dari pengujian tergantung pada batas yang ada untuk unit testing. Unit test
berorientasi pada white-box testing, dan langkahnya dapat dijalankan secara
parallel pada komponen yang berlainan. (Pressman, 2002:485).
19
Ketika pemrograman object oriented digunakan, maka konsep dari unit
berubah. Setiap class dan objek memiliki data dan operasi (methods) yang
memanipulasi data-data ini. Unit testing tidak lagi dilakukan pada modul-modul
terpisah, tetapi dilakukan pada class atau objek. Hal ini dikarenakan sebuah kelas
bisa memiliki sejumlah operasi berbeda dan beberapa operasi tersebut dapat
berada pada kelas-kelas yang berbeda, artinya unit testing berubah secara dramatis
(Pressman, 2002:664).
Kita tidak dapat lagi melakukan test pada satu operasi secara terpisah
melainkan dilakukan sebagai bagian dari kelas. Berikut adalah ilustrasinya,
sebuah superclass yang memiliki operasi X yang diturunkan pada sejumlah
subclasses. Maka setiap subclasses akan menurunkan operasi X . Dikarenakan
operasi X tersebut digunakan oleh beberapa kelas, maka Unit test pada operasi X
harus dilakukan pada subclasses.
2.10 System Testing
System testing adalah serangkaian test yang bertujuan untuk menguji
system secara keseluruhan. Meskipun setiap test memiliki tujuan yang
berbeda, namun seluruh tahapan dilakukan dengan terintegrasi (Pressman,
2002:525). Berikut ini adalah serangkaian test yang termasuk dalam system
testing.
2.10.1 Recovery Testing
Sistem yang berbasis komputer harus dapat pulih dari kesalahan dan
melanjutkan pemrosesan ketika terjadi keadaan yang tidak diinginkan. Dalam
20
beberapa kasus, sistem harus fault tolerant, yaitu pengolahan tidak boleh
menyebabkan kesalahan fungsi sistem secara keseluruhan. Dalam kasus lain,
kegagalan system harus dikoreksi dalam jangka waktu tertentu atau kerugian
secara ekonomi yang parah akan terjadi (Pressman, 2002:525).
Recovery Testing adalah tes sistem yang memaksa perangkat lunak untuk
gagal dalam berbagai cara dan memverifikasi bahwa pemulihan dilakukan
dengan benar. Jika pemulihan otomatis (dilakukan oleh sistem itu sendiri),
reinitialization, mekanisme checkpointing, data recovery, dan restart
dievaluasi. Jika pemulihan membutuhkan intervensi manusia, berarti waktu
untuk perbaikan dievaluasi.
2.10.2 Security Testing
Security testing melakukan verifikasi bahwa mekanisme keamanan
yang ada pada system akan mampu melindungi dari serangan. Sistem
keamanan harus, di uji kekebalannya dari serangan langsung. Selama
pengujian keamanan, tester memainkan peran sebagai individu yang
melakukan serangan terhadap sistem (Pressman, 2002:525).
Tester mungkin mencoba untuk mendapatkan password dengan
perangkat lunak khusus yang dirancang untuk membuat kerusakan pada
pertahanan yang telah dibangun, sengaja menyebabkan kesalahan pada sistem,
dapat menelusuri melalui data tidak aman. Dengan cukup waktu dan sumber
daya, pengujian keamanan yang baik pada akhirnya akan menembus sistem.
Peran perancang sistem untuk membuat penetrasi biayanya lebih dari nilai
informasi yang akan diperoleh (Pressman, 2002:526).
21
2.10.3 Stress Testing
Tujuan dari stress testing adalah untuk mengevaluasi dan menentukan
perilaku perangkat lunak ketika beban yang ditawarkan lebih dari kapasitas
yang dirancang. Sistem sengaja dibebankan hingga melampaui batas yang
ditentukan. Hal ini dilakukan untuk memastikan bahwa sistem dapat tetap
berfungsi pada kondisi terburuk (Naik, 2008:243).
Stress testing menjalankan pengujian sistem dengan cara yang menuntut
sumber daya frekuensi, atau volume dalam kuantitas lebih. Misalnya:
1. Tes khusus dapat dirancang dengan menghasilkan sepuluh permintaan per
detik, ketika satu atau dua adalah tingkat rata-rata.
2. melakukan masukan data yang dapat ditingkatkan dengan urutan besarnya
untuk melihat bagaimana fungsi masukan akan menjawab.
3. Uji kasus yang membutuhkan memori maksimum atau sumber daya
lainnya dijalankan,
4. Uji kasus yang dapat menyebabkan sistem operasi terbebani.
5. Uji kasus yang dapat menyebabkan pengambilan data yang berlebihan.
2.10.4 Performance Testing
Performance Testing sering digabungkan dengan stress testing dan
biasanya memerlukan instrumen perangkat keras atau perangkat lunak.
Artinya, diperlukan instrumen untuk mengukur pemanfaatan sumber daya.
Instrumen eksternal dapat memantau interval eksekusi, peristiwa log
yang terjadi, dan memantau mesin secara teratur. Dengan instrumenting
22
sistem, tester dapat mengungkap situasi yang menyebabkan degradasi dan
kegagalan system (Pressman, 2002:527).
2.11 Disain Antar Muka
Antar muka pada aplikasi berbasis web adalah kesan pertama. Terlepas dari
isi, kepuasan pelayanan, dan keseluruhan keuntungan dari aplikasi tersebut, disain
yang kurang baik akan membuat User meninggalkan web tersebut (Pressman,
2005:813). Pressman menyebutkan ada beberapa faktor yang harus diperhatikan
dalam mendisain website:
a. Menu navigasi harus konsisten dan harus tersedia di setiap halaman yang
bisa diakses oleh User
b.Menu navigasi harus terlihat jelas oleh User. User tidak perlu mencari link
untuk menuju ke halaman yang mereka kehendaki.
c. Keindahan hendaknya tidak menggantikan fungsionalitas. Contoh, tombol
yang sederhana lebih baik daripada tombol dengan gambar atau icon yang
maksudnya tidak jelas.
2.12 Rapid Applications Development (RAD)
Model RAD adalah sebuah metode pengembangan sistem yang menggunakan
perencanaan minimal dan mengutamakan kecepatan. Tahap perencanaan dalam
RAD berada pada fase panulisan kode software itu sendiri. Pengurangan porsi
perencanaan secara umum membuat penulisan kode program lebih cepat, dan
mudah beradaptasi pada perubahan (Pressman, 2005:82).
23
Model pengembangan perangkat lunak yang digunakan pada Aplikasi m-
Learning ini adalah model RAD. Penulis memilih model RAD yang merupakan
sebuah model proses perkembangan dari sekuensial linier yang menekankan
siklus perkembangan yang sangat pendek, proses RAD memungkinkan tim
pengembangan menciptakan “sistem fungsional yang utuh” dalam periode waktu
yang sangat pendek (kira-kira 60 sampai 90 hari). RAD cocok diterapkan pada
aplikasi m-learning ini karena dimana perkembangan cepat dicapai dengan
menggunakan pendekatan kontruksi berbasis komponen.
RAD mengasumsikan pemakaian teknik generasi keempat. Selain
menciptakan perangkat lunak dengan menggunakan bahasa pemrograman
generasi ketiga yang konvensional. Pada semua kasus, alat-alat bantu otomatis
dipakai untuk memfasilitasi konstruksi perangkat lunak. Melakukan penggunaan
kembali komponen yang ada (jika mungkin), artinya membuat kembali
penggunaan komponen jika dibutuhkan, kemudian testing and turnover. Karena
proses RAD menekankan pada pemakaian kembali, banyak komponen program
telah diuji. Hal ini mengurangi keseluruhan waktu pengujian, tetapi komponen
baru harus diuji dan semua interface harus dilatih secara penuh.
Hasil pengembangan bisa lebih cepat dibandingkan metode lainnya. RAD
memerlukan biaya yang lebih sedikit, mementingkan dari segi bisnis dan teknik,
berkonsentrasi pada sudut pandang pengguna, RAD menyediakan kemungkinan
perubahan secara cepat sesuai permintaan pengguna, menghasilkan jarak
kesesuaian yang kecil antara kebutuhan user dan spesifikasi sistem, waktu, biaya,
dan usaha yang akan dikelurkan pun minimal.
24
2.13 Studi Sejenis
Dalam hal ini, penulis membaca dan memahami literatur ilmiah yang sejenis
dengan penulis. Berikut adalah daftar studi literatur yang penulis
Judul: Media Pembelajaran Matematika Online Berbasis Mobile Learning
Melalui Wap (Wireless Application Protocol) Untuk Sekolah Menengah Atas.
Nama penulis: Ninda Argafani
Tahun terbit: 2008
Abstrak:
Waktu yang tersedia bagi guru dalam mengajar di dalam kelas sangat kurang
sehingga dalam mengajar guru hanya dikejar target mengajar atau ketuntasan
materi, sedangkan ketuntasan atau kepemahaman siswa dalam memahami konsep
kurang diperhatikan.
Ditambah dengan kurangnya siswa dalam berlatih mengerjakan soal-soal
merupakan salah satu penyebab mengapa nilai matematika selalu lebih rendah
dari pada mata pelajaran yang lain. Selain itu, guru jarang memberikan soal-soal
latihan dan membahasnya dikarenakan keterbatasan waktu. Untuk itu guru perlu
mengembangkan berbagai metode pengajaran beserta perangkat-perangkat yang
diperlukan untuk menunjang proses kegiatan belajar mengajar agar tidak hanya
target mengajar saja yang terpenuhi tetapi pemahaman siswa dalam mata
pelajaran juga terpenuhi.
Mobile learning merupakan salah satu media pembelajaran yang sekarang sedang
banyak dikembangkan. Salah satu bentuk dari mobile learning adalah media
25
alternatif pembelajaran online WAPsite, yang dapat diakses melalui telepon
seluler (handphone) yang memiliki fasilitas WAP. Dengan adanya fasilitas ini kita
dapat mengakses berbagai macam informasi melalui telepon seluler. Dengan
memanfaatkan hasil olah tehnologi ini, dapat dikembangkan sebuah media
pembelajaran matematika berbasis WAPsite. WAPsite adalah suatu web yang
dikembangkan dan disesuaikan untuk perangkat mobile seperti telepon seluler.
Tujuan penulisan skripsi ini adalah untuk mengetahui bagaimana membuat media
pembelajaran matematika online melalui WAP (Wireless Application Protocol)
untuk Sekolah Menengah Atas.
Untuk mengetahui bagaimana membuat media pembelajaran online melalui WAP
pada Sekolah Menengah Atas, maka metode penulisan skripsi ini dengan
menggunakan metode penulisan diskriptif, yaitu dengan menjabarkan langkah-
langkah pembuatan dari media pembelajaran online melalui WAP serta
menjelaskan software pendukung yang digunakan dalam proses pembuatan.
Kesimpulan dalam penulisan skripsi ini adalah bahwa pembuatan media
pembelajaran matematika melalui WAP menggunakan bahasa pemorgraman
WML dan PHP serta MySQL sebagai penyimpanan data dan Photoshop 7.0
sebagai pengolah gambar. Selain itu pembuatan media pembelajaran ini melalui
lima tahapan, yaitu Merancang desain alur aplikasi, merancang database dan
tabel-tabel yang diperlukan dalam sistem, membuat program koneksi, membuat
tampilan dari setiap halaman, tahap terakhir adalah Output atau hasil berupa
media belajar matematika online melalui WAP.
Kata kunci : media pembelajaran, matematika, WAP
26
Kelebihan:
1. Aplikasi ini memiliki fasilitas raport nilai
2. Aplikasi ini memiliki fasilitas forum
Kekurangan :
1. Aplikasi ini hanya untuk pelajaran matematika
2. Aplikasi ini dikembangkan dengan PHP.
3. Materi terbatas, tidak ada fasilitas untuk mengedit materi.
Judul: Perancangan Aplikasi M-Learning Berbasis Java
Nama penulis: Bambang Riyanto, Muh. Tamimuddin, Sri Widayati
Tahun terbit: 2006
Abstrak:
Teknologi telekomunikasi dan teknologi internet menjadi gelombang
kecenderungan baru di seluruh dunia. Perkembangan ini memungkinkan
terobosan baru dalam belajar secara mobile menggunakan perangkat IT genggam
atau disebut mobile learning (m-learning). M-learning memiliki beberapa
kelebihan di antaranya adalah kemampuan belajar “kapan-pun di mana-pun”.
Namun, di sisi lain, perangkat pembelajaran m-learning memiliki keterbatasan
sumber daya dan keragaman platform sehingga diperlukan rancangan yang
mampu menjamin kompatibilitas dan interoperabilitas.
Kata kunci: m-learning,e-learning, OOP, Java, XML, XML-RPC
Kelebihan :
27
1. Aplikasi ini memiliki fasilitas forum
2. Content pembelajaran dapat diakses dengan offline maupun online.
Kekurangan :
1. Aplikasi ini harus diunduh ke handphone pengguna untuk mengaksesnya.
2. Transmisi data dari server ke client yang menggunakan XML-RPC
membuat beban pada server bertambah karena server harus melakukan
parsing XML.
3. Akses database belum menggunakan framework yang berbasis Object
relational Mapping.
Judul: Pembelajaran Dalam Konteks Mobile Learning.
Nama penulis: Essa Basaeed , Jawad Berri dan Mohamed Jamal Zemerly
Tahun terbit: 2007
Abstrak:
Mobile learning sedang mendapatkan ketertarikan dalam beberapa tahun
belakangan ini karena dianggap sesuai dan keluasannya dalam menyampaikan
materi belajar. Kesesuaian yang dimilikinya dikarenakan mobile device digunakan
tidak hanya untuk komunikasi tetapi juga untuk mengakses internet, berbelanja,
bertukar informasi dan mengatur kegiatan sehari-hari.
28
Tidak berbatas karena memperluas e-Learning dan menghilangkan batasan-
batasan serta menawarkan kebebasan dari ruang dan waktu dalam belajar.
Perangkat bergerak memiliki potensi untuk digunakan sebagai alat yang tepat
untuk memberikan suasana belajar yang berbeda, bagaimanapun keadaan ini
mendapatkan tantangan baru berkaitan dengan kemampuan perangkat bergerak
untuk mengatasi masalah yang berkaitan dengan materi belajar berbasis
multimedia.
Fokus kami adalah untuk mendiskusikan isu-isu yang terkait dengan disain dan
implementasi sistem mobile learning. Proposal ini menggunakan teknologi
berbasis web untuk memecahkan tantangan yang ada pada lingkungan berbasis
mobile, dan membutanya menjadi solusi yang sangat cross-platform.
Kata kunci: Context-awareness, pendidikan berbasis teknologi, m-Learning,
pembelajaran dengan perangkat bergerak.
Kelebihan :
1. Aplikasi ini memiliki fasilitas forum.
Kekurangan :
1. Hanya menggunakan fasilitas forum untuk bertukar informasi.
2. Aplikasi ini dikembangkan dengan PHP.
29
Judul: Disain Dan Pengembangan Device-Independent System Untuk Mobile
Learning.
Nama penulis: Razieh Niazi dan Qusay H. Mahmoud
Tahun terbit: 2008
Abstrak:
Dengan penetrasi tinggi dari telepon genggam pada masyarakat terutama kaum
muda, dan teknologi tinggi yang dimiliki telepon genggam itu sendiri dan
ketersediaan jaringan nirkabel, pengajar merasa optimis berkenaan dengan potensi
dari telepon genggam untuk alat pendidikan.
Beberapa penelitian berkaitan dengan efek pendidikan dengan mobile learning di
pendidikan tinggi telah dipublikasikan. Tetapi perhatian pada disain dan
pengembangan masih sedikit. Diperlukan inovasi, reliable dan perangkat lunak
yang dapat digunakan untuk mobile learning.
Hasil yang ditunjukkan di sini berfokus pada disain dan pengembangan aplikasi
dan sistem baru untuk pengajar maupun pembelajar untuk menerapkan mobile
learning. Pada paper ini, kami mempertunjukkan sebuah sistem mobile learning
untuk pengajar maupun pembelajar.
Dengan menerapkan sistem ini, pengajar akan dapat membuat quiz yang
kompatibel untuk berbagai platform.
Kata kunci: Mobile Learning, M-Learning Java ME, Blackberry Devices, Quiz
Generator, Device-Independent.
30
Kelebihan :
1. Aplikasi ini memiliki fasilitas quiz generator dan penilaian.
Kekurangan :
1. Aplikasi ini harus diunduh ke handphone pengguna untuk mengaksesnya.
2. Transmisi data dari server ke client yang menggunakan XML-RPC
membuat beban pada server bertambah karena server harus melakukan
parsing XML.
Judul: Mobile Learning Dengan Berbasis Jaringan Ad-Hoc Messaging.
Nama penulis: Stefan Stieglitz, Christoph Fuchß, dan Christoph Lattemann
Tahun terbit: 2008
Abstrak:
Permintaan untuk teknik e-learning telah berganti. Aspek semisal interaksi antar
komunitas, fleksibilitas, dan mobilitas dalam berkomunikasi menjadi penting.
Untuk memenuhinya platform e-learning harus mampu mengakomodir mobile
learning.
Kebanyakan mencoba mengadopsi e-learning statis ke dalam perangkat mobile.
Tetapi, seringkali secara teknis tidak memungkinkan untuk sebagian perangkat
dapat berhubungan dengan server.
Oleh sebab itu kami memperkenalkan aplikasi mobile learning yang beroperasi
dalam arsitektur jaringan ad-hoc. Konsep dari ad hoc messaging network
(AMNET) digunakan sebagai dasar arsitektur pada sistem.
31
Kata kunci: Mobile learning, ad hoc learning, community, e-learning platform,
AMNET, ad hoc messaging network, pervasive learning
Kelebihan :
1. Dengan menggunakan jaringan tertutup maka aplikasi ini dapat memantau
daftar pengguna secara detil.
Kekurangan :
1. Aplikasi ini beroperasi pada jaringan ad-hoc sehingga penyebarannya
terbatas pada wilayah yang terjangkau oleh jaringan saja.
32
BAB III
METODOLOGI PENELITIAN
3.1 Metode Pengumpulan Data
Dalam rangka penelitian ini, penulis membutuhkan data atau informasi
dan referensi yang relatif lengkap untuk mendukung materi uraian dan
pembahasan. Metode pengumpulan data dan referensi yang dibutuhkan adalah
sebagai berikut.
3.1.1 Wawancara
Wawancara (interview) adalah komunikasi dua arah untuk
mendapatkan data dari responden (Jogiyanto, 2008:111).
Penulis menggunakan teknik wawancara langsung, yaitu dengan cara
mengajukan pertanyaan-pertanyaan langsung kepada Kepala Pusat Data
Teknik informatika Fakultas Sains dan Teknologi (PUSDATIN FST) dalam
hal kebutuhan akan aplikasi yang penulis buat. Hasil wawancara dapat
dilihat pada Lampiran A.
3.1.2 Studi Pustaka
a. Membaca dan mempelajari buku-buku atau dokumen-dokumen.
Dokumen atau buku yang termasuk didalamnya yaitu buku-buku,
artikel, dan jurnal yang berhubungan dengan dan m-learning. Dokumen
- dokumen tersebut bisa bersifat hardcopy ataupu softcopy yang
bersumber dari internet. Dapat dilihat di daftar pustaka.
33
b. Dokumen- dokumen yang telah dikumpulkan kemudian dipilih dan
dihimpun berdasarkan tujuan dan fokus penelitian. Dapat dilihat di
daftar pustaka.
c. Dokumen-dokumen yang telah dipilih dan himpun kemudian diurutkan
sesuai dengan urutan kronologis, kekuatan, dan kesesuaian. Dapat
dilihat di daftar pustaka.
d. Dilakukan analisis untuk mendapatkan suatu pemahaman mengenai
konsep perancangan web aplikasi untuk mengakomodir m-learning.
Dapat dilihat di daftar pustaka.
3.1.3 Studi Sejenis
Dalam hal ini, penulis membaca dan memahami literatur ilmiah yang
sejenis dengan penulis. Hasil studi literatur sejenis dapat dibaca pada subbab
2.9.
3.2 Bahan dan Alat
3.2.1 Perangkat Keras
Perangkat keras adalah seperangkat alat atau komponen yang
disarankan untuk pengembangan aplikasi adalah sebagai berikut:
1. CPU (Central Processing Unit) Intel Pentium 4 2.0 GHz
2. Harddisk 20 GB
3. Keyboard Standard USA
4. Mouse Standard
5. Monitor SVGA
34
3.2.2 Perangkat Lunak
Perangkat lunak merupakan bagian dari sistem pengolahan data
yang digunakan untuk mengaktifkan fungsi dari perangkat keras komputer.
Perangkat lunak minimal adalah sebagai berikut :
1. Sistem Operasi
Sistem operasi yang disarankan minimal Windows XP Service Pack 2.
2. Program Aplikasi
Merupakan perangkat lunak yang akan digunakan dalam
pembuatan program diantaranya adalah server Apache Tomcat 5.5.17,
J2SE 1.5.0_09, NetBeans IDE 6.0.
3.3 Metode Pengembangan Sistem
Metode pengembangan sistem yang penulis gunakan dalam penelitian
skripsi ini adalah dengan model RAD (Rapid Application Development). RAD
adalah sebuah model proses pengembangan perangkat lunak sekuensial linear
yang menekankan siklus pengembangan cepat (Pressman, 2005:82).
Model RAD ini merupakan adaptasi "kecepatan tinggi" dari model
sekuensial linear, dimana perkembangan dapat cepat dicapai dengan
menggunakan model pendekatan konstruksi berbasis komponen. Jika kebutuhan
dipahami dengan baik, proses RAD memungkinkan tim pengembang menciptakan
"sistem fungsional yang utuh" dalam periode waktu periode yang sangat pendek
(kira-kira 60-90 hari). Model RAD digunakan dengan tujuan mempersingkat
35
waktu pengerjaan aplikasi serta proses yang dihasilkan, didapatkan secara cepat
dan tepat.
Alasan penulis memilih metodologi RAD sebagai acuan dalam pembuatan
sistem adalah karena sistem yang penulis buat merupakan sistem yang sederhana
dan penulis hanya menggunakan komponen-komponen yang sudah ada.
Ilustrasi model RAD seperti gambar berikut:
Gambar 3.1. The RAD Model (Pressman, 2005:82)
Communicat ion
Planning
Modelingbusiness modeling dat a modeling process modeling
Construct ioncomponent reuse aut omat ic code generat ion t est ing
Deployment
60 - 90 days
Team # 1
Modelingbusiness modeling dat a modeling process modeling
Construct ioncomponent reuse aut omat ic code generat ion t est ing
Mode lingbusiness modeling data modeling process modeling
Const ruct ioncomponent reuse automatic code generation testing
Team # 2
Team # n
int egrat ion delivery feedback
36
Pada gambar di atas terlihat bahwa model RAD dikembangkan dengan tim-
tim yang jumlahnya disesuaikan dengan kebutuhan. Pada penelitian ini penulis
melakukan pengembangan aplikasi dengan 1 tim. Hal ini dikarenakan dalam
pembuatan aplikasi dilakukan secara individu yaitu penulis sendiri.
Adapun tahapan-tahapan pengembangan sistem dengan metode RAD adalah
sebagai berikut:
a. Communication
Pada tahap ini, penulis melakukan analisis untuk mengetahui
permasalahan yang terjadi, sehingga dapat diketahui informasi yang harus
diakomodasi oleh aplikasi yang akan dibuat. Secara rinci yang penulis lakukan
pada tahap analisis kebutuhan adalah :
1. Analisis Kebutuhan User (dapat dibaca pada sub bab 4.1.1)
2. Alat dan Bahan (dapat dibaca pada sub bab 4.1.2)
b. Planning (dapat dibaca pada sub bab 4.2)
Pada tahap ini, penulis melakukan perencanaan yaitu dengan membuat
timeline untuk memudahkan dan mengarahkan penulis dalam melakukan
pembuatan sistem.
37
c. Modelling
Pada tahap ini, penulis melakukan pemodelan informasi, interface yang
akan dipergunakan, dan data yang diperlukan selama penggunaan aplikasi. Secara
rinci, yang penulis lakukan pada tahap ini adalah sebagai berikut
1. Membuat Use Case Diagram (dapat dibaca pada sub bab 4.3.1)
2. Membuat Entity Relational Diagram (dapat dibaca pada sub bab 4.3.2)
3. Membuat Kamus data (dapat dibaca pada sub bab 4.3.3)
4. Merancang Antar Muka aplikasi (dapat dibaca pada sub bab 4.3.4)
d. Construction
Diketahui juga sebagai tahap pembuatan atau pembangunan. Pada
tahap ini dilakukan :
a. Implementasi antar muka (dapat dibaca pada sub bab 4.4.1)
b. Unit Testing (dapat dibaca pada sub bab 4.4.2)
Unit Testing adalah proses eksekusi program yang bertujuan untuk
menemukan error. Unit Testing yang dilakukan pada tugas akhir ini
dengan menggunakan JUnit.
c. System testing (dapat dibaca pada sub bab 4.4.3)
Pada tahap System Testing ini penulis melakukan serangkaian test pada
system secara keseluruhan, tes-tes yang penulis lakukan adalah sebagai
berikut:
a. Recovery Testing
38
Pada tahap ini Penulis membuat beberapa keadaan yang memaksa
aplikasi gagal beroperasi. Hal ini dilakukan untuk memastikan proses
pemulihan berjalan dengan baik.
b. Security Testing
Penulis melakukan Security Testing menggunakan HP Scrawler
1.0. Software ini melakukan crawl pada aplikasi yang penulis kembangkan
dan secara simultan melakukan analisa untuk kemungkinan serangan
SQLInjection pada setiap halaman.
c. Stress Testing
Pada tahap ini Penulis menggunakan WAPT 6.0. Penulis
membebankan aplikasi menggunakan 500 looping pada satu waktu yang
sama untuk menguji kemampuan system ketika berada mendapat beban
berat.
d. Performance Testing
Pada tahap ini Penulis menggunakan software WAPT. Penulis
melakukan testing yang sama dengan tahap Stress Testing, tetapi kali ini
penulis menggunakan 20 looping pada 20 User untuk melihat performa
aplikasi dalam keadaan normal.
e. Deployment (dapat dibaca pada sub bab 4.5)
Disebut juga sebagai tahapan penerapan aplikasi yang telah dibuat.
39
Gambar 3.2. Tahapan dan Rincian Pengembangan Sistem
Wawancara, Studi Pustaka, Studi Literatur Sejenis
Rapid Application Development
Communication
Analisis Kebutuhan Sistem, Analisis Perangkat Lunak
Planning
Membuat Timeline
Pengumpulan Data
Modelling
Use Case Diagram, Entity Relational Diagram, Kamus Data
Construction
Pembuatan Aplikasi
Deployment
Penerapan Aplikasi, Feedback User
40
BAB IV
HASIL DAN PEMBAHASAN
4.1. Communication
4.1.1. Analisis Kebutuhan User
Berdasarkan hasil wawancara yang penulis lakukan, penulis
mendapatkan informasi mengenai bentuk mobile learning, menu-menu,
maupun format file-file yang diperlukan untuk pengembangan aplikasi
mobile learning. Adapun hasil wawancara secara lengkap ada pada lampiran
A.
4.1.2. Alat dan Bahan
1. Perangkat Keras
Perangkat keras adalah seperangkat alat atau komponen
yang akan digunakan untuk membentuk suatu sistem komputer:
a. CPU (Central Processing Unit)
CPU merupakan pusat pengolahan dan juga pusat
pengontrolan dari sebuah sistem komputer yang saling
melaksanakan kegiatan. Spesifikasi yang penulis gunakan adalah
sebagai berikut:
1) Processor intel core i3 2.13 Ghz
2) Harddisk 320 GB
3) DDR RAM 1,7 GB
4) VGA on board Intel Graphics media accelerator
41
b. Keyboard
Keyboard adalah alat input yang biasanya didampingi dengan
alat tampilan (display) di layar monitor yang menampilkan apa
yang ditekan di keyboard.
c. Mouse
Mouse adalah alat input komputer yang digunakan oleh
berbagai program aplikasi GUI (Graphical User Interface)
dengan petunjuk posisi yang ditampilkan melalui monitor.
2. Perangkat Lunak
Perangkat lunak merupakan bagian dari sistem
pengolahan data yang digunakan untuk mengaktifkan fungsi
dari perangkat keras komputer. Perangkat lunak yang penulis
gunakan adalah sebagai berikut:
a. Sistem Operasi
Sistem operasi yang penulis sarankan adalah Microsoft
Windows XP SP2.
b. Program aplikasi
Merupakan perangkat lunak yang akan digunakan dalam
pembuatan program adalah server Apache Tomcat 5.5.17, J2SE
1.5, NetBeans IDE 6.7.1, MySql 5.
4.2. Planning
Dalam hal ini, penulis membangun aplikasi mobile learning secara
individu. Adapun waktu yang diperlukan dalam penelitian pembuatan
42
aplikasi ini adalah selama 9 Minggu. Berikut ini adalah timeline yang
penulis rancanakan selama membangun aplikasi mobile learning:
Tabel 4.1. Planning Pembuatan Aplikasi
Minggu
ke-1
Minggu
ke-2
Minggu
ke-3
Minggu
ke-4
Minggu
ke-5
Minggu
ke-6
Minggu
ke-7
Minggu
ke-8
Minggu
ke-9
Communication
Planning
Modelling
Construction
Deployment
4.3. Modelling
4.3.1. Use Case Diagram
Gambar 4.1 Use Case Diagram Autentikasi User
Berikut ini adalah use case naratif dari use cese diagram di atas yang
menjelaskan urutan kegiatan yang dilakukan sistem dan user
Tutor
Autentikasi User
Login
Logout
Administrator
43
1. Use Case Autentikasi User
Tabel 4.2 Use Case Autentikasi User
Usecase Name Autentikasi User
Actor (s) Administrator, tutor
Brief Description Usecase ini mendeskripsikan event dari administrator
dan tutor untuk login dan logout ke dalam sistem.
Precondition User haruslah sudah terdaftar sebagai pengguna sistem.
User haruslah seorang yang terdaftar sebagai
administrator atau tutor.
Trigger Use case ini diinisiasi pada saat user membuka aplikasi
mobile learning.
Basic Flow 1. User memulai aplikasi mobile learning
2. User mengklik tombol [login]
Post condition Aplikasi klien mengirimkan user dan password yang
dimasukan oleh user ke server, dan mengecek apakah
username dan password cocok. Jika cocok maka
aplikasi akan menampilkan menu utama, jika tidak
cocok maka aplikasi akan menampilkan login form
kembali.
44
2. Use Case Manajemen User
Gambar 4.2 Use Case Diagram Manajemen User
Berikut ini adalah use case naratif dari use cese diagram di atas yang
menjelaskan urutan kegiatan yang dilakukan sistem dan user.
Tabel 4.3 Use Case Manajemen User
Usecase Name Manajemen User
Actor (s) Administrator
Brief Description Usecase ini mendeskripsikan event dari administrator
yaitu menambah data user.
Precondition User haruslah sudah terdaftar sebagai pengguna sistem.
Manajemen User Administrator
Create User
View User
Manage own
account
Delete User
Update User
Tutor
Login
Logout
45
User haruslah seorang yang terdaftar sebagai
administrator.
Trigger Use case ini diinisiasi pada saat administrator memilih
[menu add a user] pada user management.
Basic Flow 1. Administrator membuka list dengan memilih menu
[user management]
2. Administrator memilih menu [input user]
3. Administrator memasukan data User
4. Administrator mengklik tombol [save]
5. Administrator mengklik tombol [keluar]
Alternate flow 2a. Administrator memilih salah satu user kemudian
memilih menu [edit], maka aplikasi akan menampilkan
data user tersebut ke dalam form dan kembali ke
langkah 3.
2b. Administrator memilih salah satu user kemudian
memilih menu [hapus], maka aplikasi akan menghapus
data user yang dipilih dan menampilkan kembali daftar
user
Post condition Aplikasi menyimpan data User yang telah dimasukkan
ke dalam database, dan aplikasi menampilkan kembali
daftar user.
46
3. Use Case Materi
Gambar 4.3 Use Case Diagram Manajemen Materi
Tabel 4.4 Use Case Materi
Usecase Name Materi
Actor (s) Administrator, Tutor
Brief Description Usecase ini mendeskripsikan event dari administrator
yaitu menambah,merubah dan menghapus Materi.
Precondition User haruslah sudah terdaftar sebagai tutor atau
administrator.
Trigger Use case ini diinisiasi pada saat administrator memilih
menu [materi].
Basic Flow 1. User membuka list dengan memilih menu [materi]
2. User memilih materi dari daftar
3. User memasukan data materi
4. User mengklik tombol [save]
Materi
Create Materi
View Materi
Upadate Materi
Delete Materi
Administrator
Tutor
Student
47
Alternate flow 2a. User memilih salah satu materi kemudian mengedit
data materi pada form, kemudian User mengklik
tombol [save] untuk menyimpan hasil masukkan.
2b. User memilih salah satu course kemudian memilih
menu [delete], maka aplikasi akan menghapus materi
yang dipilih.
Post condition Aplikasi menyimpan perubahan materi ke dalam
database, dan aplikasi menampilkan kembali daftar
course.
4. Use Case Course
Gambar 4.4 Use Case Diagram Manajemen Course
Tabel 4.5 Use Case Autentikasi User
Usecase Name Course
Actor (s) Administrator
Course
Create Course
View Course
Upadate Course
Delete Course
Administrator
Tutor
Student
48
Brief Description Usecase ini mendeskripsikan event dari administrator
yaitu menambah,merubah dan menghapus Course.
Precondition User haruslah sudah terdaftar sebagai pengguna sistem.
User haruslah seorang yang terdaftar sebagai
administrator.
Trigger Use case ini diinisiasi pada saat administrator memilih
menu [managemen course].
Basic Flow 1. Administrator membuka list dengan memilih menu
[course]
2. Administrator memasukan data course
3. Administrator mengklik tombol [simpan]
Alternate flow 2a. Administrator memilih salah satu course kemudian
mengedit data course pada form, kemudian user
mengklik tombol [save].
2b. Administrator memilih salah satu course kemudian
mengklik tombol [hapus], maka aplikasi akan
menghapus course yang dipilih.
Post condition Aplikasi menyimpan perubahan course ke dalam
database.
49
5. Use Case Manajemen File
Gambar 4.5 Use Case Diagram Manajemen File
Tabel 4.6 Use Case Manajemen File
Usecase Name Manajemen File
Actor (s) Administrator, Dosen
Brief Description Usecase ini mendeskripsikan event dari administrator
dan Dosen yaitu menambah dan menghapus File.
Precondition User haruslah sudah terdaftar sebagai pengguna sistem.
User haruslah seorang yang terdaftar sebagai
administrator atau Dosen.
Trigger Use case ini diinisiasi pada saat user memilih menu
[Upload File].
Basic Flow 1. User membuka list dengan memilih menu [Upload
File].
2. User mengklik tombol [browse].
3. User memilih file yang akan diupload
Manajemen File
Administrator
Tutor
Upload File
Delete File
50
4. User mngklik tombol submit.
Alternate flow
Post condition Aplikasi menyimpan nama file ke dalam database, dan
meyimpan file tersebut ke dalam folder pada server.
6. Use Case Manajemen Gambar
Gambar 4.6 Use Case Diagram Manajemen Gambar
Tabel 4.7 Use Case Manajemen Gambar
Usecase Name Manajemen Gambar
Actor (s) Administrator, Dosen
Brief Description Usecase ini mendeskripsikan event dari administrator
dan Dosen yaitu menambah dan menghapus Gambar.
Precondition User haruslah seorang yang terdaftar sebagai
administrator atau Dosen.
Trigger Use case ini diinisiasi pada saat user memilih menu
[Image Manager].
Manajemen Gambar
Administrator
Tutor
Upload Gambar
Delete File
51
Basic Flow 1. User membuka list dengan memilih menu [Image
Manager].
2. User mengklik tombol [browse].
3. User memilih gambar yang akan diupload
4. User mngklik tombol submit.
Alternate flow
Post condition Aplikasi menyimpan nama file ke dalam database, dan
meyimpan gambar tersebut ke dalam folder pada server.
4.3.2. Entity Relational Diagram (ERD)
Entity Relational Diagram (ERD) adalah suatu model yang digunakan untuk
menggambarkan data dalam bentuk entitas, atribut dan hubungan antar-entitas.
ERD dapat digunakan pada semua alat-alat pemodelan dan merupakan metode
untuk menggambarkam sistem penyimpanan data. Hubungan antar tabel adalah
sebagai berikut :
Gambar 4.7 Entity Relational Diagram (ERD)
52
Berikut ini adalah kamus data dari tabel-tabel yang ada di dalam
aplikasi:
1. Tabel User
Nama Tabel : user
Keterangan : Berisi data user
Primary Key : id
Tabel 4.8 Tabel user
Nama Field Tipe Panjang Keterangan
id int 4 ID user
user_namaDepan Varchar 255 Nama depan user
user_namaBelakang Varchar 255 Nama belakang user
user_email Varchar 255 Email user
user_password Varcahr 255 Password user
User_type Varcahr 255 User role
2. Tabel Materi
Nama Tabel : materi
Keterangan : Berisi daftar-daftar materi berdasarkan mata kuliah yang
diajarkan
Primary Key : materi_id
53
Tabel 4.9 Tabel Materi
Nama Field Tipe Panjang Keterangan
materi _id Int 4 Id materi
title varchar 255 Judul materi
content text Isi materi
user int 4 Id User dengan role tutor yang membuat materi
matkul int 4 Id dari mata kuliah
3. Tabel Mata Matkul
Nama Tabel : matkul
Keterangan : Berisi daftar-daftar mata kuliah yang diajarkan
Primary Key : matkul_id
Tabel 4.10 Tabel Matkul
Nama Field Tipe Panjang Keterangan
matkul_id Int 4 Id mata kuliah
matkul_title varchar 50 Nama mata kuliah
matkul_kode varchar 8 Kode mata kuliah
matkul_semester varchar 2 Semester mata kuliah
4. Tabel Kuliah
Nama Tabel : kuliah
Keterangan : Berisi data-data perkuliahan
Primary Key : kuliah_id
54
Tabel 4.11 Tabel Kuliah
Nama Field Tipe Panjang Keterangan
Kuliah_id int 4 ID kuliah (auto increment)
Matkul int 4 Foreign key dari mata kuliah
User int 4 Foreign key user
5. Tabel Images
Nama Tabel : images
Keterangan : Berisi data-data gambar
Primary Key : image_id
Tabel 4.12 Tabel image
Nama Field Tipe Panjang Keterangan
image_id int 4 ID image (auto increment)
Image_path varchar 255 Nama file gambar.
User int 4 Foreign key user
6. Tabel File
Nama Tabel : file
Keterangan : Berisi data-data file yang diupload
Primary Key : file_id
Tabel 4.13 Tabel File
Nama Field Tipe Panjang Keterangan
file_id int 4 ID kuliah (auto increment)
55
File_path Varchar 255 Nama file
Materi int 4 Foreign key materi
4.3.3 Pemodelan Antar Muka
Pada tahap perancangan antar muka penulis mempertimbangkan
beberapa aspek. Berikut adalah beberapa aspek yang menjadi pertimbangan
penulis:
a. Disain dibuat konsisten.
b. Navigasi mudah dimengerti.
c. Penggunaan gambar yang sesedikit mungkin.
d. Perpindahan halaman dibuat seminimal mungkin.
Berdasarkan pertimbangan di atas, maka penulis merancang antar muka
sebagai berikut:
1. Antar Muka Halaman Awal
Gambar 4.8. Perancangan halaman Login
Untuk admin dan tutor, saat pertama kali aplikasi ini dibuka di browser,
aplikasi akan langsung menampilkan form login.
APLIKASI CONTENT MANAGEMENT SYSTEM m-Learning
Copyright © 2010 All Right Reserved
Gambar
Username
Password
56
2. Antar Muka Halaman Kelas
Gambar 4.9. Perancangan halaman Kelas
Menu-menu yang penulis tampilkan berisi: Kelas, Kuliah, Mata Kuliah,
Materi, User, dan Logout. Pada halaman kelas, penulis tampilkan tabel Daftar
kelas dan form untuk operasi create, update, dan delete kelas.
Kelas Kuliah Mata Kuliah Materi User Logout
APLIKASI CONTENT MANAGEMENT SYSTEM m-Learning
Copyright © 2010 All Right Reserved
Tabel Kelas Nama Kelas
New Save Delete
57
3. Antar Muka Halaman Kuliah
Gambar 4.10 Perancangan halaman Kuliah
Pada halaman kuliah, penulis tampilkan tabel Daftar kuliah dan form
untuk operasi create, update, dan delete kuliah.
4. Antar Muka Halaman Materi
Gambar 4.11 Perancangan halaman Materi
Kelas Kuliah Mata Kuliah Materi User Logout
APLIKASI CONTENT MANAGEMENT SYSTEM m-Learning
Kelas Kuliah Mata Kuliah Materi User Logout
APLIKASI CONTENT MANAGEMENT SYSTEM m-Learning
Tabel Kuliah
Course
Kelas
Tutor
New Save Delete
Tabel Materi
New Save Delete
Course
Tutor
Title
Content
58
Pada halaman materi, penulis tampilkan tabel Daftar materi dan form
untuk operasi create, update, dan delete materi.
5. Antar Muka Halaman Mata Kuliah
Gambar 4.12 Perancangan halaman Mata Kuliah
Pada halaman Mata kuliah, penulis tampilkan tabel Daftar Mata kuliah dan
form untuk operasi create, update, dan delete Mata kuliah.
Kelas Kuliah Mata Kuliah Materi User Logout
APLIKASI CONTENT MANAGEMENT SYSTEM m-Learning
New Save Delete
Tabel Mata Kuliah
Semester
Kode
Title
59
6. Antar Muka Halaman User
Gambar 4.13 Perancangan halaman User
Pada halaman User, penulis tampilkan tabel Daftar User dan form untuk
operasi create, update, dan delete User.
4.3.4 Pemodelan Kelas
Framework yang penulis gunakan dalam pengembangan aplikasi ini
Kelas Kuliah Mata Kuliah Materi User Logout
APLIKASI CONTENT MANAGEMENT SYSTEM m-Learning
Tabel User
New Save Delete
Nama Depan
Nama Belakang
Password
Konfirmasi Password
NIP
Gelar
Role
60
adalah framework hibernate yaitu framework yang melakukan pemetaan table-
table pada database ke dalam objek-objek yang disebut object mappings. Setiap
object yang dibuat adalah representasi dari fields yang ada di database.
Setelah mapping dilakukan, selanjutnya penulis membuat kelas-kelas yang
digunakan untuk mengakses data yang disebut DAO (Data Access Object).
Berikut adalah object mappings dan DAO (Data Access Object) yang penulis
buat.
61
a. Package entity
Package entity berisi object mappings dari database, berikut adalah bentuk
class diagram beserta relasi dari objek-objek yang ada di package entity.
Gambar 4.14 Class Diagram pada package entity
62
b. Package DAO
Berikut adalah class diagram dari package DAO yang penulis buat:
Gambar 4.9. Class Diagram Package DAO
4.4. Construction
Gambar 4.15 Class Diagram pada package DAO
63
4.4 Construction
4.4.1 Implementasi antar muka
Pada tahap ini, penulis memulai membuat aplikasi dari perancangan
yang telah penulis buat sebelumnya. Bahasa pemrograman yang penulis
terapkan adalah bahasa pemrograman Java dengan framework Hibernate
untuk relational database dan JMaki sebagai framework AJAX. Adapun
listing kode pemrograman dapat dilihat pada Lampiran B.
Adapun tampilan aplikasi yang penulis buat bisa dilihat pada gambar
dibawah ini:
1. Tampilan Halaman Login
Gambar 4.16 Halaman Login
64
2. Tampilan Halaman Mata Kuliah
Gambar 4.17 Halaman Mata Kuliah
3. Tampilan Halaman Materi
Gambar 4.18 Halaman Materi
65
4. Tampilan Halaman User
Gambar 4.19 Halaman User
5. Tampilan Halaman Upload File
Gambar 4.20 Halaman Materi untuk Tutor
66
6. Tampilan halaman Image Manager
Gambar 4.21 Halaman Image Manager
7. Tampilan Halaman Materi untuk Tutor
Gambar 4.22 Halaman Materi untuk Tutor
67
8. Tampilan Halaman User untuk Tutor
Gambar 4.23 Halaman User untuk Tutor
9. Tampilan Halaman Frontend daftar Dosen
Gambar 4.24 Halaman Frontend daftar Dosen
68
10. Tampilan Halaman Frontend daftar Mata Kuliah
Gambar 4.25 Halaman Frontend daftar Mata Kuliah
11. Tampilan Halaman Frontend Profil Dosen
Gambar 4.26 Halaman Frontend Profil Dosen
69
12. Tampilan Halaman Frontend Materi
Gambar 4.27 Halaman Frontend Materi
13. Tampilan Hasil Pencarian
Gambar 4.28 Halaman Hasil Pencarian
70
Pengujian pada Handphone User
Penulis melakukan pengujian pada beberapa tipe Handphone. Penulis
melakukan pengujian dengan menggunakan jaringan ad-hoc dari laptop ke
handphone. Berikut adalah hasil pengujian yang telah penulis lakukan:
Gambar 4.29 Pengujian pada handphone Nokia E63
Gambar 4.30 Pengujian pada handphone Nokia E51
4.4.
JUn
a
Gamb
.2 Unit Tes
Berikut ad
it yang terin
a. Class m
bar 4.31 Pe
sting
dalah hasil
ntegrasi den
materi:
Gamba
engujian pad
unit testin
ngan IDE N
ar 4.32 Has
da handphon
ng yang pen
NetBeans 6.7
sil Unit Test
ne Nokia C
nulis lakuk
7.1:
ting class m
3
kan dengan
materi
71
tools
72
b. Class matkul:
Gambar 4.33 Hasil Unit Testing class matkul
c. Class user:
Gambar 4.34 Hasil Unit Testing class user
d. Class file:
Gambar 4.35 Hasil Unit Testing class file
73
e. Class Image:
Gambar 4.36 Hasil Unit Testing class Image
4.4.3 System Testing
Pada tahap ini penulis melakukan serangkaian testing. Hasil dari
testing yang telah penulis lakukan adalah sebagai berikut:
a. Recovery Testing
Penulis membuat proses pemulihan dengan memanggil fungsi
rollback pada API Hibernate untuk mengatasi gangguan yang dapat
menyebabkan kegagalan pada aplikasi.
Fungsi rollback akan membatalkan semua perubahan yang
dilakukan semua perintah SQL sejak proses transaksional dimulai atau
sejak perubahan terakhir dibuat jika terjadi kegagalan.
Pada tahap ini penulis melakukan langkah –langkah sebagai berikut:
1. Mematikan database
Database dimatikan ketika aplikasi sedang dalam keadaan
berjalan. Dari log pada server terlihat bahwa fungsi rollback untuk
mengatasi kegagalan akses database berjalan dengan baik.
74
2. Mematikan server
Server dimatikan ketika aplikasi sedang dalam keadaan berjalan.
Dari log pada server terlihat bahwa fungsi rollback untuk mengatasi
server yang mati berjalan dengan baik.
b. Security Testing
Hasil dari security testing yang penulis lakukan menunjukkan tidak
terdapat link yang memungkinkan untuk diserang. Berikut pada tabel
4.14 dan tabel 4.15 adalah hasil pengujian yang telah penulis lakukan:
Tabel 4.14 Hasil Security Testing pada halaman frontend
Test Hasil
Jumlah Link 10
Kemungkinan serangan 0
Tabel 4.15 Hasil Security Testing pada halaman Administrator
Test Hasil
Jumlah Link 26
Kemungkinan serangan 0
75
c. Stress Testing
Hasi dari stress testing yang penulis lakukan menunjukkan aplikasi
mampu berjalan dalam keadaan normal dengan beban yang berat.
Berikut adalah hasil pengujian yang telah penulis lakukan:
Performance data:
Tabel 4.16 Hasil Performance data pada Stress Testing
Pada tabel 4.16 di atas menunjukkan data yang diterima pengguna dalam
kurun waktu 1 menit yang dihitung setiap 10 detik. Pengguna masih bisa
mengakses total rata-rata 2,42 halaman dalam waktu 1 menit dengan jumlah rata-
rata sukses 2,42 halaman atau 100 %.
76
Response Time:
Tabel 4.17 Hasil Response Time data pada Stress Testing
Pada tabel 4.17 di atas menunjukkan respon aplikasi terhadap permintaan
halaman oleh pengguna selama 1 menit yang dihitung setiap 10 detik. Total
selama 1 menit pengujian, hasil rata-rata yang diperoleh adalah 1,8 detik per
halaman.
77
Bandwith Usage:
Tabel 4.18 Hasil Bandwith Usage data pada Stress Testing
Pada tabel 4.18 di atas menunjukkan penggunaan bandwith oleh aplikasi
dalam kurun waktu 1 menit yang dihitung setiap 10 detik. Total selama pengujian
adalah 9,96 kbit/s untuk penerimaan pada satu pengguna dan 1,68 kbit/s untuk
pengiriman pada satu pengguna.
78
Errors report:
Tabel 4.19 Hasil Errors report data pada Stress Testing
Pada tabel 4.19 di atas menunjukkan error yang terjadi pada aplikasi
selama stress testing dalam kurun waktu 1 menit yang dihitung setiap 10 detik.
Hasil yang didapat menunjukkan tidak ada error pada aplikasi selama stress
testing dilakukan.
79
Performance Testing
Berikut adalah hasil pengujian yang telah penulis lakukan:
Performance data:
Tabel 4.20 Hasil Performance data data pada Performance Testing
Pada tabel 4.20 di atas menunjukkan data yang diterima pengguna dalam
kurun waktu 1 menit yang dihitung setiap 10 detik. Pengguna masih bisa
mengakses total rata-rata 2,4 halaman dalam waktu 1 menit dengan jumlah rata-
rata sukses 2,4 halaman atau 100 %.
80
Response time:
Tabel 4.21 Hasil Response time data pada Performance Testing
Pada tabel 4.21 di atas menunjukkan respon aplikasi terhadap permintaan
halaman oleh pengguna dalam kurun waktu 1 menit yang dihitung setiap 10 detik.
Total selama 1 menit pengujian, hasil rata-rata yang diperoleh adalah 1,711 detik
per halaman.
81
Bandwith Usage
Tabel 4.22 Hasil Bandwith Usage data pada Performance Testing
Pada tabel 4.22 di atas menunjukkan penggunaan bandwith oleh aplikasi
dalam kurun waktu 1 menit yang dihitung setiap 10 detik. Total selama pengujian
adalah 2,0 kbit/s untuk penerimaan pada satu pengguna dan 0,54 kbit/s untuk
pengiriman pada satu pengguna.
82
Errors Report:
Tabel 4.23 Hasil Errors Report data pada Performance Testing
Pada tabel 4.23 di atas menunjukkan error yang terjadi pada aplikasi
selama stress testing dalam kurun waktu 1 menit yang dihitung setiap 10 detik.
83
Hasil yang didapat menunjukkan tidak ada error pada aplikasi selama stress
testing dilakukan.
4.5 Deployment
4.5.1 Deployment
Pada tahap ini penulis melakukan deployment aplikasi pada server
Pusat Data Teknik informatika Fakultas Sains dan Teknologi (PUSDATIN
FST).
4.5.2 Users Delivery Feedback
Untuk mendapatkan feedback mengenai aplikasi yang penulis
kembangkan, penulis mendapat saran dari user mengenai aplikasi yang
penulis buat. Berikut adalah feedback yang penulis dapatkan:
1. Halaman yang tampil disarankan memiliki tampilan yang
menyesuaikan dengan lebar layar, sehingga tidak ada scroll pada
bagian bawah halaman.
2. Pada setiap halaman materi disarankan untuk ditampilkan materi
dari Dosen yang sama, sehingga memudahkan user dalam hal
navigasi.
3. Ukuran huruf pada aplikasi disarankan untuk diperbesar.
84
BAB V
PENUTUP
5.1 Kesimpulan
Berdasarkan uraian dan pembahasan pada bab-bab sebelumnya, maka
dapat ditarik kesimpulan bahwa :
1. Dengan mengembangkan aplikasi mobile learning berbasis web, pengguna
tidak memerlukan aplikasi khusus untuk menggunakan aplikasi ini.
2. Berdasarkan pengujian yang dilakukan oleh pengguna, dengan adanya
fasilitas-fasilitas untuk mengupdate content, aplikasi memiliki content
yang dinamis karena content dapat diisi sesuai dengan kebutuhan pengajar.
3. Berdasarkan pengujian yang dilakukan oleh penulis, aplikasi mobile
learning ini dapat berjalan sesuai dengan tujuan, analisis, dan desain yang
telah dirancang, sehingga aplikasi ini dapat membantu pembelajar dalam
aktifitas belajar.
Tabel 5.1 Rangkuman Hasil pengujian
Nama Testing Hasil
Security Testing Dari 36 link kemungkinan
serangan 0
Stress Testing Performance data 2,42 halaman per detik
Response Time Rata-rata 1,8 detik / halaman.
Bandwith Usage Receive per user 9,96 kbit/s
Sending per user 1,68 kbit/s
85
Errors report Total errors 0%
Performance Testing
Performance data 2,42 detik per halaman.
Response Time Rata-rata 1,711 detik / halaman.
Bandwith Usage Receive per user 2,0 kbit/s
Sending per user 0,54 kbit/s
Errors report Total errors 0%
5.2 Saran
Berdasarkan kesimpulan-kesimpulan yang telah dikemukakan, dapat
diajukan beberapa saran untuk pengembangan lebih lanjut antara lain :
1. Disarankan adanya media player untuk file multimedia sehingga dapat
dibuka dengan cara streaming.
2. Aplikasi ini belum dapat menyimpan hasil yang didapat mahasiswa setelah
mengerjakan soal. Disarankan adanya penyimpanan nilai bagi mahasiswa
yang telah mengerjakan soal-soal.
86
DAFTAR PUSTAKA
Ally , Mohamed. 2009. Mobile Learning Transforming the Delivery of Education
and Training. Edmonton: AU Press.
Bauer , Christian And King , Gavin. 2005. Java Persistence with Hibernate. New
York: Manning
Basaeed, Essa and Berri, Jawad.2007. Learner-Centric Context-Aware Mobile
Learning.
Jogiyanto, H.M. 2008. Metodologi Penelitian Sistem Informasi. Yogyakarta: Andi
Offset.
Kineo and UFI. 2009. Mobile Learning Reviewed. UK
Low , Leonard.2007. M-learning standards report. Canberra
MySQL Reference Manual. 2001. MySQL AB
Naik, Kshirasagar And Tripathy, Priyadarshi. 2008. Software Testing And
Quality Assurance Theory and Practice. New Jersey: A johnwiley & sons,
inc., publication.
87
Naughton , Patrick and Schildt, Herbert . 2001. Java 2: The Complete Reference.
California:Osborne/McGraw-Hill
Niazi , Razieh and Qusay H. Mahmoud. 2008. Design and Development of a
Device-Independent System for Mobile Learning. IEEE Education Society
Students Activities Committee
Pressman, Roger S. 2001. Software Engineering: A Practitioner's Approach. New
York: McGraw-Hill. 2005. Software Engineering: A Practitioner’s
Approach. New York: Mc-Graw Hill.
Rachdian , Adhi. 2005 Mastering CMS dengan Mambo/ Joomla. Jakarta: PT. Elex
Media Komputindo.
Stieglitz , Stefan and Fuchß, Christoph.2007. Mobile Learning by Using Ad Hoc
Messaging Network.
LAMPIRAN A
WAWANCARA
Wawancara dilakukan kepada Bapak Imam M. Shofi sebagai Kepala Pusat
Data Teknik informatika Fakultas Sains dan Teknologi (PUSDATIN FST).
Adapun pertanyaan yang penulis ajukan adalah sebagai berikut:
1. Apakah aplikasi mobile learning dibuat terbuka (dapat diakses oleh siapa
saja) atau tidak?
2. Menu apa saja yang seharusnya ada pada aplikasi mobile learning?
3. File berformat apa saja yang biasanya dijadikan bahan mengajar?
4. Word processor pada aplikasi web seperti apa yang diperlukan untuk
mangakomodasi materi belajar?
Dari wawancara di atas, penulis menarik kesimpulan sebagai berikut:
1. Aplikasi dibuat terbuka (dapat diakses oleh siapa saja).
2. Aplikasi menampilkan profil dosen yang mengisi konten belajar.
3. File yang sering digunakan adalah file dokumen berformat .doc, .ppt, .pdf dan
file multimedia seperti .mp3 dan .flv.
4. Word processor untuk mengisi konten memiliki fasilitas yang mirip dengan
aplikasi word processor pada aplikasi desktop seperti dapat membuat tabel,
numbering, format huruf, dan memasukkaan gambar pada konten.
LAMPIRAN B
USERS FEEDBACK
Kuesioner penulis sebarkan untuk mendapatkan feedback dari user.
Responden kuesioner ini adalah mahasiswa dan dosen. Adapun hasil jawaban
kuesioner adalah sebagai berikut:
No Pertanyaan Jawaban
Ya Tidak
1 Apakah tujuan dari aplikasi dapat tercapai? 87% 13%
2
Apakah disain menggunakan elemen-elemen standard
dan tidak menggunakan antarmuka dan elemen-elemen
yang sulit dipahami?
93% 7%
3 Apakah seluruh bagian dari disain benar-benar
diperlukan? 93% 7%
4 Apakah disain aplikasi konsisten? 93% 7%
5 Apakah aplikasi dapat meningkatkan produktifitas
pembelajaran? 100% 0%
6 Apakah disain aplikasi mudah dipelihara? 93% 7%
7 Apakah faktor-faktor keamanan sudah terpenuhi? 93% 7%
Dari hasil kuesioner di atas, penulis menyimpulkan bahwa aplikasi telah
memenuhi kebutuhan pengguna.
LAMPIRAN C
LISTING SOURCE CODE Hibernate.cfg.xml: <?xml version="1.0" encoding="UTF‐8"?> <!DOCTYPE hibernate‐configuration PUBLIC "‐//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate‐configuration‐3.0.dtd"> <hibernate‐configuration> <session‐factory> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/skripsi4</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password"></property> <mapping resource="entity/Materi.hbm.xml"/> <mapping resource="entity/Matkul.hbm.xml"/> <mapping resource="entity/User.hbm.xml"/> <mapping resource="entity/File.hbm.xml"/> <mapping resource="entity/Images.hbm.xml"/> </session‐factory> </hibernate‐configuration> Package dao: Class DAO.java: import java.util.logging.Level; import java.util.logging.Logger; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public class DAO { protected DAO() { } public static Session getSession() { Session session = (Session) DAO.session.get(); if (session == null) { session = sessionFactory.openSession(); DAO.session.set(session); } return session; } protected void begin() { getSession().getTransaction().begin(); } protected void commit() { getSession().getTransaction().commit(); }
protected void rollback() { try { getSession().getTransaction().rollback(); log.log(Level.WARNING,"rollback success"); } catch( HibernateException e ) { log.log(Level.WARNING,"Cannot rollback",e); } try { getSession().close(); } catch( HibernateException e ) { log.log(Level.WARNING,"Cannot close",e); } DAO.session.set(null); } public static void close() { getSession().close(); DAO.session.set(null); } private static final Logger log = Logger.getAnonymousLogger(); private static final ThreadLocal session = new ThreadLocal(); private static final SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory(); } Class DAOFile.java: package dao; import entity.AdException; import entity.File; import entity.Materi; import java.util.List; import org.hibernate.HibernateException; import org.hibernate.Query; public class DAOFile extends DAO { public File get(String file_id) throws AdException { try { begin(); Query q = getSession().createQuery( "from File where file_id= :file_id"); q.setString("file_id", file_id); File kelas = (File) q.uniqueResult(); commit(); return kelas; } catch (HibernateException e) { rollback(); throw new AdException("Could not obtain the named category " + file_id, e); } }
public File create(String path, Materi materi, byte[] file_file, String file_type) throws AdException { try { begin(); File file = new File(path, materi, file_type); getSession().save(file); commit(); return file; } catch (HibernateException e) { rollback(); throw new AdException("Could not create file" + e); } } public void delete(File file) throws AdException { try { begin(); getSession().delete(file); commit(); } catch (HibernateException e) { rollback(); throw new AdException("Could not delete file", e); } } public List list() throws AdException { try { begin(); Query q = getSession().createQuery("from File"); List list = q.list(); commit(); return list; } catch (HibernateException e) { rollback(); throw new AdException("Could not list the categories", e); } } } Class DAOImage.java: package dao; import entity.AdException; import entity.Images; import entity.User; import org.hibernate.HibernateException; import org.hibernate.Query; public class DAOImage extends DAO {
public Images get(String file_id) throws AdException { try { begin(); Query q = getSession().createQuery( "from Images where image_id= :file_id"); q.setString("file_id", file_id); Images kelas = (Images) q.uniqueResult(); commit(); return kelas; } catch (HibernateException e) { rollback(); throw new AdException("Could not obtain the named category " + file_id, e); } } public Images create(String path, User user) throws AdException { try { begin(); Images file = new Images(path, user); getSession().save(file); commit(); return file; } catch (HibernateException e) { rollback(); throw new AdException("Could not create file" + e); } } public void delete(Images image) throws AdException { try { begin(); getSession().delete(image); commit(); } catch (HibernateException e) { rollback(); throw new AdException("Could not delete file", e); } } } Class DAOMateri.java: package dao; import java.util.List; import org.hibernate.HibernateException; import entity.AdException; import entity.Materi; import entity.User; import entity.Matkul; import org.hibernate.Criteria; import org.hibernate.Query;
import org.hibernate.criterion.Criterion; import org.hibernate.criterion.LogicalExpression; import org.hibernate.criterion.Restrictions; public class DAOMateri extends DAO { public Materi get(String materi_id) throws AdException { try { begin(); Query q = getSession().createQuery( "from Materi where materi_id= :materi_id"); q.setString("materi_id", materi_id); Materi materi = (Materi) q.uniqueResult(); commit(); return materi; } catch (HibernateException e) { rollback(); throw new AdException("Could not obtain the named category " + materi_id, e); } } public Materi getByMatkul(String matkul) throws AdException { try { begin(); Query q = getSession().createQuery( "from Materi where matkul= :matkul"); q.setString("matkul", matkul); Materi materi = (Materi) q.uniqueResult(); commit(); return materi; } catch (HibernateException e) { rollback(); throw new AdException("Could not obtain the named category " + matkul, e); } } public List listBySearch(String keyword) throws AdException { try { begin(); Criteria crit = getSession().createCriteria(Materi.class); Criterion title = Restrictions.like("title", "%" + keyword + "%"); Criterion content = Restrictions.like("content", "%" + keyword + "%"); LogicalExpression orExp = Restrictions.or(title, content); crit.add(orExp); List result = crit.list(); commit(); return result; } catch (HibernateException e) { rollback(); throw new AdException("Could not list the categories", e); }
} public Materi create(String title, String content, User user, Matkul matkul) throws AdException { try { begin(); Materi advert = new Materi(title, content, user, matkul); getSession().save(advert); commit(); return advert; } catch (HibernateException e) { rollback(); throw new AdException("Could not create advert", e); } } public void delete(Materi advert) throws AdException { try { begin(); getSession().delete(advert); commit(); } catch (HibernateException e) { rollback(); throw new AdException("Could not delete advert", e); } } public List list() throws AdException { try { begin(); Query q = getSession().createQuery("from Materi"); List list = q.list(); commit(); return list; } catch (HibernateException e) { rollback(); throw new AdException("Could not list the categories", e); } } public List listByMatkul(String cd) throws AdException { try { begin(); Query q = getSession().createQuery("from Materi where matkul= :cd"); List list = q.list(); commit(); return list; } catch (HibernateException e) { rollback(); throw new AdException("Could not list the categories", e); }
} public List listByUser(String usId) throws AdException { try { begin(); Query q = getSession().createQuery("from Materi where user= :usId"); List list = q.list(); commit(); return list; } catch (HibernateException e) { rollback(); throw new AdException("Could not list the Materi" + e); } } public void update(Materi materi, String judul, String content, Matkul matkul, User user) throws AdException { try { begin(); materi.setTitle(judul); materi.setContent(content); materi.setMatkul(matkul); materi.setUser(user); getSession().merge(materi); commit(); } catch (HibernateException e) { rollback(); throw new AdException("Could not save the category", e); } } } Class DAOMatkul.java: package dao; import entity.Matkul; import java.util.List; import org.hibernate.HibernateException; import org.hibernate.Query; import entity.AdException; import org.hibernate.Criteria; import org.hibernate.criterion.Criterion; import org.hibernate.criterion.LogicalExpression; import org.hibernate.criterion.Restrictions; public class DAOMatkul extends DAO { public Matkul get(String matkul_id) throws AdException { try { begin();
Query q = getSession().createQuery( "from Matkul where matkul_id = :matkul_id"); q.setString("matkul_id", matkul_id); Matkul category = (Matkul) q.uniqueResult(); commit(); return category; } catch (HibernateException e) { rollback(); throw new AdException("Could not obtain the named category " + matkul_id, e); } } public Matkul create(String title, String kode, String sem) throws AdException { try { begin(); Matkul matkul = new Matkul(title, kode, sem); getSession().save(matkul); commit(); return matkul; } catch (HibernateException e) { rollback(); throw new AdException("Could not create advert", e); } } public void delete(Matkul matkul) throws AdException { try { begin(); getSession().delete(matkul); commit(); } catch (HibernateException e) { rollback(); throw new AdException("Could not delete advert", e); } } public List list() throws AdException { try { begin(); Query q = getSession().createQuery("from Matkul order by matkul_title asc"); List list = q.list(); commit(); return list; } catch (HibernateException e) { rollback(); throw new AdException("Could not list the categories", e); } } public List listBySearch(String keyword) throws AdException { try {
begin(); Criteria crit = getSession().createCriteria(Matkul.class); crit.add(Restrictions.like("matkul_title", "%" + keyword + "%")); List result = crit.list(); commit(); return result; } catch (HibernateException e) { rollback(); throw new AdException("Could not list the categories", e); } } public List listTutor() throws AdException { try { begin(); Query q = getSession().createQuery("from Matkul order by matkul_title asc"); List list = q.list(); commit(); return list; } catch (HibernateException e) { rollback(); throw new AdException("Could not list the categories", e); } } public void update(Matkul matkul, String judul, String kode, String sem) throws AdException { try { begin(); matkul.setMatkul_title(judul); matkul.setMatkul_kode(kode); matkul.setMatkul_semester(sem); getSession().merge(matkul); commit(); } catch (HibernateException e) { rollback(); throw new AdException("Could not save the category", e); } } } Class DAOUser.java: package dao; import org.hibernate.HibernateException; import org.hibernate.Query; import entity.AdException; import entity.User; import java.util.List; import org.hibernate.Criteria; import org.hibernate.criterion.Criterion; import org.hibernate.criterion.LogicalExpression;
import org.hibernate.criterion.Restrictions; public class DAOUser extends DAO { public User get(String user_id) throws AdException { try { begin(); Query q = getSession().createQuery("from User where user_id = :user_id"); q.setString("user_id", user_id); User user = (User) q.uniqueResult(); commit(); return user; } catch (HibernateException e) { rollback(); throw new AdException("Could not get user " + user_id, e); } } public List list() throws AdException { try { begin(); Query q = getSession().createQuery("from User"); List list = q.list(); commit(); return list; } catch (HibernateException e) { rollback(); throw new AdException("Could not list the categories", e); } } public List listBySearch(String keyword) throws AdException { try { begin(); Criteria crit = getSession().createCriteria(User.class); Criterion title = Restrictions.like("user_namaDepan", "%" + keyword + "%"); Criterion content = Restrictions.like("user_namaBelakang", "%" + keyword + "%"); LogicalExpression orExp = Restrictions.or(title, content); crit.add(orExp); List result = crit.list(); commit(); return result; } catch (HibernateException e) { rollback(); throw new AdException("Could not list the categories", e); } } public List listForTutor() throws AdException { try {
begin(); Query q = getSession().createQuery("from User where user_type=2 order by user_namaDepan asc"); List list = q.list(); commit(); return list; } catch (HibernateException e) { rollback(); throw new AdException("Could not list the tutors", e); } } public void update(User user, String nama_depan, String nama_belakang, String users_email, String users_nip, String users_degree, String users_type, String users_cv, String users_pwd) throws AdException { try { begin(); user.setUser_password(users_pwd); user.setUser_namaDepan(nama_depan); user.setUser_namaBelakang(nama_belakang); user.setUser_email(users_email); user.setUser_nip(users_nip); user.setUser_gelar(users_degree); user.setUser_type(users_type); user.setUser_cv(users_cv); getSession().merge(user); commit(); } catch (HibernateException e) { rollback(); throw new AdException("Could not save the category" + e); } } public void update(User user, String nama_depan, String nama_belakang, String users_email, String users_nip, String users_degree, String users_type, String users_cv) throws AdException { try { begin(); user.setUser_namaDepan(nama_depan); user.setUser_namaBelakang(nama_belakang); user.setUser_email(users_email); user.setUser_nip(users_nip); user.setUser_gelar(users_degree); user.setUser_type(users_type); user.setUser_cv(users_cv); getSession().merge(user); commit(); } catch (HibernateException e) { rollback(); throw new AdException("Could not save the category" + e); } }
public void resetPwd(User user, String users_nip) throws AdException { try { begin(); user.setUser_password(users_nip); getSession().merge(user); commit(); } catch (HibernateException e) { rollback(); throw new AdException("Could not save the category" + users_nip, e); } } public User create(String user_namaDepan, String user_namaBelakang, String user_email, String user_password, String user_nip, String user_gelar, String user_type, String user_cv) throws AdException { try { begin(); User user = new User(user_namaDepan, user_namaBelakang, user_email, user_nip, user_nip, user_gelar, user_type, user_cv); getSession().save(user); commit(); return user; } catch (HibernateException e) { rollback(); throw new AdException("Could not create user " + user_namaDepan + e); } } public void delete(User user) throws AdException { try { begin(); getSession().delete(user); commit(); } catch (HibernateException e) { rollback(); throw new AdException("Could not delete user " + user.getUser_namaDepan(), e); } } } Package entity: Class AdException.java: package entity; public class AdException extends Exception { public AdException(String message) {
super(message); } public AdException(String message, Throwable cause) { super(message, cause); } } Class File.java: package entity; public class File { private long file_id; private String file_path; private Materi materi; private String file_type; public File(String file_path, Materi materi, String file_type) { this.file_path = file_path; this.materi = materi; this.file_type = file_type; } public String getFile_type() { return file_type; } public void setFile_type(String file_type) { this.file_type = file_type; } public File() { } public long getFile_id() { return file_id; } public void setFile_id(long file_id) { this.file_id = file_id; } public String getFile_path() { return file_path; } public void setFile_path(String file_path) { this.file_path = file_path; }
public Materi getMateri() { return materi; } public void setMateri(Materi materi) { this.materi = materi; } } File.hbm.xml: <?xml version="1.0" encoding="UTF‐8"?> <!DOCTYPE hibernate‐mapping PUBLIC "‐//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate‐mapping‐3.0.dtd"> <hibernate‐mapping> <class dynamic‐insert="false" dynamic‐update="false" mutable="true" name="entity.File" optimistic‐lock="version" polymorphism="implicit" select‐before‐update="false" table="file"> <id column="file_id" name="file_id" type="long"> <generator class="native"/> </id> <property column="file_path" name="file_path" type="string"/> <property column="file_type" name="file_type" type="string"/> <many‐to‐one class="entity.Materi" column="materi" foreign‐key="fk_file_materi" name="materi" not‐null="true"/> </class> </hibernate‐mapping> Class Images.java package entity; public class Images { private long image_id; private String image_path; private User user; public Images(String file_path, User user) { this.image_path = file_path; this.user = user; } public Images() { } public long getImage_id() { return image_id; } public void setImage_id(long image_id) {
this.image_id = image_id; } public String getImage_path() { return image_path; } public void setImage_path(String image_path) { this.image_path = image_path; } public User getUser() { return user; } public void setUser(User user) { this.user = user; } } Images.hbm.xml <?xml version="1.0" encoding="UTF‐8"?> <!DOCTYPE hibernate‐mapping PUBLIC "‐//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate‐mapping‐3.0.dtd"> <hibernate‐mapping> <class dynamic‐insert="false" dynamic‐update="false" mutable="true" name="entity.Images" optimistic‐lock="version" polymorphism="implicit" select‐before‐update="false" table="images"> <id column="image_id" name="image_id" type="long"> <generator class="native"/> </id> <property column="image_path" name="image_path" type="string"/> <many‐to‐one class="entity.User" column="user" foreign‐key="fk_image_user" name="user" not‐null="true"/> </class> </hibernate‐mapping> Class Materi.java package entity; import java.util.HashSet; import java.util.Set; public class Materi { private long materi_id; private String title; private String content; private User user; private Matkul matkul; private Set files = new HashSet();
public Materi(String title, String content, User user, Matkul matkul) { this.title = title; this.content = content; this.user = user; this.matkul = matkul; this.files = new HashSet(); } Materi() { } public Set getFiles() { return files; } public void setFiles(Set files) { this.files = files; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public User getUser() { return user; } public void setUser(User user) { this.user = user; } public long getMateri_id() { return materi_id; } public void setMateri_id(long materi_id) { this.materi_id = materi_id; }
public Matkul getMatkul() { return matkul; } public void setMatkul(Matkul matkul) { this.matkul = matkul; } } Materi.hbm.xml <?xml version="1.0" encoding="UTF‐8"?> <!DOCTYPE hibernate‐mapping PUBLIC "‐//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate‐mapping‐3.0.dtd"> <hibernate‐mapping> <class dynamic‐insert="false" dynamic‐update="false" mutable="true" name="entity.Materi" optimistic‐lock="version" polymorphism="implicit" select‐before‐update="false" table="materi"> <id column="materi_id" name="materi_id" type="long"> <generator class="native"/> </id> <property column="title" name="title" type="string"/> <property column="content" name="content" type="text"/> <many‐to‐one class="entity.User" column="user" foreign‐key="fk_materi_user" name="user" not‐null="true"/> <many‐to‐one class="entity.Matkul" column="matkul" foreign‐key="fk_materi_matkul" name="matkul" not‐null="true"/> <set cascade="delete" inverse="true" lazy="true" name="files" table="file"> <key> <column name="materi"/> </key> <one‐to‐many class="entity.File"/> </set> <set cascade="delete" inverse="true" lazy="true" name="soals" table="soal"> <key> <column name="materi"/> </key> </set> </class> </hibernate‐mapping> Class Matkul.java package entity; import java.util.HashSet; import java.util.Set; public class Matkul { private long matkul_id;
private String matkul_title; private String matkul_kode; private String matkul_semester; private Set materis = new HashSet(); public Matkul() { } public Matkul( String matkul_title,String matkul_kode,String matkul_semester) { this.matkul_title = matkul_title; this.matkul_kode = matkul_kode; this.matkul_semester = matkul_semester; this.materis = new HashSet(); } public String getMatkul_semester() { return matkul_semester; } public void setMatkul_semester(String matkul_semester) { this.matkul_semester = matkul_semester; } public String getMatkul_kode() { return matkul_kode; } public void setMatkul_kode(String matkul_kode) { this.matkul_kode = matkul_kode; } public Set getMateris() { return materis; } public long getMatkul_id() { return matkul_id; } public String getMatkul_title() { return matkul_title; } public void setMateris(Set materis) { this.materis = materis; } public void setMatkul_id(long matkul_id) { this.matkul_id = matkul_id; }
public void setMatkul_title(String matkul_title) { this.matkul_title = matkul_title; } } Matkul.hbm.xml <?xml version="1.0" encoding="UTF‐8"?> <!DOCTYPE hibernate‐mapping PUBLIC "‐//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate‐mapping‐3.0.dtd"> <hibernate‐mapping> <class dynamic‐insert="false" dynamic‐update="false" mutable="true" name="entity.Matkul" optimistic‐lock="version" polymorphism="implicit" select‐before‐update="false" table="matkul"> <id column="matkul_id" name="matkul_id" type="long"> <generator class="native"/> </id> <property column="matkul_title" name="matkul_title" not‐null="true" type="string"/> <property column="matkul_kode" name="matkul_kode" not‐null="true" unique="true" type="string"/> <property column="matkul_semester" name="matkul_semester" not‐null="true" type="string"/> <set cascade="delete" inverse="true" lazy="true" name="materis" table="materi"> <key> <column name="matkul"/> </key> <one‐to‐many class="entity.Materi"/> </set> </class> </hibernate‐mapping> Class User.java package entity; import java.util.HashSet; import java.util.Set; public class User { private long user_id; private String user_namaDepan; private String user_namaBelakang; private String user_email; private String user_password; private String user_nip; private String user_gelar; private String user_type; private String user_cv; private Set materis = new HashSet(); private Set images = new HashSet();
public User(String user_namaDepan, String user_namaBelakang, String user_email, String user_password, String user_nip, String user_gelar, String user_type, String user_cv) { this.user_type = user_type; this.user_namaDepan = user_namaDepan; this.user_namaBelakang = user_namaBelakang; this.user_email = user_email; this.user_password = user_password; this.user_nip = user_nip; this.user_gelar = user_gelar; this.user_cv = user_cv; this.materis = new HashSet(); this.images = new HashSet(); } public User() { } public String getUser_cv() { return user_cv; } public void setUser_cv(String user_cv) { this.user_cv = user_cv; } public Set getImages() { return images; } public void setImages(Set images) { this.images = images; } public Set getMateris() { return materis; } public String getUser_type() { return user_type; } public void setUser_type(String user_type) { this.user_type = user_type; } public String getUser_email() { return user_email; } public String getUser_gelar() { return user_gelar; }
public long getUser_id() { return user_id; } public String getUser_namaBelakang() { return user_namaBelakang; } public String getUser_namaDepan() { return user_namaDepan; } public String getUser_nip() { return user_nip; } public String getUser_password() { return user_password; } public void setMateris(Set materis) { this.materis = materis; } public void setUser_email(String user_email) { this.user_email = user_email; } public void setUser_gelar(String user_gelar) { this.user_gelar = user_gelar; } public void setUser_id(long user_id) { this.user_id = user_id; } public void setUser_namaBelakang(String user_namaBelakang) { this.user_namaBelakang = user_namaBelakang; } public void setUser_namaDepan(String user_namaDepan) { this.user_namaDepan = user_namaDepan; } public void setUser_nip(String user_nip) { this.user_nip = user_nip; } public void setUser_password(String user_password) { this.user_password = user_password; }
} User.hbm.xml <?xml version="1.0" encoding="UTF‐8"?> <!DOCTYPE hibernate‐mapping PUBLIC "‐//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate‐mapping‐3.0.dtd"> <hibernate‐mapping> <class dynamic‐insert="false" dynamic‐update="false" mutable="true" name="entity.User" optimistic‐lock="version" polymorphism="implicit" select‐before‐update="false" table="user"> <id column="user_id" name="user_id" type="long"> <generator class="identity"/> </id> <property column="user_namaDepan" name="user_namaDepan" type="string"/> <property column="user_namaBelakang" name="user_namaBelakang" type="string"/> <property column="user_email" name="user_email" type="string" unique="true"/> <property column="user_password" name="user_password" type="string"/> <property column="user_nip" name="user_nip" type="string" unique="true"/> <property column="user_gelar" name="user_gelar" type="string"/> <property column="user_type" name="user_type" not‐null="true" type="string"/> <property column="user_cv" name="user_cv" not‐null="true" type="text"/> <set cascade="delete" inverse="true" lazy="true" name="materis" table="materi"> <key> <column name="user"/> </key> <one‐to‐many class="entity.Materi"/> </set> <set cascade="delete" inverse="true" lazy="true" name="images" table="images"> <key> <column name="user"/> </key> <one‐to‐many class="entity.Images"/> </set> </class> </hibernate‐mapping> File glue.js: //=========================matkul===================================== jmaki.subscribe("/matkulTable/onSelect", function(args){ var title= args.value.title; var kode= args.value.kode; var sem= args.value.sem; var id= args.value.id; document.getElementById("sem").value=sem; document.getElementById("title").value=title; document.getElementById("kode").value=kode; document.getElementById("id").value=id; }); jmaki.subscribe("/buttonSave/onClick", function(args){ var val = document.getElementById("title").value;
var kode = document.getElementById("kode").value; var sem = document.getElementById("sem").value; var valId = document.getElementById("id").value; if(val!=""){ if(valId!=""){ var row = { id : valId, title : val, kode:kode, sem:sem }; jmaki.doAjax({ method: "POST", url: "edit.jsp?title=" + val+"&kode="+kode+"&sem="+sem+"&id="+valId , callback: function(_req) { jmaki.publish('/jmaki/matkul/updateRow', { targetId: valId, value:row }); } }) } else{ jmaki.doAjax({ method: "POST", url: "add.jsp?title=" + val+"&kode="+kode+"&sem="+sem }) refreshPage(); } document.getElementById("id").value=""; document.getElementById("title").value=""; document.getElementById("kode").value=""; document.getElementById("sem").value=""; } else{ alert("Anda harus mengisi judul") } }); jmaki.subscribe("/buttonDelete/onClick", function(args){ var id = document.getElementById("id").value; if(id!=""){ if(confirm("Hapus data ?")){ document.getElementById("id").value=""; document.getElementById("title").value=""; document.getElementById("sem").value=""; document.getElementById("kode").value=""; jmaki.doAjax({ method: "POST", url: "delete.jsp?id=" + id, callback: function(_req) {
jmaki.publish('/jmaki/matkul/removeRow', { targetId: id }); } }) } } }); jmaki.subscribe("/buttonNew/onClick", function(args){ document.getElementById("kode").value=""; document.getElementById("title").value=""; document.getElementById("id").value=""; document.getElementById("sem").value=""; }); //=====================user========================================= jmaki.subscribe("/userTable/onSelect", function(args){ var fn= args.value.fn; var ln= args.value.ln; var email= args.value.email; var nip= args.value.nip; var gelar= args.value.gelar; var type= args.value.type; var pwd= args.value.pwd; var cv= args.value.cv; var id= args.value.id; document.getElementById("fn").value=fn; document.getElementById("ln").value=ln; document.getElementById("em").value=email; document.getElementById("nip").value=nip; document.getElementById("gelar").value=gelar; document.getElementById("pwd").value=pwd; document.getElementById("id").value=id; tinyMCE.execCommand('mceSetContent',false,cv); if (type == "1") { document.getElementById("type").options[1].selected = "true" } else{ document.getElementById("type").options[2].selected = "true" } }); jmaki.subscribe("/NewUser/onClick", function(args){ document.getElementById("id").value=""; document.getElementById("fn").value=""; document.getElementById("ln").value=""; document.getElementById("em").value=""; document.getElementById("nip").value=""; document.getElementById("gelar").value=""; document.getElementById("pwd").value=""; tinyMCE.execCommand('mceSetContent',false,""); document.getElementById("type").options[0].selected = "true";
}); jmaki.subscribe("/SaveUser/onClick", function(args){ var fn=document.getElementById("fn").value; var ln=document.getElementById("ln").value; var email=document.getElementById("em").value; var pwd=document.getElementById("pwd").value; var nip=document.getElementById("nip").value; var gelar=document.getElementById("gelar").value; var type=document.getElementById("type").value; var cv = tinyMCE.get('FCKxeditor1').getContent() ; var id= document.getElementById("id").value; if((fn!="")&(ln!="")){ if(id!=""){ var row = { id : id, fn : fn, ln : ln, email : email, nip : nip }; jmaki.doAjax({ method: "POST", url: "edit.jsp?fn=" + fn+"&cv="+cv+"&ln="+ln+"&em="+email+"&nip="+nip+"&gelar="+gelar+"&type="+type+"&id="+id+"&act=1" , callback: function(_req) { jmaki.publish('/jmaki/user/updateRow', { targetId: id, value:row }); } }) } else{ jmaki.doAjax({ method: "POST", url: "add.jsp?fn=" + fn+"&cv="+cv+"&ln="+ln+"&em="+email+"&pwd="+pwd+"&nip="+nip+"&gelar="+gelar+"&type="+type }) } } document.getElementById("fn").value=""; document.getElementById("ln").value=""; document.getElementById("em").value=""; document.getElementById("nip").value=""; document.getElementById("pwd").value=""; document.getElementById("gelar").value=""; tinyMCE.execCommand('mceSetContent',false,"");
document.getElementById("type").options[0].selected = "true" document.getElementById("id").value=""; refreshPage(); }); jmaki.subscribe("/SaveTutor/onClick", function(args){ var fn=document.getElementById("fn").value; var ln=document.getElementById("ln").value; var email=document.getElementById("em").value; var pwd=document.getElementById("pwd").value; var pwd2=document.getElementById("pwd2").value; var nip=document.getElementById("nip").value; var gelar=document.getElementById("gelar").value; var type=document.getElementById("type").value; var id= document.getElementById("id").value; var cv = tinyMCE.get('FCKxeditor1').getContent(); if(pwd2!=""){ if(pwd==pwd2){ jmaki.doAjax({ method: "POST", url: "edit.jsp?fn=" + fn+"&cv="+cv+"&ln="+ln+"&em="+email+"&pwd="+pwd+"&pwd="+pwd2+"&nip="+nip+"&gelar="+gelar+"&type="+type+"&id="+id+"&act=1" }) document.getElementById("fn").value=fn; document.getElementById("ln").value=ln; document.getElementById("em").value=email; document.getElementById("nip").value=nip; document.getElementById("pwd").value=pwd; document.getElementById("gelar").value=gelar; document.getElementById("type").value = type; document.getElementById("id").value=id; }else{ alert("password tidak sesuai"); } }else{ jmaki.doAjax({ method: "POST", url: "edit.jsp?fn=" + fn+"&cv="+cv+"&ln="+ln+"&em="+email+"&pwd="+pwd+"&pwd="+pwd2+"&nip="+nip+"&gelar="+gelar+"&type="+type+"&id="+id+"&act=1" }) document.getElementById("fn").value=fn; document.getElementById("ln").value=ln; document.getElementById("em").value=email; document.getElementById("nip").value=nip; document.getElementById("pwd").value=pwd; document.getElementById("gelar").value=gelar; document.getElementById("type").value = type; document.getElementById("id").value=id;
} }); jmaki.subscribe("/DeleteUser/onClick", function(args){ var id = document.getElementById("id").value; if(id!=""){ if(confirm("Hapus data ?")){ document.getElementById("fn").value=""; document.getElementById("ln").value=""; document.getElementById("em").value=""; document.getElementById("nip").value=""; document.getElementById("pwd").value=""; document.getElementById("gelar").value=""; tinyMCE.execCommand('mceSetContent',false,""); document.getElementById("type").options[0].selected = "true" document.getElementById("id").value=""; jmaki.doAjax({ method: "POST", url: "delete.jsp?id=" + id, callback: function(_req) { jmaki.publish('/jmaki/user/removeRow', { targetId: id }); } }) } } }); jmaki.subscribe("/ResetPwdUser/onClick", function(args){ var id = document.getElementById("id").value; var nip =document.getElementById("nip").value; if(id!=""){ jmaki.doAjax({ method: "POST", url: "edit.jsp?id=" + id+"&act=3&nip="+nip }) } }); //========================upload file================================= jmaki.subscribe("/materiTableUploadFile/onSelect", function(args){ var id= args.value.id; document.getElementById("id").value=id; updateDivUploadFile(id); }); function updateDivUploadFile(id){ jmaki.doAjax({ method: "POST", url: "form.jsp?id="+id, callback: function(_req) { document.getElementById("content").innerHTML = _req.responseText; }
}) } jmaki.subscribe("/userTableImage/onSelect", function(args){ var id= args.value.id; document.getElementById("id").value=id; updateDivUploadFileImage(id); }); function updateDivUploadFileImage(id){ jmaki.doAjax({ method: "POST", url: "form_image.jsp?id="+id, callback: function(_req) { document.getElementById("content").innerHTML = _req.responseText; } }) } //==========================materi======================================== jmaki.subscribe("/newMateri/onClick", function(args){ tinyMCE.execCommand('mceSetContent',false,""); document.getElementById("id").value=""; document.getElementById("title").value=""; document.getElementById("course").value=""; document.getElementById("tutor").value=""; }); jmaki.subscribe("/materiTable/onSelect", function(args){ var content= args.value.content; var title= args.value.title; var tutorId= args.value.tutorId; var courseId= args.value.courseId; var id= args.value.id; tinyMCE.execCommand('mceSetContent',false,content); document.getElementById("id").value=id; document.getElementById("title").value=title; updateDivMateri(courseId,tutorId); }); jmaki.subscribe("/saveMateri/onClick", function(args){ var id= document.getElementById("id").value; var tutor= document.getElementById("tutor").value; var course= document.getElementById("course").value; var title= document.getElementById("title").value; var content = tinyMCE.get('FCKxeditor1').getContent() ; if(id!=""){ var row = { id : id, tutor : tutor, course : course, title : title };
jmaki.doAjax({ method: "POST", url: "edit.jsp?tutor=" + tutor+"&course="+course+"&content="+content+"&title="+title+"&id="+id , callback: function(_req) { jmaki.publish('/jmaki/materi/updateRow', { targetId: id, value:row }); } }) } else{ jmaki.doAjax({ method: "POST", url: "add.jsp?tutor=" + tutor+"&course="+course+"&content="+content+"&title="+title }) } document.getElementById("id").value=""; document.getElementById("title").value=""; document.getElementById("course").value=""; document.getElementById("tutor").value=""; tinyMCE.execCommand('mceSetContent',false,""); refreshPage(); }); jmaki.subscribe("/deleteMateri/onClick", function(args){ var id = document.getElementById("id").value; if(id!=""){ if(confirm("Hapusx data ?")){ tinyMCE.execCommand('mceSetContent',false,""); document.getElementById("id").value=""; document.getElementById("title").value=""; document.getElementById("course").value=""; document.getElementById("tutor").value=""; jmaki.doAjax({ method: "POST", url: "delete.jsp?id=" + id, callback: function(_req) { jmaki.publish('/jmaki/materi/removeRow', { targetId: id }); } }) } } }); function updateDivMateri(courseId,tutorId){ jmaki.doAjax({ method: "POST", url: "selectorMateri.jsp?courseId="+courseId+"&tutorId="+tutorId, callback: function(_req) {
document.getElementById("selectorMateri").innerHTML = _req.responseText; } }) } //========================Login========================================= jmaki.subscribe("/Login/onClick", function(args){ var nip=document.getElementById("login_name").value; var pwd=document.getElementById("login_password").value; jmaki.doAjax({ method: "POST", url: "login.jsp?nip=" + nip+"&pwd="+pwd }) });
Frontend Pages: lectures.jsp <%@ page import="dao.DAO" %> <%@ page import="dao.DAOKuliah" %> <%@ page import="dao.DAOUser" %> <%@ page import="entity.AdException" %> <%@ page import="entity.User" %> <%@ page import="entity.Kuliah" %> <%@ page import="java.util.Iterator" %> <%@ page import="java.util.List" %> <%@ page import="dao.DAOMatkul" %> <%@ page import="entity.Matkul" %> <%@ taglib prefix="a" uri="http://jmaki/v1.0/jsp" %> <!DOCTYPE html PUBLIC "‐//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1‐transitional.dtd"> <html> <head> <link rel="stylesheet" href="jmaki‐standard.css" type="text/css"></link> <title>Lectures</title> <meta http‐equiv="Content‐Type" content="text/html; charset=UTF‐8" /> </head> <body> <div id="outerBorder"> <%@ include file="header.jsp" %> <% try { List users = new DAOUser().listForTutor(); Iterator ci = users.iterator(); while (ci.hasNext()) { User user = (User) ci.next(); String id = Long.toString(user.getUser_id()); Iterator ai = user.getMateris().iterator(); if (ai.hasNext()) { out.print("<div id='level1'><img src='images/arrow.png' width='9'/>" + "<a href='lecture.jsp?id=" + id + "'>" + user.getUser_namaDepan() + " " + user.getUser_namaBelakang() + "</a><br /></div>"); } } DAO.close(); } catch (AdException e) { System.out.println(e.getMessage()); } %> </div> <!‐‐ main ‐‐>
</div> <!‐‐ outerborder ‐‐> </body> </html> course.jsp: <%@ page import="dao.DAO" %> <%@ page import="dao.DAOMatkul" %> <%@ page import="entity.AdException" %> <%@ page import="entity.Matkul" %> <%@ page import="java.util.Iterator" %> <%@ page import="java.util.List" %> <%@ taglib prefix="a" uri="http://jmaki/v1.0/jsp" %> <!DOCTYPE html PUBLIC "‐//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1‐transitional.dtd"> <html> <head> <link rel="stylesheet" href="jmaki‐standard.css" type="text/css"></link> <title>Courses</title> <meta http‐equiv="Content‐Type" content="text/html; charset=UTF‐8" /> </head> <body> <div id="outerBorder"> <%@ include file="header.jsp" %> <% try { List matkuls = new DAOMatkul().list(); Iterator ci = matkuls.iterator(); while (ci.hasNext()) { Matkul matkul = (Matkul) ci.next(); String id = Long.toString(matkul.getMatkul_id()); Iterator ai = matkul.getMateris().iterator(); if (ai.hasNext()) { out.print("<div id='level1'><img src='images/arrow.png' width='9'/>" + "<a href='subjectListByCourse.jsp?id=" + id + "'>" + matkul.getMatkul_title() + "</a><br></div>"); } } DAO.close(); } catch (AdException e) { System.out.println(e.getMessage()); } %> </div> <!‐‐ outerborder ‐‐> </body> </html>
subject.jsp: <% String idx = request.getParameter("id"); if ((idx == null) || (idx.equalsIgnoreCase(""))) {%> <jsp:forward page="index.jsp"/> <% } %> <%@ page import="dao.DAO" %> <%@ page import="dao.DAOMateri" %> <%@ page import="dao.DAOFile" %> <%@ page import="entity.AdException" %> <%@ page import="entity.Materi" %> <%@ page import="entity.Matkul" %> <%@ page import="entity.File" %> <%@ page import="java.util.Iterator" %> <%@ page import="java.util.List" %> <%@ page import="dao.DAOMatkul" %> <%@ page import="entity.Matkul" %> <%@ page import="java.io.*" %> <%@ taglib prefix="a" uri="http://jmaki/v1.0/jsp" %> <!DOCTYPE html PUBLIC "‐//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1‐transitional.dtd"> <html> <head> <link rel="stylesheet" href="../jmaki‐standard.css" type="text/css"></link> <title>Subject</title> <meta http‐equiv="Content‐Type" content="text/html; charset=UTF‐8" /> </head> <body> <div id="outerBorder"> <div id="header"> <div id="banner"><img src="../images/UIN_logo.jpg" width="100" alt="UIN_logo"/> </div> </div> <div id="main"> <div id="menu"> <a href="../lectures.jsp">Lectures</a> | <a href="../course.jsp">Courses</a><br /> </div> <% String id = request.getParameter("id"); String Courseid = request.getParameter("Courseid"); try { Materi materi = new DAOMateri().get(id); out.println("<b>" + materi.getTitle() + "</b><br />"); out.print(materi.getContent() + "<br /><br /><br /><b>Attachment(s):</b><br />"); Iterator ai = materi.getFiles().iterator(); while (ai.hasNext()) { File files = (File) ai.next();
if (files.getFile_type().equalsIgnoreCase("2")) { out.print("<img src='../images/arrow.png' width='9'/>" + "<a href='../upload/files/" + files.getFile_path() + "'>" + files.getFile_path() + "</a><br>"); } } DAO.close(); } catch (AdException e) { System.out.println(e.getMessage()); } %> </div> <!‐‐ main ‐‐> <div id="related"> <b>Materi lain dari Dosen ini:</b><br /> <% Matkul matkul = new DAOMatkul().get(Courseid); Iterator ai = matkul.getMateris().iterator(); while (ai.hasNext()) { Materi advert = (Materi) ai.next(); if (advert.getMateri_id() != Integer.parseInt(id)) { out.print("<div id='subject_list'><img src='../images/arrow.png' width='9'/>" + "<a href='subject.jsp?id=" + advert.getMateri_id() + "&Courseid=" + Courseid + "'>" + advert.getTitle() + "</a>"); out.println("<br /> Tutor : " + advert.getUser().getUser_namaDepan() + "<br><br></div>"); } } DAO.close();%> </div> <!‐‐ related ‐‐> </div> <!‐‐ outerborder ‐‐> </body> </html>
UNIVERSITAS ISLAM NEGERI (UIN)
SYARIF HIDAYATULLAH JAKARTA
Jln. Ir. H. Juanda No. 95 Ciputat 15412 Telp. (021) 7402982, Fax. (021) 7402982, website : www.uinjkt.ac.id, email : [email protected]
NIM : 105091002893
I. DATA PRIBADI
Nama : Aditya Prasetio Tempat Tgl. Lahir : Jakarta, 3 November 1987 Jenis Kelamin : Laki-Laki Agama : Islam Warga Negara : Indonesia Negara Asal : Indonesia
Alamat Asal : Jl. Petogogan I/22 RT 005/05 Gandaria Utara Keb. Baru Jakarta Selatan
Kode Pos : 12240 E-mail : [email protected] Telepon/HP : 081319960703 Asal sekolah SMA : MA. Darunnajah Asal Propinsi SMA : Jakarta Jurusan : IPA Alamat Sekolah : Jl. Ulujami Raya No. 86 Keb. Lama Jak-Sel NEM : 20.84 Email : SDA IPK (terakhir) : 2.91
II. DATA KELUARGA
Nama Ayah : Achmad Soeharto Pekerjaan : - Pendidikan Terakhir : STM Nama Ibu : Sri Kadariyah Pekerjaan : - Pendidikan Terakhir : SMP Alamat Sekarang : -
Kode Pos : - Telepon : - Penghasilan : - Orang Tua/Wali : Syamsuddin
III. JENJANG PROGRAM : S1 IV. STATUS PROGRAM : Reguler V. PILIHAN FAKULTAS/PROGRAM STUDI
Fakultas : Fakultas Sains & Teknologi Program Studi : Teknik Informatika
Foto 3 x 4 Terbaru Pas photo
PENGEMBANGAN APLIKASI CONTENT MANAGEMENT SYSTEM UNTUK MOBILE LEARNING BAGI PENGAJAR BERBASIS JAVA
Aditya Prasetio
Fakultas Sains dan Teknologi Universitas Islam Negeri Syarif Hidayatullah Jakarta
Tel : (021) 823026 Fax : (021) 8624025 Email : [email protected]
ABSTRAK
Selama satu dekade terakhir, dunia pendidikan dan pelatihan sangat dipengaruhi oleh perkembangan teknologi. Fenomena ini akan semakin menguat mengingat teknologi ke depan akan semakin kompleks, powerfull, dan terjangkau secara ekonomi. Sebagai contoh paling populer, internet kini sudah menjadi kebutuhan penting bagi siapa pun yang terlibat dalam aktifitas pendidikan dan pelatihan, baik sebagai media maupun sumber belajar.
Pada penelitian sebelumnya setiap aplikasi hanya terbatas pada satu pelajaran saja sehingga pengguna memerlukan aplikasi berbeda pada setiap pelajaran. Disamping itu pengguna harus mengunduh aplikasi tersebut ke handphone mereka, hal ini membuat content menjadi statis.
Oleh karena itu, dirasa perlu untuk memngembangkan aplikasi mobile learning yang memiliki content dinamis. Adapun metodologi yang penulis gunakan dalam membuat aplikasi ini adalah menggunakan RAD, yang mempunyai lima tahapan, yaitu Communication, Planning, Modelling, Construction, dan Deployment. Penulis menggunakan bahasa pemrogaman Java, Framework Jmaki untuk AJAX, ORM Hibernate dan database MySQL dalam membuat aplikasi ini. Dengan adanya aplikasi ini maka akan mempermudah pengajar dalam memberikan materi belajar maupun soal latihan tanpa terbatas oleh ruang dan waktu sehingga diharapkan dapat meningkatkan efektifitas dalam belajar.
Kata Kunci: Mobile learning, Content Management System, web dinamis, RAD.
1. PENDAHULUAN 1.1. Latar Belakang
Pada penelitian sebelumnya setiap aplikasi hanya terbatas pada satu pelajaran saja sehingga pengguna memerlukan aplikasi berbeda pada setiap pelajaran. Disamping itu pengguna harus mendownload aplikasi tersebut ke
handphone mereka, hal ini membuat content menjadi statis.
Berdasarkan content yang masih statis, maka penulis mengembangkan sebuah Content Management System untuk mengisi materi, agar content aplikasi dapat disesuaikan dengan kebutuhan dan tidak terbatas dengan satu mata pelajaran saja. Aplikasi yang
penulis kembangkan tidak membatasi pembelajar untuk mengakses content pembelajaran apapun yang ada, dengan demikian pambelajar dapat leluasa mendapatkan materi belajar. Untuk mengakses aplikasi yang penulis kembangkan pengguna cukup menggunakan web browser pada telepon genggam mereka.
. 1.2. Rumusan Masalah
Masalah yang dapat dirumuskan dalam tugas akhir ini sebagai berikut :
1. Bagaimana mengembangkan sebuah aplikasi Content Management Sistem untuk mobile learning yang diperlukan bagi pengajar.
2. Bagaimana membuat aplikasi web Content Management Sistem untuk mobile learning yang dapat diakses melalui telepon genggam.
1.3. Batasan Masalah
Agar pembahasan mengenai topik ini tidak terlalu meluas maka diperlukan batasan masalah. Adapun batasan masalah untuk skripsi ini antara lain:
1. Mobile learning berperan sebagai pendamping untuk sistem belajar yang ada.
2. Pengguna memerlukan handphone memiliki mobile browser untuk mengakses sistem ini.
3. Pengajar memiliki hak untuk menambah isi materi yang sesuai dengan bidang yang diajarnya.
4. File yang diperbolehkan untuk diupload adalah file berformat .doc, .docx, ppt, pptx, xls, xlsx .pdf, .flv, dan MP3.
5. Pembelajar hanya bisa melihat materi yang telah dimasukkan oleh pengajar serta mendownload file.
6. Pembelajar bebas memilih materi
apa saja yang ada pada aplikasi m-Learning, tidak terbatas oleh kelas dan semester yang diikutinya.
7. Bagian yang dapat diakses dengan handphone hanya pada frontend, sedangkan bagian beckend diakses dengan komputer atau laptop.
8. M-Learning akan dibangun menggunakan teknologi Java 1.5 dengan IDE Netbeans 6.7.1.
1.4. Tujuan dan Manfaat Penelitian
Penelitian yang penulis lakukan bertujuan untuk:
1. Tujuan 1. Untuk mempermudah
pengajar dalam memberikan materi belajar maupun soal latihan tanpa terbatas oleh ruang dan waktu sehingga diharapkan dapat meningkatkan efektifitas dalam belajar.
Manfaat yang di dapatkan dalam penelitian ini adalah :
1. Memberikan independensi waktu dan tempat pada pengguna dalam memberikan materi belajar dan soal latihan kepada pembelajar.
2. Berguna sebagai tambahan dalam belajar bagi pembelajar.
1.5. Metodologi Penelitian
Metode Penelitian yang penulis gunakan adalah sebagai berikut :
1. Pengumpulan data a. Wawancara Teknik yang penulis gunakan dalam memperoleh data adalah dengan cara mengajukan pertanyaan-pertanyaan kepada Kepala Pusat Data Teknik
informatika Fakultas Sains dan Teknologi (PUSDATIN FST). b. Studi Pustaka Mengumpulkan data dan informasi dengan cara membaca dan mempelajari buku-buku literatur referensi serta situs-situs internet yang berkenaan dengan topik yang dapat dijadikan acuan pembahasan dalam penelitian ini.
1. Metode Pengembangan Perangkat Lunak (Software Development Method) Metode pengembangan perangkat lunak yang penulis gunakan adalah SDLC (System Development Live Cycle) model linear sequencial yang sering disebut RAD (Rapid Application Development). Tahapannya adalah sebagai berikut : 1 Communication. 2. Planning. 3. Modelling. 4. Construction (Implementation). 5. Deployment
1.6. Sistematika Penelitian Penelitian ini terdiri dari lima bab,
dengan penjelasan tiap-tiap bab sebagai berikut : BAB I : PENDAHULUAN Pada bab ini berisi tentang Latar Belakang, Rumusan Masalah, Batasan Masalah, Tujuan dan Manfaat Penelitian, Metodologi Penelitian serta Sistematika Penulisan Penelitian. BAB II: LANDASAN TEORI Pada bab ini menjelaskan tentang teori perangkat keras dan perangkat lunak, definisi sistem, analisa sistem, definisi
perancangan sistem dan jenis program yang digunakan. BAB III: Metodologi Penelitian Pada bab ini akan menguraikan dan memberikan penjelasan mengenai perancangan perangkat lunak, perancangan sistem sehingga dapat diketahui rencana yang akan dikerjakan. BAB IV: Pembahasan dan Implementasi Pada bab ini akan menjelaskan mengenai pembuatan sistem dan pengujian sistem. BAB V: Penutup Bab ini berisi kesimpulan dari pembahasan masalah dan saran-saran berkenaan dengan penelitian ini.
2. LANDASAN TEORI 2.1. Pengembangan Sistem
Pengembangan sistem yaitu menyusun sistem yang baru untuk menggantikan sistem yang lama secara keseluruhan atau perbaikan pada sistem yang telah ada dengan harapan bahwa sistem yang baru dapat mengatasi sistem yang lama. (Mcleod, J., 1996).
Pengembangan sistem dapat berarti menyusun suatu sistem yang baru untuk menggantikan sistem yang lama secara keseluruhan atau memperbaiki sistem yang telah ada.
Dengan telah dikembangkannya sistem yang baru, maka diharapkan akan terjadi peningkatan-peningkatan ini antara lain:
1. Performance (Kinerja), yaitu terjadi peningkatan terhadap kinerja (hasil kerja) sistem yang baru sehingga menjadi lebih efektif.
2. Throughput, yaitu jumlah dari pekerjaan yang dapat dilakukan suatu saat tertentu.
3. Control (pengemdalian), yaitu peningkatan terhadap pengendalian untuk mendeteksi dan memperbaiki kesalahan-kesalahan serta kecurangan-kecurangan yang akan terjadi.
Service (pelayanan), bagaimana peningkatan terhadap pelayanan yang diberikan oleh sistem.
2.2. Mobile Learning (m-Learning) Mobile learning (m-Learning) adalah penggunaan teknologi wireless mobile yang memungkinkan pengaksesan informasi dan meteri belajar kapanpun dan dimanapun. Dengan demikinan, pembelajar memiliki control penuh atas tempat dan waktu untuk belajar. Semua manusia memiliki hak yang sama dalam mengakses informasi dan materi belajar untuk meningkatkan kualitas mereka terlepas dari asal, status, dan budaya mereka (Mohamed. 2009: 1).
2.2.1. Mobile Learning Berbasis Web
Mobile learning berbasis web memiliki standard content yang dapat diakses melalui web browser pada mobile devices yang dijelaskan oleh W3C Mobile Web Initiative (MWI) yang merupakan sebuah kolaborasi industri dan teknologi yang bertujuan untuk meningkatkan produksi content web dan akses untuk pengguna mobile (Low.2007:20). Mobile Web Best Practices 1.0 (W3C 2006a) adalah spesifikasi standard dan contoh praktek dari mobile web-based content (Low.2007:20). Berikut adalah garis besar
rekomendasi yang dikeluarkan oleh W3C (W3C 2006a). Dibawah rekomendasi dari Default Delivery Context, content untuk mobile web bisa saja melebihi rekomendasi ini jika content dirancang untuk diakses oleh perangkat yang berspesifikasi tinggi (Low.2007:21).
2.3. Content Management System
(CMS)
Content Management System (CMS) adalah sebuah aplikasi berbasis web yang memiliki system sedemikian rupa hingga memberikan kemudahan kepada para pengguna sekaligus juga pengelolanya (Rachdian, 2005:4).
Content Management System (CMS) memiliki serangkaian prosedur yang digunakan untuk mengatur alur kerja. Prosedur-prosedur ini dapat bersifat manual maupun berbasis compute. Prosedur-prosedur ini didesain untuk:
1. Memungkinkan sejumlah orang untuk berkontribusi dan memasukkan data.
2. Mengontrol akses data, sesuai dengan perannya.
3. Memudahkan penyimpanan dan penerimaan data.
Pada sebuah CMS, content yang diatur bersifat industri spesifik. Sebagai contoh, content multimedia akan berbeda dengan desain dokumen untuk pesawat jet. Banyak terminologi yang mengaturnya. Beberapa contoh yang umum digunakannya CMS antara lain Web Content
Management, Digital Asset Management, Digital Records Management, Electronic Content Management, dan Mobile Content Management, Learning Management System.
2.3.1. Learning Management
System (LMS) Learning Management System adalah system manajemen pembelajaran berbasis web yang memungkinkan pengajar untuk mengakses dan mendistribusikan materi belajar. Sistem ini juga memungkinkan murid untuk melakukan aktifitas belajar seperti mengakses konten dan materi yang dibuat oleh pengajar (Niazi, 2008: 3). Dengan learning management system, pengajar yang berperan sebagai pengelola konten belajar dapat membuat, dan mempublikasikan materi belajar kepada siswa-siswanya.
2.4. JAVA
Java ditemukan oleh James Gosling, Patrick Naughton, Chris Warth, Ed Frank, dan Mike Sheridan dibawah Sun Microsystem, Inc pada 1991. Membutuhkan 18 bulan untuk mengembangkan versi pertamanya. Bahasa pemrograman ini awalnya diberi nama Oak tapi kemudian diganti Java pada 1995. Diantara implementasi awal dari Oak pada 1992 dan berganti nama menjadi Java pada 1995, banyak orang yang berkontribusi dalam desain dan evolusinya. Bill Joy, Arthur van Hoff, Jonathan Payne, Frank Yellin, dan Tim Lindholm adalah
kontributor kunci dalam proses pendewasaan dari prototype awal (Naughton, Patrick. 1999: 10).
Java sendiri memiliki beberapa edisi untuk berbagai keperluan pengembang perangkat lunak yaitu J2SE, J2EE, J2ME, dan yang terakhir adalah JavaFX.
Sebuah profile memberikan library tambahan untuk suatu kelas tertentu pada sebuah perangkat. profile-profile menyediakan user interface (UI) API, persistence, messaging library, dan sebagainya.
2.5. Hibernate 3
Bauer dan King (2005:2) menjelaskan Hibernate adalah framework yang memediasi interaksi aplikasi dengan database, dengan demikian developer dapat berkonsentrasi pada komponen logika bisnis. Dengan hibernate pengembang tidak perlu mengikuti semua aturan dan disain hibernate ketika membuat logika bisnis dan kelas-kelas. Hibernate tidak saja melakukan pemetaan kelas Java ke tabel database, tapi juga menyediakan fasilitas untuk query dan data retrieval dan secara signifikan mempersingkat waktu pengembangan dibandingkan dengan data handling secara manual pada SQL dan JDBC. Tujuan Hibernate adalah untuk membebas tugaskan pengembang dari tugas-tugas persisten data (Bauer. 2003:1).
2.6. Framework jMaki jMaki adalah framework ringan untuk membuat aplikasi Web centric 2.0 menggunakan tata letak CSS, widget-widget model, penangan JavaScript, dan proxy generik untuk berinteraksi dengan web eksternal RESTful web services. jMaki mengabstraksi JavaScript dan CSS dengan menyediakan widget default, widget JavaScript dan CSS yang dibuat mudah diakses sehingga bisa dikustomisasi oleh perancang. jMaki berfokus pada aspek memberikan JavaScript untuk memungkinkan klien untuk berkomunikasi dengan berbagai teknologi server-termasuk PHP, Java (JSP / JSF), dan Phobos dalam teknologi-server cara netral.
2.7. Database MySql 5.1.30 MySQL merupakan Open Source SQL database yang paling popular, MYSQL dibuat oleh MySQL AB. MySQL AB adalah sebuah perusahaan komersil yang menyediakan servis seputar database MySQL (MySQL Reference Manual. MySQL AB , 2001, pp.2).
MySQL merupakan sebuah relational database management system, yang menyimpan data pada tabel yang terpisah, hal ini dapat meningkatkan kecepatan dan fleksibilitas. Tabel-tabel tersebut kemudian dihubungkan melalui relasi-relasi tertentu sehingga memungkinkan untuk mengkombinasikan data dari berbagai tabel sesuai dengan permintaan, melalui SQL yang telah menjadi bahasa standar yang umum untuk mengakses database.
2.8. Sekilas tentang NetBeans 6.7.1 NetBeans IDE adalah sebuah integrated development environment (IDE) untuk menulis, meng-compile, testing, dan debugging aplikasi untuk platform Java maupun bahasa pemrograman lain. Netbeans IDE memiliki text editor, perangkat disain visual, source code management, integrasi dengan database, integrasi dengan server, dan lain-lain.
2.9. Unit Testing
Unit testing berfokus pada verifikasi di unit terkecil dari disain perangkat lunak. Menggunakan disain component-level sebagai penunjuk, control path yang penting akan dites untuk mendapatkan error di dalam batas modul. Kompleksitas dari pengujian tergantung pada batas yang ada untuk unit testing. Unit test berorientasi pada white-box testing, dan langkahnya dapat dijalankan secara parallel pada komponen yang berlainan. (Pressman, 2002:485). Ketika pemrograman object oriented digunakan, maka konsep dari unit berubah. Setiap class dan objek memiliki data dan operasi (methods) yang memanipulasi data-data ini. Unit testing tidak lagi dilakukan pada modul-modul terpisah, tetapi dilakukan pada class atau objek. Hal ini dikarenakan sebuah kelas bisa memiliki sejumlah operasi berbeda dan beberapa operasi tersebut dapat berada pada kelas-kelas yang berbeda, artinya unit testing berubah secara dramatis (Pressman, 2002:664). Kita tidak dapat lagi melakukan test pada satu operasi secara terpisah melainkan dilakukan sebagai bagian dari kelas. Berikut adalah ilustrasinya, sebuah superclass yang memiliki
operasi X yang diturunkan pada sejumlah subclasses. Maka setiap subclasses akan menurunkan operasi X . Dikarenakan operasi X tersebut digunakan oleh beberapa kelas, maka Unit test pada operasi X harus dilakukan pada subclasses.
2.10. System Testing System testing adalah serangkaian test yang bertujuan untuk menguji system secara keseluruhan. Meskipun setiap test memiliki tujuan yang berbeda, namun seluruh tahapan dilakukan dengan terintegrasi (Pressman, 2002:525). Berikut ini adalah serangkaian test yang termasuk dalam system testing.
2.11. Disain Antar Muka Antar muka pada aplikasi berbasis web adalah kesan pertama. Terlepas dari isi, kepuasan pelayanan, dan keseluruhan keuntungan dari aplikasi tersebut, disain yang kurang baik akan membuat User meninggalkan web tersebut (Pressman, 2005:813). Pressman menyebutkan ada beberapa faktor yang harus diperhatikan dalam mendisain website:
a. Menu navigasi harus konsisten dan harus tersedia di setiap halaman yang bisa diakses oleh User
b. Menu navigasi harus terlihat jelas oleh User. User tidak perlu mencari link untuk menuju ke halaman yang mereka kehendaki. Keindahan hendaknya tidak menggantikan fungsionalitas. Contoh, tombol yang sederhana lebih baik daripada tombol dengan gambar atau icon yang maksudnya tidak jelas.
2.12. Rapid Applications Development (RAD) Model RAD adalah sebuah metode pengembangan sistem yang menggunakan perencanaan minimal dan mengutamakan kecepatan. Tahap perencanaan dalam RAD berada pada fase panulisan kode software itu sendiri. Pengurangan porsi perencanaan secara umum membuat penulisan kode program lebih cepat, dan mudah beradaptasi pada perubahan (Pressman, 2005:82).
3. METODOLOGI PENELITIAN 3.1. Metode Pengumpulan Data
3.1.1 Wawancara Penulis menggunakan teknik wawancara langsung, yaitu dengan cara mengajukan pertanyaan-pertanyaan langsung kepada Kepala Pusat Data Teknik informatika Fakultas Sains dan Teknologi (PUSDATIN FST) dalam hal kebutuhan akan aplikasi yang penulis buat.
3.1.2 Studi Pustaka a) Membaca dan mempelajari
buku-buku atau dokumen-dokumen. Dokumen atau buku yang termasuk didalamnya yaitu buku-buku, artikel, dan jurnal yang berhubungan dengan dan m-learning. Dokumen - dokumen tersebut bisa bersifat hardcopy ataupu softcopy yang bersumber dari internet. Dapat dilihat di daftar pustaka.
b) Dokumen- dokumen yang telah dikumpulkan kemudian dipilih dan dihimpun berdasarkan tujuan dan fokus penelitian. Dapat dilihat di daftar pustaka.
c) Dokumen-dokumen yang telah dipilih dan himpun kemudian diurutkan sesuai dengan urutan kronologis, kekuatan, dan kesesuaian. Dapat dilihat di daftar pustaka.
d) Dilakukan analisis untuk mendapatkan suatu pemahaman mengenai konsep perancangan web aplikasi untuk mengakomodir m-learning. Dapat dilihat di daftar pustaka.
3.1.3 Studi Sejenis Dalam hal ini, penulis membaca dan memahami literatur ilmiah yang sejenis dengan penulis.
3.2. Alat dan Bahan
Adapun peralatan yang digunakan dibagi dua, yaitu :
1. Perangkat Keras a. CPU (Central Processing Unit)
CPU merupakan pusat pengolahan dan juga pusat pengontrolan dari sebuah sistem komputer yang saling melaksanakan kegiatan. Spesifikasi yang penulis gunakan adalah sebagai berikut:
1) Processor intel core i3 2.13 Ghz
2) Harddisk 320 GB 3) DDR RAM 1,7 GB 4) VGA on board Intel Graphics
media accelerator b. Keyboard
Keyboard adalah alat input yang biasanya didampingi dengan alat tampilan (display) di layar monitor yang menampilkan apa yang ditekan di keyboard.
c. Mouse
Mouse adalah alat input komputer yang digunakan oleh berbagai program aplikasi GUI (Graphical User Interface) dengan petunjuk posisi yang ditampilkan melalui monitor.
2. Perangkat Lunak a) Sistem Operasi
Sistem operasi yang penulis sarankan adalah Microsoft Windows XP SP2.
b) Program aplikasi Merupakan perangkat lunak yang akan digunakan dalam pembuatan program adalah server Apache Tomcat 5.5.17, J2SE 1.5, NetBeans IDE 6.7.1, MySql 5.
3.3. Metode Pengembangan Sistem a. Communication Pada tahap ini, penulis melakukan analisis untuk mengetahui permasalahan yang terjadi, sehingga dapat diketahui informasi yang harus diakomodasi oleh aplikasi yang akan dibuat.
b. Planning Pada tahap ini, penulis melakukan
perencanaan yaitu dengan membuat timeline.
c. Modelling
Yang penulis lakukan pada tahap ini adalah sebagai berikut
1. Membuat Use Case Diagram 2. Membuat Entity Relational
Diagram 3. Membuat Kamus data. 4. Merancang Antar Muka aplikasi.
d. Construction Diketahui juga sebagai tahap pembuatan atau pembangunan. Pada tahap ini dilakukan :
a. Implementasi antar muka.
b. Unit Testing.
c. System testing.
4. PEMBAHASAN
4.1. Communication
Pada tahap ini, penulis melakukan analisis untuk mengetahui permasalahan yang terjadi, sehingga dapat diketahui informasi yang harus diakomodasi oleh aplikasi yang akan dibuat. Secara rinci yang penulis lakukan pada tahap analisis kebutuhan adalah :
1. Analisis Kebutuhan User. 2. Alat dan Bahan.
4.2. Planning Pada tahap ini, penulis melakukan
perencanaan yaitu dengan membuat timeline untuk memudahkan dan mengarahkan penulis dalam melakukan pembuatan sistem.
4.3. Modelling
Pada tahap ini, penulis melakukan pemodelan informasi, interface yang akan dipergunakan, dan data yang diperlukan selama penggunaan aplikasi. Secara rinci, yang penulis lakukan pada tahap ini adalah sebagai berikut 1. Membuat Use Case Diagram 2. Membuat Entity Relational Diagram 3. Membuat Kamus data. 4. Merancang Antar Muka aplikasi.
4.4. Construction
Diketahui juga sebagai tahap pembuatan atau pembangunan. Pada tahap ini dilakukan :
a. Implementasi antar muka. b. Unit Testing.
Unit Testing adalah proses eksekusi program yang bertujuan untuk menemukan error. Unit
Testing yang dilakukan pada tugas akhir ini dengan menggunakan JUnit.
c. System testing. a. Recovery Testing
Pada tahap ini Penulis membuat beberapa keadaan yang memaksa aplikasi gagal beroperasi. Hal ini dilakukan untuk memastikan proses pemulihan berjalan dengan baik.
b. Security Testing Penulis melakukan Security Testing menggunakan HP Scrawler 1.0. Software ini melakukan crawl pada aplikasi yang penulis kembangkan dan secara simultan melakukan analisa untuk kemungkinan serangan SQLInjection pada setiap halaman.
c. Stress Testing Pada tahap ini Penulis menggunakan WAPT 6.0. Penulis membebankan aplikasi menggunakan 500 looping pada satu waktu yang sama untuk menguji kemampuan system ketika berada mendapat beban berat.
d. Performance Testing Pada tahap ini Penulis menggunakan software WAPT. Penulis melakukan testing yang sama dengan tahap Stress Testing, tetapi kali ini penulis menggunakan 20 looping pada 20 User untuk melihat performa aplikasi dalam keadaan normal.
5. KESIMPULAN 5.1. Kesimpulan
Setelah melakukan pengetesan terhadap aplikasi yang telah dibuat dan menyelesaikan penelitian ini. Dapat ditarik kesimpulan sebagai berikut:
1. Dengan mengembangkan aplikasi mobile learning berbasis web, pengguna tidak memerlukan aplikasi khusus untuk menggunakan aplikasi ini.
2. Berdasarkan pengujian yang dilakukan oleh pengguna, dengan adanya fasilitas-fasilitas untuk mengupdate content, aplikasi memiliki content yang dinamis karena content dapat diisi sesuai dengan kebutuhan pengajar.
3. Berdasarkan pengujian yang dilakukan oleh penulis, aplikasi mobile learning ini dapat berjalan sesuai dengan tujuan, analisis, dan desain yang telah dirancang, sehingga aplikasi ini dapat membantu pembelajar dalam aktifitas belajar..
5.2. Saran Berikut ini beberapa saran yang mungkin berguna untuk digunakan sebagai bahan pertimbangan yang ingin melakukan penelitian atau aplikasi yang hampir sama,
1. Disarankan adanya media player untuk file multimedia sehingga dapat dibuka dengan cara streaming.
2. Aplikasi ini belum dapat menyimpan hasil yang didapat mahasiswa setelah mengerjakan soal. Disarankan adanya penyimpanan nilai bagi mahasiswa yang telah mengerjakan soal-soal.
Daftar Pustaka
Ally , Mohamed. 2009. Mobile Learning Transforming the Delivery of Education
and Training. Edmonton: AU Press.
Bauer , Christian And King , Gavin. 2005. Java Persistence with Hibernate. New York: Manning Basaeed, Essa and Berri, Jawad.2007. Learner-Centric Context-Aware Mobile
Learning.
Jogiyanto, H.M. 2008. Metodologi Penelitian Sistem Informasi. Yogyakarta: Andi Offset.
Kineo and UFI. 2009. Mobile Learning Reviewed. UK
Low , Leonard.2007. M-learning standards report. Canberra MySQL Reference Manual. 2001. MySQL AB
Naik, Kshirasagar And Tripathy, Priyadarshi. 2008. Software Testing And Quality Assurance Theory and Practice. New Jersey: A johnwiley & sons, inc., publication.
Naughton , Patrick and Schildt, Herbert . 2001. Java 2: The Complete Reference. California:Osborne/McGraw-Hill
Niazi , Razieh and Qusay H.
Mahmoud. 2008. Design and Development of a Device-Independent System for Mobile
Learning. IEEE Education Society Students Activities Committee
Pressman, Roger S. 2001. Software
Engineering: A Practitioner's Approach. New York: McGraw-Hill. 2005. Software Engineering: A Practitioner’s Approach. New York: Mc-Graw Hill.
Rachdian , Adhi. 2005 Mastering
CMS dengan Mambo/ Joomla. Jakarta: PT. Elex Media Komputindo.
Stieglitz , Stefan and Fuchß, Christoph.2007. Mobile Learning by Using Ad Hoc Messaging Network.
APPLICATION DEVELOPMENT CONTENT MANAGEMENT SYSTEM FOR MOBILE LEARNING FOR JAVA-BASED Teachers
Aditya Prasetio
Faculty of Science and Technology
State Islamic University Syarif Hidayatullah Jakarta
Tel : (021) 823026 Fax : (021) 8624025 Email : [email protected]
ABSTRACT
Over the last decade, the education and training is strongly influenced by developments in technology. This phenomenon will become stronger given the technology in the future will be more complex, powerful, and economically affordable. The most popular example, the Internet has now become an important requirement for anyone involved in education and training activities, both as media and learning resources.
In a previous study of each application is limited to just one lesson so that the user requires a different application on each lesson. Besides, users must download the applications to their mobile phone, it makes the content into static.
Therefore, it is necessary to develope mobile learning applications that have dynamic content. The methodology that I use in making this application is the RAD, which has five stages, namely Communication, Planning, Modeling, Construction, and Deployment. The author uses the Java programming language, JMaki Framework for AJAX, Hibernate ORM and MySQL database in making this application. With this application it will be easier for teachers in providing learning materials and practice questions without limited by space and time so it is expected to increase effectiveness in learning.
Keywords: Mobile Learning, Content Management System, dynamic web, RAD.
1. INTRODUCTION 1.1 Background
In a previous study of each application is limited to just one lesson so that the user requires a different application on each
lesson. Besides, users must download the applications to their mobile phone, it makes the content into static. Based on the content was static, the authors developed a Content
Management System to fill material, so content can be tailored to the needs of the application and not limited to one subject only. Applications that do not restrict the authors develop the learners to access any existing learning content, thus pambelajar can freely obtain learning materials. To access the authors developed an application that users can simply use a web browser on their mobile phone.
1.2 Problem Formulation Problems that can be formulated in this thesis as follows: 1. How to develop an application Content Management System for mobile learning is necessary for teachers. 2. How to create a web application Content Management System for mobile learning which can be accessed via mobile phones.
1.3 Limitation Problem In order for the discussion of this topic is not too widespread it is necessary to limit the problem. The boundary problem for this thesis include: 1. Mobile learning acts as a companion to existing learning systems. 2. Users need a mobile phone has a mobile browser to access this system. 3. Teachers have the right to increase the content of the material in accordance with the field that was teaching. 4. Files that are allowed to be uploaded is the file format. Doc,. Docx, ppt, pptx, xls, xlsx. Pdf,. Flv, and MP3.
5. Learners can only see material that has been entered by the teacher for and download files. 6. Learners are free to choose whatever materials are on m-Learning applications, not limited by class and the semester that followed. 7. The part that can be accessed by mobile phone only on the frontend, while the beckend accessed by a computer or laptop. 8. M-Learning will be built using Java 1.5 with NetBeans IDE 6.7.1.
1.4 Objectives and Benefits Research Research Methodology Research conducted by the author aims to: 1.Goal
To facilitate teachers in providing learning materials and practice questions without limited by space and time so it is expected to increase effectiveness in learning.
The benefit is in getting in this study are:
1. Giving independence to the user's time and place in providing learning materials and practice questions to the learner. 2. Useful as an extra in learning for the learner.
1.5 Systematics Research Research Methods I use are as follows: 1. Data collection a. Interview The technique I use in obtaining data is by asking questions to the Head of Data Engineering Informatics Faculty of Science and
Technology (FST PUSDATIN). b. Library Studies Collecting data and information by reading and studying literature, reference books and Internet sites related to topics that can be used as reference for discussion in this study. 1. Software Development Methods (Software Development Method) software development method which writer use is SDLC (System Development Live Cycle) sequencial linear model is often called RAD (Rapid Application Development). Stages are as follows: 1 Communication. 2. Planning. 3. Modelling. 4. Construction (Implementation). 5. Deployment.
1.6 Systematics Research This study consists of five chapters, with explanations of each chapter as follows: CHAPTER I: INTRODUCTION This chapter contains the Background, Problem Formulation, Limitation of Issues, Objectives and Benefits of Research, Research Methodology and Writing Systematic Research. CHAPTER II: THEORY BASIS This chapter describes the theory of hardware and software, system definition, system analysis, system design definition and type of program used. CHAPTER III: Research Methodology
In this chapter will describe and give an explanation about software design, system design so that it can be seen that the plan will be undertaken. CHAPTER IV: Discussion and Implementation In this chapter will explain about the making of the system and test system. CHAPTER V: Conclusion This chapter contains the conclusion of the discussion of problems and suggestions regarding this research.
2. BASIS THEORY
2.1 System Development Development of the system is compiling a new system to replace the old system as a whole or repairs on existing systems in the hope that the new system can overcome the old system. (McLeod, J., 1996). Development means the system can compile a new system to replace the old system as a whole or improve existing systems. With it has developed a new system, it is expected that there will be improvements include: 1.Performance (Performance), which is an increase on performance (the work) a new system to become more effective. 2. Throughput, ie the number of jobs that can be done a certain time. 3. Control , namely the increase of controls to detect and correct these mistakes and fraud that will occur. Service (service), how the improvement of services provided by the system.
2.2 Mobile Learning (m-Learning) Mobile learning (m-Learning) is the use of mobile wireless technology that allows access to information and learning materials anytime, anywhere. Thus, learners have full control over the place and time to learn. All human beings have equal rights in accessing information and learning materials to improve their quality regardless of origin, status, and their culture (Mohamed. 2009: 1). 1. Web-Based Mobile Learning
Mobile learning has a standard web-based content that can be accessed through a web browser on mobile devices described by the W3C Mobile Web Initiative (MWI), which is a collaboration of industry and technology that aims to enhance web content production and access for mobile users (Low.2007: 20). Mobile Web Best Practices 1.0 (W3C 2006a) is a standard specification and practice examples of web-based content (Low.2007: 20). Here is an outline of the recommendations issued by the W3C (W3C 2006a). Under the recommendation of the Default Delivery Context, content for the mobile web could have exceeded this recommendation if the content is designed to be accessed by the device high specification (Low.2007: 21).
2.3 Content Management System (CMS) Content Management System (CMS) is a web-based application
that has a system in such a way as to provide convenience to the users as well as managers (Rachdian, 2005:4). Content Management System (CMS) has a series of procedures used to manage workflow. These procedures can be either manually or based compute. These procedures are designed to: 1. Allows a number of people to contribute and enter data. 2. Controlling access to data, in accordance with its role. 3. Facilitate storage and receiving data. In a CMS, content is subject to specific industries. For example, multimedia content will vary with the design documents for the plane jet. Many terms that govern them. Some common examples include the use of CMS Web Content Management, Digital Asset Management, Digital Records Management, Electronic Content Management, and Mobile Content Management, Learning Management System. 1. Learning Management
System (LMS). Learning Management System is a web-based learning management system that allows teachers to access and distribute learning materials. This system also allows students to perform learning activities such as accessing content and material created by teachers (Niazi, 2008: 3). With the learning management system, teachers who act as managers of learning content to
create, and publish learning materials to students.
2.4 JAVA Java invented by James Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan under Sun Microsystems, Inc. in 1991. Require 18 months to develop the first version. Programming language was originally named Oak Java but later replaced in 1995. Among the initial implementation of Oak in 1992 and changed its name to Java in 1995, many people who contributed in the design and evolution. Bill Joy, Arthur van Hoff, Jonathan Payne, Frank Yellin, and Tim Lindholm were key contributors in the process of maturation of the initial prototype (Naughton, Patrick. 1999: 10). Java itself has several editions for different purposes ie software developers J2SE, J2EE, J2ME, and the last is JavaFX. A profile provides additional libraries for a particular class on a device. profile-profile provides a user interface (UI) API, persistence, messaging libraries, and so forth.
2.5 Hibernate 3 Bauer and King (2005:2) describes Hibernate is a framework that mediates interactions with the database application, so developers can concentrate on business logic components. With hibernate developer does not need to follow all the rules and design of hibernate when creating the business logic and classes.
Hibernate not only to map Java classes to database tables, but also provides the facility to query and data retrieval and significantly shorten development time compared with manual data handling in SQL and JDBC. Hibernate goal is to free developers from assigned duties persistent data (Bauer. 2003:1).
2.6 JMaki Framework jMaki is a lightweight framework for creating Web applications centric 2.0 uses CSS layout, widget-widget model, JavaScript handlers, and generic proxy to interact with external RESTful web services web. jMaki abstracts JavaScript and CSS to provide default widget, widget JavaScript and CSS are made easily accessible so that it can be customized by the designer. jMaki focuses on the aspect of giving JavaScript to enable clients to communicate with various server-technologies including PHP, Java (JSP / JSF), and Phobos in server-technology neutral way.
2.7 Database MySql 5.1.30 MySQL Open Source SQL database is the most popular, MYSQL made by MySQL AB. MySQL AB is a commercial company that provides services around the MySQL database (MySQL Reference Manual. MySQL AB, 2001, pp.2). MySQL is a relational database management system, which stores data in separate tables, this can increase the speed and flexibility. The tables are then connected via certain relations making it possible
to combine data from multiple tables in accordance with the request, via SQL which has become a common standard language for accessing databases.
2.8 Overview of NetBeans 6.7.1 NetBeans IDE is an integrated development environment (IDE) for writing, compiling, testing, and debugging applications for the Java platform as well as other programming languages. Netbeans IDE has a text editor, visual design tools, source code management, integration with databases, integration with the server, and others.
2.9 Unit Testing Unit testing focuses on verifying the smallest unit of software design. Using component-level design as a bookmark, an important control paths will be tested to get an error in the module boundary. The complexity of testing depends on the existing boundary for unit testing. Oriented unit tests on white-box testing, and steps can be run in parallel on different components. (Pressman, 2002:485). When the object-oriented programming is used, then the concept of the unit changed. Each class and object has its data and operations (methods) that manipulate this data. Unit testing is no longer done in separate modules, but done in class or object. This is because a class can have a number of different operations and some operations may be in different classes, meaning changed dramatically unit testing (Pressman, 2002:664).
We can no longer perform tests on a single operation carried out separately but as part of the class. Here is the illustration, a superclass that have derived X operating on a number of subclasses. Then any subclasses will lose X operation. Due to the operation of X were used by several classes, then the test unit in operation should be performed on the X subclasses.
2.10 System Testing System testing is a series of tests aimed to test the system as a whole. Although each test has different goals, but all done with an integrated phase (Pressman, 2002:525). Here is a series of tests that are included in the testing system.
2.11 Interface Design Interface on a web-based application is the first impression. Regardless of content, service satisfaction, and overall benefits of the application, which is not good design will make users leave the web (Pressman, 2005:813). Pressman said there are several factors that should be considered in designing the website: a. Menu navigation should be consistent and should be available on every page that can be accessed by users. b. The navigation menu should be clearly visible to users. Users do not need to find a link to go to the page they want. The beauty should not replace the functionality. For example, a simple button better than the button with a picture or icon that means it is not clear.
2.12 Rapid Applications Development (RAD)
The RAD Model is a system development method that uses minimal planning and prioritizing speed. The planning phase in RAD is in the phase of writing software code itself. Reducing the portion of the general plan to make writing code more quickly, and easily adapt to change (Pressman, 2005:82).
3. RESEARCH METHODOLOGY 3.1 Data Collection Method
3.1.1 Interviews The author uses the direct interview technique, that is by asking questions directly to the Head of Data Engineering Informatics Faculty of Science and Technology (PUSDATIN FST) in terms of the need for applications that writers make.
3.1.2 Literature Study a) Read and study the books or documents. Document or book that includes books, articles and journals that relate to and m-learning. The document - the document can be hardcopy ataupu softcopy sourced from the internet. Can be seen in the bibliography. b) Documents which have been collected are then selected and compiled based on the purpose and focus of research. Can be seen in the bibliography. c) The documents that have been selected and gather then sorted according to chronological order, strength, and suitability. Can be seen in the bibliography.
d) Analysis to gain an understanding of the concept of designing a web application to accommodate the m-learning. Can be seen in the bibliography.
3.1.3 Related Studies In this case, the authors read and understand the scientific literature that is similar to the author.
3.2 Tools and Materials The equipment used was divided in two, namely: 1. Hardware
a. CPU (Central Processing Unit) CPU is the central processing and control center of a computer system that conducts each other. Specification that I use are as follows: 1) Processor Intel core I3 2.13 Ghz. 2) Hard Drive 320 GB 3) 1.7 GB DDR RAM 4) VGA on board Intel Graphics media accelerator b. Keyboard The keyboard is an input device that is usually accompanied by the display device (display) on a monitor that displays what is pressed on the keyboard. c. Mouse Mouse is the computer input devices used by any software application GUI (Graphical User Interface) with instructions displayed on the monitor position.
2. Software a) Operating System
The operating system that the authors suggest, is Microsoft Windows XP SP2.
b) The application program Is a software that will be used in making program is the server Apache Tomcat 5.5.17, J2SE 1.5, NetBeans IDE 6.7.1, MySql 5.
3.3 Systems Development Method a. Communication
At this stage, the authors analyzed to determine the problems that occur, so that can know the information that must be accommodated by the application to be made.
b. Planning At this stage, the authors do plan is to create a timeline.
c. Modelling Which writers do at this stage are as follows
1. Creating Use Case Diagrams 2. Creating Entity Relational
Diagram 3. Creating a data dictionary. 4. Designing an application
interface.
d. Construction Known also as a stage of manufacture or construction. In this stage: a. Implementation of the
interface. b. Unit Testing. c. System testing.
4. DISCUSSION
4.1 Communication At this stage, the authors analyzed to determine the problems that occur, so that can know the information that must be accommodated by the application to be made. In detail, the authors do on stage is a needs analysis:
1. User Needs Analysis. 2. Equipment and Materials.
4.2 Planning At this stage, the authors do plan is to create a timeline to facilitate and lead author in conducting the manufacture of the system.
4.3 Modelling At this stage, the author of information modeling, an interface that will be used, and the data required for application usage. In detail, the authors do at this stage are as follows 1. Creating Use Case Diagrams 2. Creating Entity Relational Diagram 3. Creating a data dictionary. 4. Designing an application interface.
4.4 Construction Known also as a stage of manufacture or construction. In this stage: a. Implementation of the interface. b. Unit Testing. Unit Testing is the process of execution of the program that aims to find errors. Unit Testing is done on this thesis by using JUnit. c. System testing.
a. Recovery Testing At this stage the author makes some circumstances that force the
application fails to operate. This is done to ensure the recovery process goes well. b. Security Testing The authors perform Security Testing using HP Scrawler 1.0. This software do the crawl on the application that the author developed and simultaneously analyzed for a possible attack SQLInjection on every page. c. Stress Testing At this stage I use WAPT 6.0. Writer charged with 500 loop applications at one time the same to test the ability of the system when they are getting a heavy load. d. Performance Testing At this stage the author uses the software WAPT. The authors do the same testing with stress testing phase, but this time the author uses 20 loops on 20 User to view the performance of applications under normal circumstances.
5. CONCLUSION
5.1.Conclusion After testing of applications that have been made and completed the study. It can be deduced as follows: 1. By developing a web-based learning mobile applications, users do not need a special application to use this application. 2. Based on testing performed by the user, given the facilities to update the content, the application has dynamic content because the content can be filled in accordance with the needs of teachers.
3. Based on testing performed by the author, mobile learning applications can be run in accordance with the objectives, analysis, and design that have been designed, so this application can help learners in learning activities.
5.2. Suggestion Here are some suggestions that may be useful to use as material considerations that would like to do research or similar application, 1. It is suggested the existence of a media player for multimedia files that can be opened with the way streaming. 2. This application has not been able to save the results obtained after the students do the problems. It is recommended the storage of value for students who have been working on the questions.
Bibliography Ally, Mohamed. 2009. Mobile Learning is Transforming the Delivery of Education and Training. Edmonton: AU Press. Bauer, Christian And King, Gavin. 2005. Java Persistence with Hibernate. New York: Manning Basaeed, Essa and Berri, Jawad.2007. Learner-Centric Context-Aware Mobile Learning. Jogiyanto, H.M. 2008. Research Methods in Information Systems. Yogyakarta: Andi
Offset. Kineo and UFI. 2009. Mobile Learning reviewed. UK Low, Leonard.2007. M-learning standards report. Canberra MySQL Reference Manual. 2001. MySQL AB Naik, Kshirasagar And Tripathy, Priyadarshi. 2008. Software Testing And Quality Assurance Theory and Practice. New Jersey: A johnwiley & sons, inc., Publication. Naughton, Patrick and Schildt, Herbert. 2001. Java 2: The Complete Reference. California: Osborne / McGraw-Hill Niazi, Razieh and Qusay H. Mahmoud. 2008. Design and Development of a Device-Independent System for Mobile Learning. IEEE Education Society Students Activities Committee Pressman, Roger S. 2001. Software Engineering: A Practitioner's Approach. New York: McGraw-Hill. 2005. Software Engineering: A Practitioner's Approach. New York: Mc-Graw Hill. Rachdian, Adhi. 2005 Mastering the CMS with Mambo / Joomla. Jakarta: PT. Elex Media Komputindo. Stieglitz, Stefan and Fuchß, Christoph.2007. Learning by Using Mobile Messaging Ad Hoc Network.