Selamat menulis ilmiah

Karena lagi malas ngoprek , saya rename saja direktori user profile pada LibreOffice. Caranya adalah sebagai berikut. Cari direktori .libreoffice/3 di home folder Anda, misalnya

cd /home/hudan/.libreoffice/3

Lalu rename folder user dan jalankan kembali LibreOffice. Aplikasi office ini akan membuat direktori baru untuk user profile kita.

mv user user.old

Sudah begitu saja

Lalu di mana letak cache browser Google Chrome ini? Di laptop saya, di sini lokasinya: /home/hudan/.cache/google-chrome/Default/Cache. Coba lihat di folder Home Anda masing-masing. Karena harus mengakses folder yang hidden, kita harus mengaktifkan menu “Show hidden files” terlebih dulu. Menu ini bisa diaktifkan dengan memilih View > Show Hidden Files pada Nautilus atau tekan Ctrl + H.

Penasaran? Atau sudah tahu? Haha… Blog ini sebagai pengingat saja kalau lupa

Akhirnya saya browsing lagi, dan menemukan source code zlib di sini. Selanjutnya, saya print file zlib.h dan zconf.h. Saya baca satu per satu baris source code-nya. Dan ternyata? Enggak paham . Selanjutnya, saya coba print juga RFC untuk zlib ini (RFC 1950). Setelah dibaca-baca, sering disinggung-singgung juga metode deflate dan gzip. Akhirnya, saya print juga RFC 1951 untuk deflate dan RFC 1952 untuk gzip. Selain itu, sepertinya saya juga harus membaca kembali buku fundamental bahasa pemrograman C klasik, sudah banyak sintaks yang lupa . Official site zlib bisa juga diakses di sini.

Kesimpulannya? Ya tidak ada cara lain selain dibaca RFC, manual, dan source code untuk memahami pustaka dasar yang digunakan untuk kompresi di protokol HTTP ini. Have a nice Tuesday!

Kita akan membuat sebuah perhitungan aritmetika sederhana (kita coba penjumlahan saja) seperti yang dijelaskan di tulisan sebelumnya. Namun, akan ada sedikit modifikasi yaitu operasi ini dilakukan di arsitektur client-server. Client akan mengirim dua operand dan server akan memproses dan mengirim hasil perhitungan ke client.

Langkah-langkahnya secara ringkas adalah sebagai berikut:

1. Client mengirim dua operand
2. Server menerima dua operand
3. Server melakukan parsing dua operand ini
4. Server melakukan perhitungan dan mengirim hasilnya ke client

Kita mulai dari client terlebih dulu. Agar input dua operand ini bersifat dinamis, maka kita akan memanfaatkan teknik mendapatkan argumen value di Python. Selanjutnya, client akan mengirim dua operand yang masih direpresentasikan dalam satu string ini ke server (perhatikan bahwa di sini dua operand masih digabung menjadi satu string, belum dipisah)

#!/usr/bin/env python
 
# mengimpor modul socket dan sys
import socket
import sys
 
# mendapatkan semua operand
operand = ' '.join(sys.argv[1:])
 
# menentukan alamat server
server_address = ('localhost', 5000)
 
# ukuran buffer ketika menerima pesan
SIZE = 1024
 
# membuat socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
# koneksi ke server
s.connect(server_address)
 
# mengirim operand ke server
s.send(operand)
 
# menerima hasil penjumlahan dari server
result = s.recv(SIZE)
 
# mencetak hasil penjumlahan dari server
print result
 
# menutup socket
s.close()

Operand yang dikirimkan ke server masih seperti ini: “2 3″. Sehingga, server harus memisahkannya (split) baru bisa dioperasikan. Proses mengolah atau memanipulasi data sebelum diproses lebih lanjut biasa disebut dengan parsing. Dalam contoh ini, parsing dilakukan untuk memisahkan dua operand yang masih berupa satu string “2 3″  menjadi “2″ dan “3″. Python menyediakan fungsi split yang sangat memudahkan kita melakukan pekerjaan ini. Mari kita mulai kode untuk server.

#!/usr/bin/env python
 
# mengimpor modul socket
import socket
 
# menentukan alamat server
server_address = ('localhost', 5000)
 
# ukuran buffer ketika menerima pesan
SIZE = 1024
 
# membuat objek socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
# bind ke alamat server
s.bind(server_address)
 
# mendengarkan koneksi dari client
s.listen(5)
 
# siap menerima pesan terus-menerus dari client
while 1:
	# menerima koneksi dari client
	client, client_address = s.accept()
 
	# menerima pesan dari client
	message = client.recv(SIZE)
 
	# jika tidak ada pesan, keluar dari while
	if not message:
		break
 
	# parsing operand
	operand = message.split()
	operand1 = float(operand[0])
	operand2 = float(operand[1])
 
	# operasi penjumlahan
	result = operand1 + operand2
 
	# mengirimkan hasil penjumlahan ke client
	client.send(str(result))
 
# menutup socket
s.close()

Pesan dari client di-split dan return value dari proses split ini berupa list. By default, jika tidak diberikan input eksplisit, split dilakukan berdasarkan tanda spasi. Sehingga, operand1 dan operand2 bisa didapatkan dari return value split yang berupa list ini. Setelah itu, hasil penjumlahan dikonversi ke string agar bisa dikirim ke client (fungsi send dan recv hanya menerima string). Silakan langsung dicoba saja

Kita menjalankan sebuah script Python yang melakukan operasi penjumlahan dengan cara seperti ini

python penjumlahan.py

Kita bisa menambahkan argumen di belakang perintah tersebut, misalnya dua operand yang akan dijumlahkan

python penjumlahan.py 2 3

Bagaimana menangkap dua argumen tambahan (nilai 2 dan 3) di atas? Kita mengimpor modul sys terlebih dulu dan dilanjutkan dengan mengambil nilai argumen kemudian melakukan operasi penjumlahan

#!/usr/bin/env python
import sys

# mendapatkan nilai operand
operand1 = float(sys.argv[1])
operand2 = float(sys.argv[2])

# operasi penjumlahan dan cetak hasilnya ke layar
hasil_penjumlahan = operand1 + operand2
print hasil_penjumlahan

Argumen dikonversi ke float untuk mengonversi tipe data string ke float agar bisa dilakukan perhitungan (by default, argument value bertipe data string). Pada contoh di atas, sys.argv dimulai dengan indeks 1, ke mana indeks yang ke-0? Mari kita cek urutan indeks argument value ini

1. sys.argv[0] -> penjumlahan.py
2. sys.argv[1] -> 2
3. sys.argv[2] -> 3

Sudah jelas bukan? Silakan jalankan contoh di atas dengan perintah sebagai berikut

python penjumlahan.py 2 3

Sebenarnya, contoh di atas bisa kita persingkat lagi sehingga hanya menghasilkan beberapa baris. Coba simak contoh di bawah ini.

#!/usr/bin/env python
import sys

# mendapatkan nilai operand
operand1, operand2 = sys.argv[1:]

# cetak hasil operasi penjumlahan ke layar
print float(operand1) + float(operand2)

Indeks pada sys.argv ditunjukkan dengan [1:], artinya semua argument value dari indeks 1 sampai terakhir (ditunjukkan dengan tanda “:”) disimpan dalam variabel-variabel di ruas kiri (dua variabel yaitu operand1 dan operand2). Kemudian, konversi ke tipe data float  dilakukan pada saat operasi penjumlahan dan hasilnya langsung dicetak ke layar. Happy coding ^_^

Ada sebuah video menarik tentang bagaimana sebenarnya jaringan komputer bekerja. Sepertinya pemahaman tentang jaringan ini akan mempermudah kita dalam memprogram nantinya. Silakan dicek videonya di YouTube. Jadi YouTube bisa buat belajar juga lho, tidak cuma untuk melihat Shinta & Jojo, Nurman Kamaru, atau Ayu Ting Ting .

Oke, sebelum memprogram, kita harus tahu alur ceritanya dulu bukan? Begini ceritanya. Client akan mengirimkan sebuah pesan dengan tipe data string kepada server. Kemudian server akan menerimanya, kemudian mengirimkannya kembali ke client. Perhatikan bahwa di sini ada tiga proses utama: client mengirim, server menerima, dan server mengirim kembali pesan.

Mari kita mulai melihat proses utama dari sisi client terlebih dulu.

1. Pertama, client membuat objek socket terlebih dulu
2. Kedua, client mengoneksikan dirinya ke server
3. Baru kemudian melakukan proses mengirim (send) atau menerima (receive) pesan dari server

Oke, kita lihat program client sederhana ini.

#!/usr/bin/env python
 
# mengimpor modul socket
import socket
 
# menentukan alamat server
server_address = ('localhost', 5000)
 
# ukuran buffer ketika menerima pesan
SIZE = 1024
 
# membuat objek socket (proses pertama)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
# koneksi ke server (proses kedua)
s.connect(server_address)
 
# mengirim pesan ke server (proses ketiga)
s.send("Hi server ... ")
 
# menerima pesan dari server
message = s.recv(SIZE)
 
# mencetak pesan dari server
print message
 
# menutup socket
s.close()

Mari kita lihat satu per satu bagian program ini. Sebelumnya, ada catatan menarik tentang notasi “#!” di baris pertama program ini. Silakan disimak lebih lanjut di halaman Wikipedia ini. Tahap pertama adalah mengimpor modul socket. Modul ini digunakan untuk memanipulasi berbagai hal yang berkaitan dengan socket.

# mengimpor modul socket
import socket

Selanjutnya, adalah inisialisasi dua variabel yaitu alamat server (server_address) dan ukuran buffer (SIZE). Perhatikan bahwa alamat server dibuat dengan tipe data tuple.

# menentukan alamat server
server_address = ('localhost', 5000)
 
# ukuran buffer untuk menerima pesan
SIZE = 1024

Elemen pertama variabel server_address menunjukkan alamat server dengan tipe data string, sedangkan elemen kedua adalah port yang digunakan pada server dengan tipe data integer. “localhost” menunjukkan bahwa server berada di komputer yang sama dengan client. Jika alamat ini dikosongi seperti ini: “” , maka artinya sama dengan “localhost”. Nomor port dipilih sesuai dengan nomor port yang kosong di komputer Anda. Ukuran buffer mempunyai satuan byte. Anda bisa mengubahnya sesuai dengan kebutuhan. Bisa mulai dari 256, 512, 1024, 2048, dan seterusnya asalkan masih dalam kelipatan dua.

Proses selanjutnya adalah membuat objek socket. Ini adalah proses pertama yang merupakan bagian proses utama yang terjadi di sisi client.

# membuat objek socket (proses pertama)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

AF_INET adalah keluarga socket untuk komunikasi antara client dan server yang bisa berada di host yang sama atau berbeda. AF_INET hanya mendukung IPv4. Parameter kedua adalah SOCK_STREAM yang artinya adalah program ini menggunakan protokol TCP bukan UDP. Jika menggunakan UDP, maka parameternya adalah SOCK_DGRAM. Dokumentasi lengkap tentang socket bisa dilihat di sini. Di sisi client, s disebut dengan socket client.

Langkah selanjutnya adalah mengoneksikan client ke server.

# koneksi ke server (proses kedua)
s.connect(server_address)

Koneksi ke server dilakukan sesuai dengan alamat dan port yang telah didefinisikan sebelumnya. Perhatikan bahwa ini adalah proses kedua dari proses utama yang terjadi di sisi client. Setelah itu, client mengirim pesan ke server.

# mengirim pesan ke server (proses ketiga)
s.send("Hi server ... ")

Perhatikan juga bahwa ini adalah proses ketiga dari bagian proses utama pada client. Sintaks Python memang dirancang untuk mudah sekali dimengerti. Misalnya sintaks mengirim adalah send, sedangkan menerima sintaksnya adalah recv. Tidak ada alasan untuk susah mengerti sintaks Python bukan? .

Pesan yang diterima dari server disimpan di variabel message untuk selanjutnya dicetak.

# menerima pesan dari server
message = s.recv(SIZE)
 
# mencetak pesan dari server
print message

Terakhir adalah menutup socket yang telah digunakan.

# menutup socket
s.close()

Sampai di sini ada pertanyaan? Silakan post komentar atau mengirim ke email saya atau boleh juga ditanyakan di kelas .

Kita lanjutkan ke sisi server. Sedikit berbeda dengan client, program dari sisi server harus melakukan bind, listen, dan accept. Secara umum, proses utama yang terjadi di sisi server adalah sebagai berikut

1. Server membuat objek socket terlebih dulu
2. Bind ke alamat yang ditentukan
3. Mendengarkan (listen) apakah ada koneksi yang masuk
4. Menerima koneksi (accept) dari client
5. Menerima pesan dari client (recv)
6. Melakukan suatu proses
7. Mengirimkan hasil proses ke client (send)

Kita lihat dulu contoh programnya, baru kita cek satu per satu bagian programnya.

#!/usr/bin/env python
 
# mengimpor modul socket
import socket
 
# menentukan alamat server
server_address = ('localhost', 5000)
 
# ukuran buffer ketika menerima pesan
SIZE = 1024
 
# membuat objek socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
# bind ke alamat server
s.bind(server_address)
 
# mendengarkan koneksi dari client
s.listen(1)
 
# siap menerima pesan terus-menerus dari client
while 1:
	# menerima koneksi dari client
	client, client_address = s.accept()
 
	# menerima pesan dari client
	message = client.recv(SIZE)
 
	# jika tidak ada pesan, keluar dari while
	if not message:
		break
 
	# mengirimkan kembali pesan ke client
	client.send(message)
 
# menutup socket
s.close()

Di sisi server ini, program diawali dengan cara yang sama seperti di sisi client. Mulai dari impor modul socket, menentukan alamat server, menentukan ukuran buffer, dan membuat objek socket. Kita langsung ke bagian yang berbeda. Pertama adalah proses bind ke alamat dan port yang telah ditentukan

# bind ke alamat server
s.bind(server_address)

Istilah bind di sini bisa diartikan sebagai pengaturan alamat dan port server.  Jadi, alamat dan port yang telah dideklarasikan tersebut, “ditempelkan” pada objek socket server. Di sisi server, s disebut dengan socket server. Langkah selanjutnya adalah “mendengarkan” koneksi dari client.

# mendengarkan koneksi dari client
s.listen(1)

Terdapat satu parameter pada listen yang biasa disebut dengan backlog yang artinya adalah jumlah maksimum antrian koneksi. Karena di sini kita masih mencoba contoh yang sederhana, jadi kita set jumlah antriannya satu saja. Berikutnya adalah menerima koneksi dari client.

# menerima koneksi dari client
client, client_address = s.accept()

Return value dari accept ada dua yaitu objek socket client (ditunjukkan dengan variabel client) dan alamat client (variabel client_address). Jadi di sisi server, socket server ditunjukkan dengan variabel s dan socket client ditunjukkan oleh variabel client. Ingat-ingat konsep ini karena akan kita gunakan pada bagian berikutnya .

Berikutnya adalah server menggunakan infinite loop untuk menerima pesan dari client. Kemudian server mengirimkan pesan kembali ke client.

# siap menerima pesan terus-menerus dari client
while 1:
	# menerima pesan dari client
	message = client.recv(SIZE)
 
	# jika tidak ada pesan, keluar dari while
	if not message:
		break
 
	# mengirimkan kembali pesan ke client
	client.send(message)

Jika tidak ada lagi pesan yang diterima, maka keluar dari looping dan socket server ditutup.

# menutup socket
s.close()

Silakan langsung dicoba

Berikut ini adalah fungsi untuk menghitung operasi dasar aritmetika pada Python

def operasi(operand1, operand2):
	# operasi aritmetika dasar
	hasil_jumlah = operand1 + operand2
	hasil_kurang = operand1 - operand2
	hasil_kali = float(operand1) * float(operand2)
	hasil_bagi = float(operand1) / float(operand2)
 
	# menyusun return value
	hasil = []
	hasil.append(hasil_jumlah)
	hasil.append(hasil_kurang)
	hasil.append(hasil_kali)
	hasil.append(hasil_bagi)
 
	# memberikan return value
	return hasil

Kemudian, fungsi ini dipanggil dan return value-nya disimpan dalam sebuah variabel list juga. Kali ini variabel list boleh tidak dideklarasikan karena langsung mendapatkan nilai dari return value fungsi operasi. Sebuah list bisa diakses dengan cara seperti ini: nama_variabel[indeks]. Python masih menganut zero-based index, jadi indeks suatu tipe data secara default masih dimulai dari nol.

# pemanggilan fungsi
nilai = operasi(2, 3)
 
# mencetak hasil operasi
print "Hasil penjumlahan:", nilai[0]
print "Hasil pengurangan:", nilai[1]
print "Hasil perkalian  :", nilai[2]
print "Hasil pembagian  :", nilai[3]

Sehingga, secara keseluruhan fungsinya akan terlihat seperti di bawah ini.

def operasi(operand1, operand2):
	# operasi aritmetika dasar
	hasil_jumlah = operand1 + operand2
	hasil_kurang = operand1 - operand2
	hasil_kali = float(operand1) * float(operand2)
	hasil_bagi = float(operand1) / float(operand2)
 
	# menyusun return value
	hasil = []
	hasil.append(hasil_jumlah)
	hasil.append(hasil_kurang)
	hasil.append(hasil_kali)
	hasil.append(hasil_bagi)
 
	# memberikan return value
	return hasil
 
# pemanggilan fungsi
nilai = operasi(2, 3)
 
# mencetak hasil operasi
print "Hasil penjumlahan:", nilai[0]
print "Hasil pengurangan:", nilai[1]
print "Hasil perkalian  :", nilai[2]
print "Hasil pembagian  :", nilai[3]

Tipe data fungsi bisa saja berupa tuple, dictionary, atau tipe data yang lain. Jangan lupa perhatikan indentasi dari bagian program yang berupa fungsi dan bukan fungsi. Silakan langsung dicoba saja . Jika dijalankan, hasilnya adalah sebagai berikut.

Hasil penjumlahan: 5
Hasil pengurangan: -1
Hasil perkalian  : 6.0
Hasil pembagian  : 0.666666666667

Sebenarnya di Python program bisa saja ditulis secara sekuensial. Namun, kita juga bisa membuatnya menjadi modul-modul kecil dalam bentuk fungsi. Mari kita coba bandingkan satu per satu.

Kita akan membuat sebuah program sederhana operasi aritmetika dasar: penjumlahan, pengurangan, perkalian, dan pembagian dengan dua operand (bilangan yang dioperasikan). Pertama kita akan mencoba menulis program secara sekuensial pada scripting mode. Komentar di Python diawali dengan tanda “#”.

# deklarasi variabel operand
operand1 = 2
operand2 = 3
 
# operasi aritmetika dasar
hasil_jumlah = operand1 + operand2
hasil_kurang = operand1 - operand2
hasil_kali = operand1 * operand2
hasil_bagi = operand1 / operand2
 
# menampilkan hasil operasi
print "Hasil penjumlahan:", hasil_jumlah
print "Hasil pengurangan:", hasil_kurang
print "Hasil perkalian  :", hasil_kali
print "Hasil pembagian  :", hasil_bagi

Jika Anda menjalankan script ini di Linux, tambahkan satu baris seperti di bawah ini di awal script. Maksud dari perintah ini adalah environment yang digunakan untuk menjalankan atau mengeksekusi script ini adalah Python. Lihat ini atau ini untuk keterangan lebih lengkap.

#!/usr/bin/env python

Jalankan program pendek tersebut. Hasilnya akan seperti ini.

Hasil penjumlahan: 5
Hasil pengurangan: -1
Hasil perkalian  : 6
Hasil pembagian  : 0

Ada satu hasil yang aneh yaitu hasil pembagian. Bukankah seharusnya hasil 2/3 adalah 0.667 … ? Python tidak bisa mengoperasikan ini karena tipe data operand1 dan operand2 adalah integer, sehingga tidak menghasilkan float. Untuk bisa menghasilkan hasil yang diinginkan, kita harus melakukan casting tipe data dengan cara yang cukup sederhana. Ganti baris operasi hasil bagi dengan baris sebagai berikut:

hasil_bagi = float(operand1) / float(operand2)

Maka hasilnya sudah sesuai yang kita harapkan.

Hasil penjumlahan: 5
Hasil pengurangan: -1
Hasil perkalian  : 6
Hasil pembagian  : 0.666666666667

Lalu masalahnya adalah bagaimana jika kita harus menjalankan operasi ini sebanyak 5 kali, 10 kali, atau bahkan ratusan kali? Maka kita sebaiknya membuat fungsi. Bagaimana membuat fungsi? Secara umum, untuk membuat fungsi di Python adalah seperti ini.

def nama_fungsi(parameter1, parameter2, ...):
	operasi

Jangan lupa menyisipkan tanda “:” di akhir nama fungsi, dan baris program dalam operasi harus diindentasi sebanyak satu tab. Python adalah program yang sangat strict dalam hal indentasi. Bagian subprogram harus diindentasi increment (masuk ke dalam). Sedangkan untuk kembali ke subprogram sebelumnya, harus diindentasi sebaliknya (decrement). Kita akan mengenal ini sambil berjalan ngoprek Python.

Sekarang kita akan membuat fungsi untuk mengoperasikan aritmetika dasar yang sudah dicoba sebelumnya.

def operasi(operand1, operand2):
	# operasi aritmetika dasar
	hasil_jumlah = operand1 + operand2
	hasil_kurang = operand1 - operand2
	hasil_kali = float(operand1) * float(operand2)
	hasil_bagi = float(operand1) / float(operand2)
 
	# menampilkan hasil operasi
	print "Hasil penjumlahan:", hasil_jumlah
	print "Hasil pengurangan:", hasil_kurang
	print "Hasil perkalian  :", hasil_kali
	print "Hasil pembagian  :", hasil_bagi

Fungsi ini bisa dipanggil dengan cara sebagai berikut

operasi(2, 3)

Sehingga, program secara keseluruhan bisa disimak seperti di bawah ini

def operasi(operand1, operand2):
	# operasi aritmetika dasar
	hasil_jumlah = operand1 + operand2
	hasil_kurang = operand1 - operand2
	hasil_kali = float(operand1) * float(operand2)
	hasil_bagi = float(operand1) / float(operand2)
 
	# menampilkan hasil operasi
	print "Hasil penjumlahan:", hasil_jumlah
	print "Hasil pengurangan:", hasil_kurang
	print "Hasil perkalian  :", hasil_kali
	print "Hasil pembagian  :", hasil_bagi
 
operasi(2, 3)

Perhatikan bahwa penulisan pemanggilan fungsi mengalami decrease indent. Selamat mencoba!