Java Meets Ruby

Perbandingan kali ini dikutip dari salah satu buku yang cukup populer, yaitu From Java To Ruby karangan Bruce Tate. Sebelumnya, seperti apa deret fibonacci itu? Dari wikipedia diperoleh rumus berikut:



Sekarang bagaimana mengimpelemtasikan persamaan fungsi matematika tersebut ke dalam bahasa pemrograman? Contoh kasus kali ini adalah deret fibonacci untuk nilai n = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

# The Java Way:

class Fib {
  public static void main (String args[]) {
    int x = 0;
    int y = 1;
    int total = 1;
    for (int i=0; i<10; i++) {
      System.out.println(total);
      total = x+y;
      x = y;
      y = total;
    }
  }
}

# The Ruby Way

x, y = 0, 1
10.times do
  puts y
  x, y = y, x + y
end

Maka hasilnya, F(n) = 1, 1, 2, 3, 5, 8, 13, 21, 34, 55
Ini hanya untuk nilai n dari 1 hingga 10, dua program di atas berjalan baik - baik saja. Namun bila jumlah perulangan ditambah, yaitu untuk nilai n mulai dari 1 hingga nilai yang sangat besar, maka program Java di atas akan bermasalah sejak deret yang ke-48, yaitu terjadinya integer overflow. Kita tahu bahwa Java adalah bahasa statis yg tidak dapat serta merta instrospeksi diri. Sedangkan Ruby akan baik - baik saja, karena secara dinamis akan merubah diri dari Integer menjadi Bignum.

Further Reading:
From Java To Ruby karangan Bruce Tate

Mengembangkan suatu perangkat lunak secara TDD (Test-Driven Development) maupun BDD (Behaviour-Driven Development) memiliki seni tersendiri, dimana keduanya fokus pada testing.Autotest dapat meningkatkan produktivitas saat coding karena kita tidak terganggu dengan testing dan bisa mendapat feedback secara lebih cepat. Kita tidak perlu menjalankan test secara manual, test akan berjalan sendiri secara cerdas. So, kita bisa tetap asyik coding tanpa terganggu proses testing. Ketika terjadi kesalahan, tanpa disuruh pun autotest bakal langsung memberitahu. Hanya saja autotest berjalan di terminal, sehingga kita harus switch ke jendela terminal untuk melihat hasilnya. Tapi ada trik lain yang lebih cool, yaitu menggunakan nitification yang otomatis muncul setiap kali autotest memberi laporannya. Sistem operasi yang saya gunakan pada contoh ini adalah Ubuntu Hardy Heron

Hal yang harus dilakukan adalah:

Install Autotest

sudo gem install ZenTest

Ada dua alternatif cara yang saya tahu bisa digunakan, yaitu menggunakan Mumbles dan libnotify (khusus Gnome).

=== Menggunakan Mumbles ===

Mumbles ini mirip dengan Growl yang ada di Mac. Untuk instalasinya, Anda bisa mengunduh paket debian melalui alamat:
http://www.mumbles-project.org/download/
Setelah Anda install, maka mumbles akan muncul pada menu Application > Accessories > Mumbles.
Ketika mumbles telah berjalan, akan muncul ikon mumbles pada panel. Klik kanan pada ikon tersebut untuk melakukan konfigurasi.



Untuk mencoba kinerja mumbles, Anda dapat mengujinya melalui terminal. Ketik perintah:

mumbles-send 'Hello World' 'Katakan halo pada dunia'

Kemudian yang harus dilakukan adalah membuat file bernama .autotest yang diletakkan pada direktori $HOME Anda. Berikut isi dari file tersebut:

module Autotest::Mumbles
  def self.mumbles title, msg
    system "mumbles-send \"#{title}\" \"#{msg}\""
  end

  Autotest.add_hook :red do |at|
    errors = at.files_to_test.map { |k, v| "#{k}:\n #{v.join("\n ")}"}.join("\n\n")
    mumbles "TESTS FAILED", errors
  end

  Autotest.add_hook :green do |at|
    #res = at.results[/\d+ tests.*$/]
    res = at.results.scan(/Finished.*failures/m).to_s.gsub(/\e\[32m/,'')
    mumbles "TESTS PASSED", res
  end
end

Sekarang jalankan autotest, maka seharusnya mumbles akan menampilkan hasil test.



=== Menggunakan Gnome Notify ===

Ini adalah alternatif kedua, yaitu menggunakan libnotify milik Gnome. Pertama yang harus dilakukan adalah melakukan instalasi libnotify:

sudo apt-get install libnotify-bin

Kemudian buat file bernama .autotest pada direktori $HOME Anda. Berikut contoh isi dari file tersebut:

module Autotest::GnomeNotify

  # Time notification will be displayed before disappearing automatically
  EXPIRATION_IN_SECONDS = 5
  ERROR_STOCK_ICON = "gtk-dialog-error"
  SUCCESS_STOCK_ICON = "gtk-dialog-info"

  # Convenience method to send an error notification message
  #
  # [stock_icon]   Stock icon name of icon to display
  # [title]        Notification message title
  # [message]      Core message for the notification
  def self.notify stock_icon, title, message
    options = "-t #{EXPIRATION_IN_SECONDS * 1000} -i #{stock_icon}"
    system "notify-send #{options} '#{title}' '#{message}'"
  end

  Autotest.add_hook :red do |at|
    notify ERROR_STOCK_ICON, "Tests failed", "#{at.files_to_test.size} tests failed"
  end

  Autotest.add_hook :green do |at|
    notify SUCCESS_STOCK_ICON, "All tests passed, good job!", ""
  end

end

Sekarang jalankan autotest, maka seharusnya muncul notifikasi yang berisi hasil test yang telah berjalan.



Further reading:
http://dambalah.com/2008/10/07/autotest-notifications-in-ubuntu-with-mumbles/
http://ph7spot.com/articles/getting_started_with_autotest

"as real as it gets..." begitulah bunyi judulnya. Adalah seorang bernama wandaaa yang memuat karya kreatif ini. Berdasarkan keterangannya, karya ini dibuat untuk posternya software-asli.com.
agency : Bates141 Jakarta
creative director : Hendra Lesmono
art director : Andreas Junus & Irawandhani Kamarga
copywriter : Darrick Subrata
photgrapher : Anton Ismael

Benar-benar kreatif.. Dan tidak mengejutkan bila di Flickr foto ini mendapat response yang cukup luar biasa.

1. PC era (1980-1990)
Dalam dekade ini, konsentrasi tertuju penuh pada inovasi PC sebagai front-end (desktop & user interface layer). PC menjadi lebih mudah diguakan, mimpi untuk memiliki komputer di rumah menjadi kenyataan. Windows dan Machintos adalah dua nama besar dalam inovasi dan pengembangan user interface PC, dimana keduanya membuat UI yang konsisten dan juga integrasi antar aplikasi.

2. Web 1.0 (1990-2000)
Internet mulai booming, konsentrasi pengembangan berada pada back-end, yaitu core technology yang digunakan seperti HTTP, Web servers, search engines, commerce technologies, advertising technologies, dsb. Selain itu juga dikembangkan arsitektur dasar dan bisis model dari web applications.

3. Web 2.0 (2000-2010)
Konsentrasi pengembangan berpaling dari back-end menuju front-end. Inovasi yang terjadi kebanyakan bukanlah teknologi baru, namun berupa design pattern dan user-interface untuk meningkatkan kepuasan pengguna. Ada istilah "Everything old is new again". Ajax, social networking, merupakan contoh hasil ledakan web 2.0.

4. Web 3.0 (2010-2020)
Web 3.0 sudah sangat dekat dan diprediksi bakal fokus kembali ke masalah back-end. Diprediksi akan ada upgrade secara besar-besaran pada infrastruktur web secara teknis. Hal ini tidak lepas untuk mendukung teknologi semantic web. Pada dekade ini, web akan berfungsi menyerupai suatu basis data raksasa. Kita bisa melakukan query pada web layaknya pada basis data. Teknologi semantic web bukanlah sebuah web baru, melainkan layer tambahan pada web yang ada seperti saat ini.

5. Web 4.0 (2020-2030)
Pada dekade ini, diprediksi bahwa fokus akan kembali ke front-end, yaitu masalah user-interface. Sebagian besar pengguna menggunakan mobile device maupun embedded device. Mobile device memiliki ukuran layar yg bisa dibilang tidak selega saudaranya di desktop, inilah yang menjadi tantangan untuk membuat UI yang super produktif pada mobile device maupun embedded device. Mungkin sudah tidak lagi menggunakan text-box sebagai input, melainkan menggunakan input berupa suara. UI yag benar-benar berbeda dan cerdas.

Pada era web 2.0, java terlihat belepotan untuk masalah user interface. Kembali ke web 3.0 yang diprediksi bakal kembali fokus ke back-end, mungkin Java akan kembali menjadi "headline" pada web 3.0. Masalah back-end, teknologi Java sudah sagat tangguh. Dengan demikian kita bakal menjumpai inovasi-inovasi keren di bagian back-end, seperti semantic web, collective intelligence, dan artificial intelligence. Jika ketiganya digabungkan, maka web menjadi sangat cerdas dan muncul istilah "The Virtualization of Knowledge and Intelligence"

Further reading: Ebook gratis (legal) tentang Collective Intelligence da teknologi web lainnya

Kesuksesan web tidak lepas dari betapa solid-nya spesifikasi HTTP 1.1 (RFC-2145). HTTP cocok sekali untuk mengimplementasikan style REST. Belakangan ini Java dengan JSR-311 (JAX-RS) telah memiliki standar dalam implementasi REST, dan itu bagus sekali. Teknologi lainnya, Ruby on Rails sejak versi 1.2 telah mendukung REST (di sisi lain masih tetap mempertahankan SOAP), dan sejak versi 2.0 telah resmi "bercerai" dengan SOAP.

Seperti judulnya, pada posting kali ini kita akan membuat suatu service yang sangat sederhana, yaitu tentang televisi. Tentu saja layanan ini bersifat fiktif belaka dan tidak sepenuhnya memenuhi kriteria layanan world wide web. Namun disini kita hanya menekankan beberapa prinsip REST saja, yaitu Uniform Interface. Sebagaimana televisi konvensinal, maka:

1) Pengguna bisa menghidupkan TV
2) Pengguna bisa menyimpan channel TV ke dalam memory TV
3) Pengguna bisa mengubah channel TV untuk memilih siaran TV yang diinginkan
4) Pengguna bisa mengatur volume suara TV
5) Pengguna bisa mematikan TV

Dari daftar requirement di atas, maka kita bisa memodelkan resource TV, sbb:

1) /television/sessions
2) /television/channels
3) /television/volume

Kita memiliki tiga buah resources seperti disebutkan di atas. Jika anda termsuk orang yang teliti, mungkin anda akan bertanya: "Mengapa television dan volume adalah singular, sedangkan sessions dan channels adalah plural. Penulisan seperti ini hanyalah konvensi saja, television dan volume adalah singular karena kita asumsikan kita hanya memiliki satu buah television dan volume saja. Sedangkan kita asumsikan bahwa television memiliki banyak channels dan sessions, sehingga keduanya adalah plural.

Sekarang mari kita modelkan sistem kita untuk memenuhi requirement di atas:

1) Pengguna bisa menghidupkan TV
POST /television/sessions
2) Pengguna bisa menyimpan channel TV ke dalam memory TV
PUT /television/channels/{channel_number}
3) Pengguna bisa mengubah channel TV untuk memilih siaran TV yang diinginkan
GET /television/channels/{channel_number}
4) Pengguna bisa mengatur volume suara TV
PUT /television/volume
5) Pengguna bisa mematikan TV
DELETE /television/sessions/{session_id}

Mari kita bahas secara lebih mendalam lagi,
1) Pengguna bisa menghidupkan TV
Menghidupkan TV sama saja kita menciptakan suatu sesi baru menonton TV. Mebuat sesi baru berarti kita melakukan POST terhadap suatu resource.
Sehingga POST /television/sessions

2) Pengguna bisa menyimpan channel siaran TV ke dalam memory TV
Pada umumnya dalam TV terdapat sejumlah alokasi memory yang digunakan untuk menyimpan channel TV. Biasanya siaran TV disimpan dalam nomor-nomor tertentu, misal 1 untuk RCTI, 2 untuk MetroTV, 3 untuk SCTV, dst. Pengguna tidak perlu menciptakan nomor-nomor tersebut, karena nomor-nomor tersebut adalah bawaan dari pabriknya. Namun pengguna dapat mengubah dan menyimpan channel TV sesuka hatinya, namun pengguna tidak dapat menciptakan maupun menghapus nomor memory tersebut, mereka hanya diperbolehkan mengganti isinya. Karena prinsip-nya adalah mengubah atau update, maka kita melakukan PUT kepada suatu resource tertentu.
Sehingga PUT /television/channels/{channel_number}

3) Pengguna bisa mengubah channel TV untuk memilih siaran TV yang diinginkan
Ketika kita sedang asyik menoton TV, kadang kala kita ingin berpindah saluran. Karena TV kita telah dilengkapi memory yang dapat mengingat channel TV, kita dengan mudah memencet nomor yang ada pada tombol remote control untuk berpindah channel. Karena pada prinsipnya kita ingin menonton siaran TV yang ada pada nomor tertentu, maka kita melakukan GET terhadap suatu resource tertentu.
Sehigga GET /television/channels/{channel_number}

4) Pengguna bisa mengatur volume suara TV
Hampir sama dengan no (2), mengatur volume TV pada dasarnya adalah mengubah atau update terhadap volume TV. Kita hanya dapat mengubah, tidak dapat menghapus maupun menciptakan volume.
Sehingga PUT /television/volume

5) Pengguna bisa mematikan TV
Kebalikan dari no (1), untuk mematikan TV berarti kita mengakhiri suatu sesi. Dalam kasus ini, kata mengakhiri dapat didekatkan dengan kata menghapus. Sehingga DELETE /television/sessions/{session_id}

Demikianlah contoh bagaimana memodelkan TV secara REST. Walaupun desain di atas tidak sepenuhnya RESTful karena kita menggunakan desain session yang tidak RESTful.

Further reading:
http://www.infoq.com/articles/webber-rest-workflow

Dalam bahasa pemrograman berorientasi objek, ada dua style yang sering digunakan, yaitu class-based dan prototype-based. Class-based adalah metode yang paling banyak digunakan, dimana (seperti biasa) ada class dan object. Style ini menganggap bahwa class dan object adalah entitas yang berbeda. Class sebagai "cetakan" yang menghasilkan object. Singkat kata, object adalah instance dari suatu class. Berbeda dengan class-based, prototype-based tidak mengenal class. Semua adalah object, jika ada class maka itu juga adalah termasuk object. Prototype-based ini banyak ditemui di bahasa dinamis seperti Ruby dan Javascript. Berikut ini contoh perbandingan antara Class-based (Java) vs Prototype-based (Javascript):

+-----------------------------------------------+-----------------------------------------------+
| Class-based (Java)                            | Prototype-based (Javascript)                  |
+-----------------------------------------------+-----------------------------------------------+
|                                               |                                               |
| Class and instance are distinct entities.     | All objects are instances.                    |
|                                               |                                               |
| Define a class with a class definition;       | Define and create a set of objects with       |
| instantiate a class with constructor methods. | constructor functions.                        |
|                                               |                                               |
| Create a single object with the new operator. | Same.                                         |
|                                               |                                               |
| Construct an object hierarchy by using class  | Construct an object hierarchy by assigning an |
| definitions to define subclasses of existing  | object as the prototype associated with a     |
| classes.                                      | constructor function.                         |
|                                               |                                               |
| Inherit properties by following the class     | Inherit properties by following the prototype |
| chain.                                        | chain.                                        |
|                                               |                                               |
| Class definition specifies all properties of  | Constructor function or prototype specifies   | 
| all instances of a class. Cannot add          | an initial set of properties. Can add or      |
| properties dynamically at run time.           | remove properties dynamically to individual   |
|                                               | objects or to the entire set of objects.      |
|                                               |                                               |
+ ----------------------------------------------+-----------------------------------------------+

Bahasa statis seperti C++, Java, C# cenderung hanya class-based saja, sedangkan bahasa dinamis seperti Ruby, Python, Groovy, Javascript bisa lebih leluasa memilih antara prototype-based dan class-based atau bahkan mencampur keduanya sekaligus guna memperoleh kelebihan masing-masing metode dan saling menutup kekurangan masing-masing metode.
Contoh omplementasi prototype-based menggunakan bahasa Ruby.

Further reading:
http://www.iam.unibe.ch/~scg/Teaching/PL/Slides/03Prototypes.ppt.pdf
http://en.wikipedia.org/wiki/Prototype-based_programming
https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Class-Based_vs._Prototype-Based_Languages
http://unwrittencode.blogspot.com/2008/09/prototype-based-programming.html

Ada anjuran bahwa ketika mendesain suatu sistem yang menerapkan style REST (Representational State Transfer), sebaiknya menggunakan Logical URI. Sebelumnya, apa siy URI itu? URI itu singkatan dari Uniform Resource Identifier. URI terdiri dari URN (Uniform Resource Name) dan URL (Uniform Resource Locator). Apa bedanya? Secara sederhana, bila ada suatu link bernama "10 Lagu Teratas" maka itu adalah URN, bila ada suatu link menuju alamat "http://chart.musikamu.com/top-10" maka itu adalah URL.
Kembali lagi tentang Logical URI dan Physical URI, seperti apa siy mereka? Apa bedanya? Secara kasat mata, keduanya sangat mudah dibedakan. Berikut ini contohnya:

Logical URI:

http://chart.musikamu.com/top-10

Physical URI:

http://chart.musikamu.com/top-10.html

Jelas kan bedanya..
Mengapa REST menganjurkan logical URI? Karena REST bersifat resource-oriented. Um.. apa itu resource? Gampangannya, segala sesuatu yang punya URI adalah resource. So, karena REST itu resource-oriented, dan setiap resource dapat memiliki banyak representasi (html, xml, JSON, PNG, dsb.), maka sebaiknya kita menggunakan Logical URI. Kurang lebih seperti itu, maaf kalo ada yg keliru.

Mengingat kembali salah satu mata kuliah di semester 5, yaitu basis data. Disitu dijelaskan berbagai jenis relasi antar tabel, diantaranya One-to-One, One-to-Many, Many-to-Many. Diantara ketiganya, One-to-One adalah yang terlihat paling nyeleneh. Setidaknya itulah pikiran saya waktu itu. Nggak nyeleneh gimana? Kenapa One-to-One tidak dijadikan satu tabel saja? Ternyata ada alasannya. Salah satu alasannya adalah normalisasi tahap 4, tapi saya tidak menyinggung masalah itu. Ternyata alasannya adalah untuk menghemat storage yang dibutuhkan. Ya, mirip dengan normalisasi tahap 4, dimana kolom yang berpotensi memiliki nilai NULL harus disingkirkan ke tabel lain. Tapi harga storage kan murah? Masalahnya ternyata bukan semata-mata storage, tapi ada hubungannya juga dengan performa yang nanti akan kita dibahas bersama. Berikut ini contoh tabel yang memiliki relasi One-to-One:

ER Diagram:

          +-----------------+---------+-------------+
   +--->> | NIM             | INT 3   | primary key |
   |      +-----------------+---------+-------------+
   |      | Nama            | CHAR 10 | NOT NULL    |
   |      +-----------------+---------+-------------|
   |                                       
   |                                       
   |      +-----------------+---------+-------------+
   +----- | NIM             | INT 3   | foreign key |
          +-----------------+---------+-------------+
          | Merk_Mobil      | CHAR 10 |             |
          +-----------------+---------+-------------|

Implementasi:

+-----+------+
| NIM | Nama |
+-----+------+
| 001 | Kimi |
| 002 | Lewi |
| 003 | Mass |
| 004 | Alon |
| 005 | Kubi |
+-----+------+

+-----+------------+
| NIM | Merk_Mobil |
+-----+------------+
| 001 | Ferrari    |
| 005 | BMW        |
+-----+------------+

Bila tabel di atas dihilangkan relasinya dan digabung menjadi satu tabel, maka menghasilkan

ER Diagram:

+-----------------+---------+-------------+
| NIM             | INT 3   | primary key |
+-----------------+---------+-------------+
| Nama            | CHAR 10 | NOT NULL    |
| Merk_Mobil      | CHAR 10 |             |
+-----------------+---------+-------------|

Implementasi:

+-----+------+------------+
| NIM | Nama | Merk_Mobil |
+-----+------+------------+
| 001 | Kimi | Ferrari    |
| 002 | Lewi | NULL       |
| 003 | Mass | NULL       |
| 004 | Alon | NULL       |
| 005 | Kubi | BMW        |
+-----+------+------------+

Kita tahu bahwa tipe data CHAR 10 menampung karakter dengan panjang maksimum 10. Walaupun hanya diisi 5 karakter, tetap saja dihitung 10 karakter. Bahkan NULL juga dihitung 10 karakter! Inilah asal-muasal mengapa data dipisahkan. Dengan menggunakan relasi One-to-One, kita memiliki kemungkinan untuk menghemat storage seperti yang diilustrasikan di atas. Tapi tetap saja aneh, kenapa tidak menggunakan tipe data VARCHAR saja? Nah, karena saya orang baru di bidang IT, perkiraan saya adalah bahwa jaman dulu belum mengenal tipe data VARCHAR. Dari sisi performa, tentu saja basis data yang terpecah-pecah dalam banyak tabel memiliki performa rendah, semakin banyak tabel, semakin banyak relasi, semakin rendah pula performa database tersebut. Namun di sisi lain, ada kemungkinan untuk menghemat storage.
Berikut ini solusi sama namun lebih cantik yang bisa diterapkan di sebagian besar DBMS modern saat ini:

ER Diagram:

+-----------------+------------+-------------+
| NIM             | INT 3      | primary key |
+-----------------+------------+-------------+
| Nama            | VARCHAR 10 | NOT NULL    |
| Merk_Mobil      | VARCHAR 10 |             |
+-----------------+------------+-------------|

Implementasi:

+-----+------+------------+
| NIM | Nama | Merk_Mobil |
+-----+------+------------+
| 001 | Kimi | Ferrari    |
| 002 | Lewi | NULL       |
| 003 | Mass | NULL       |
| 004 | Alon | NULL       |
| 005 | Kubi | BMW        |
+-----+------+------------+

Pada kasus ini, dengan menggunakan tipe data VARCHAR, kita bisa menghemat storage tanpa melakukan pengorbanan besar terhadap performa basis data. Tidak perlu khawatir kehabisan storage, karena data NULL tidak memakan jumlah storage sama dengan data sepanjang 10 karakter. Mendesain suatu basis data adalah pekerjaan yang menantang sekaligus membutuhkan seni tersendiri.

Ini adalah beberapa aplikasi dan theme yang saya gunakan untuk meningkatkan produktivitas dan mempercantik tampilan GNOME. Sistem operasi yang digunakan adalah Ubuntu 8.04.1 Hardy Heron

1. Dust Theme
Theme ini termasuk theme yang gelap. Dari sisi tampilan, tampak ada sedikit pengaruh dari tampilan Mac OSX. Walaupun masih tergolong "muda", yaitu versi 0.2, namun theme ini sudah cukup stabil dan nyaman digunakan. Theme ini juga menyediakan theme untuk Mozilla Firefox versi 3, ya supaya Firefox-nya matching dengan GNOME. Semua paket yang dibutuhkan dapat didownload di https://wiki.ubuntu.com/Artwork/Incoming/DustTheme. Untuk wallpaper, saya peroleh dari http://stopthestatic.deviantart.com/art/the-damage-is-done-100484792


Ini tampilan desktop ketika lagi nganggur.


Ini tampilan ketika lagi mainan GIMP


Ini tampilan salah satu efek compiz-fusion.


Ini tampilan Mozilla Firefox yang dah dipersenjatai dengan Dust Theme


Ini adalah tampilan File Manager GNOME (Nautilus)

2. GnomeDo
GnomeDo adalah aplikasi yang sangat bermanfaat untuk urusan produktivitas. Secara default, cukup tekan tombol Super (Windows) + Space untuk mengaktifkan GnomeDo, kemudian ketik kata kunci yang dicari, maka secara instan GnomeDo akan menampilkan data-data yang sesuai. Saya paling sering menggunakan aplikasi ini untuk menjalankan suatu aplikasi. Untuk cara instalasi ada di https://wiki.ubuntu.com/GnomeDo/Installation.



3. Conky
Aplikasi ini mirip dengan Windows Sidebar pada Vista. Kita bisa mengubah-ubah tampilan sesuka hati dengan memodifikasi script conky. Ini adalah contoh script conky yang saya gunakan:

background yes
use_xft yes
xftfont HandelGotD:size=9
xftalpha 0.5
update_interval 1.0
total_run_times 0
own_window yes
own_window_type normal
own_window_transparent yes
own_window_hints undecorated,below,sticky,skip_taskbar,skip_pager
double_buffer yes
minimum_size 220 5
maximum_width 220
draw_shades no
draw_outline no
draw_borders no
draw_graph_borders yes
default_color white
default_shade_color red
default_outline_color green
alignment top_right
gap_x 12
gap_y 48
no_buffers yes
uppercase no
cpu_avg_samples 2
override_utf8_locale no

TEXT
$sysname $kernel on $machine

Uptime $alignr $uptime
Load $alignr $loadavg

Hostname $alignr $nodename
eth0 $alignr ${addr eth0}
HDDlinux $alignr /dev/hdb ${execi 300 nc localhost 7634 | cut -c53-54 ;}C
HDDwindows $alignr /dev/hda ${execi 300 nc localhost 7634 | cut -c27-28 ;}C

CPU $alignr ${cpu cpu0}%
${cpubar cpu0}

RAM $alignc $mem / $memmax $alignr $memperc%
$membar

/root $alignc ${fs_used /} / ${fs_size /} $alignr ${fs_free_perc /}%
${fs_bar /}

swap $alignc $swap / $swapmax $alignr $swapperc%
${swapbar}

$processes processes ($running_processes running)

${color white}Paling Rakus CPU:
${color de0b0b}${top name 1}${top_mem cpu 1}
${color white}${top name 2}${top cpu 2}
${top name 3}${top cpu 3}
${top name 4}${top cpu 4}
${top name 5}${top cpu 5}

${color white}Paling Rakus RAM:
${color de0b0b}${top_mem name 1}${top_mem mem 1}
${color white}${top_mem name 2}${top_mem mem 2}
${top_mem name 3}${top_mem mem 3}
${top_mem name 4}${top_mem mem 4}
${top_mem name 5}${top_mem mem 5}

${color}Jaringan:
Mudun:${color} $alignr ${downspeed eth0} k/s${color} ${offset 80}
$alignc ${downspeedgraph eth0 32,150 de0b0b de0b0b}
Munggah:${color} $alignr ${upspeed eth0} k/s ${offset 80}
$alignc ${upspeedgraph eth0 32,150 de0b0b de0b0b}

Mungkin harus sedikut dimodifikasi supaya sesuai dengan sistem anda. Kalo tampilannya seperti ini (hanya sebagian saja):



Happy Linux-ing...!!!

NB: Kalo mau Conky dan GnomeDo autostart setiap kali ubuntu booting, maka kamu harus tambahin di System - Preference - Sessions - Startup Programs

Persaingan tidak hanya terjadi antar web browser saja, markup language untuk web standard juga tampak bakal bersaing sengit. HTML 5 vs XHTML 2 siap menggantikan HTML 4.x vs XHTML 1.x. Secara fitur keduanya bersaing cukup ketat, walaupun ada perbedaan yang sangat mendasar diantara keduanya. HTML 5 masih mempertahankan sintaks SGML, sedangkan XHTML 2 tetap menggunakan XML murni.

Persamaannya, keduanya sama-sama berusaha membuang jauh-jauh unsur yang bersifat presentation pada elemen mereka (misal: font, color, bold, italic, dsb). Presentation itu memang seharusnya merupakan urusan CSS, sedangkan HTML/XHTML hanya berisi content saja. Behaviour? Itu urusan Javascript.

Berbicara tentang semantic web, keduanya sangat peduli dengan urusan semantic, hanya saja XHTML 2 memiliki fitur yang lebih garang dibanding HTML 5, namun fitur garang tidak menjamin kesuksesan suatu standard. HTML 5 lebih fleksibel (tidak terlalu strict karena SGML) dan memiliki dukungan dari 95% web browser. Sedangkan XHTML 2 yang berbasis XML merupakan jalan menuju next-generation web, termasuk semantic web.

Further Reading:
http://immike.net/blog/2008/02/06/xhtml-2-vs-html-5/
http://xhtml.com/en/future/x-html-5-versus-xhtml-2

Sekitar dua bulan yang lalu iseng-iseng ikut quiz yang diadakan oleh SitePoint. Ada dua quiz yang saya ikuti, yaitu tentang Adobe AIR dan Adobe Flex. Quiz-nya sederhana, hanya menjawab beberapa pertanyaan seputar Flex atau AIR. Dari keduanya, saya hanya beruntung di quiz yang Adobe Flex saja. Sedangkan yang Adobe AIR, saya sudah kalah cepat dari pengunjung lain (alias kehabisan buku dan hanya kebagian versi pdf aja). Maklum, pihak SitePoint hanya menyediakan 100 eksemplar saja untuk dibagikan, sisanya harus puas kebagian versi pdf saja.

Akhirnya, setelah dua bulan menunggu (dan hampir lupa) akhirnya buku itu sampai juga di rumah saya, Alhamdulillah...









Semoga buku ini bermanfaat, kebetulan di Windows saya sudah ada Adobe Flex Builder 3 (Education License) yang sudah lama tidak tersentuh. Nggak ada salahnya belajar Flex sebagai alternatif dari HTML/CSS/Javascript, sehingga kita bisa tahu kapan harus pake Flex kapan tidak.

Twine merupakan layanan semantic web. Masih dalam versi beta dan invite only. Ada RDF, OWL, dan Semantic Graph juga.

Untuk mengakses suatu variable/reference yang private maupun protected, biasanya kita menggunakan pasangan method yang biasa disebut dengan getter dan setter (kalo orang Ruby biasa menyebutnya dengan istilah reader dan accessor). Kali ini kita membandingkan antara protected variable di Java dengan instance variable (@variable) di Ruby. Mengapa protected? Karena sifat instance variable pada Ruby lebih mirip dengan sifat protected pada Java, yaitu hanya dapat diakses oleh class itu sendiri dan turunannya.

The Java Way:

protected String myString1;
protected String myString2;
protected String myString3;

public void setMyString1(String myString1) {
  this.myString1 = myString1;
}

public String getMyString1() {
  return this.myString1;
}

public String getMyString2() {
  return this.myString2;
}

public void setMyString3(String myString3) {
  this.myString3 = myString3;
}

The Ruby Way:

def my_string_1
  @my_string_1
end

def my_string_1=(string)
  @my_string_1 = string
end

def my_string_2
  @my_string_2
end

def my_string_3=(string)
  @my_string_3 = string
end

Hampir mirip dengan versi Java, hanya saja (karena dynamic language) Ruby tidak membutuhkan deklarasi. Ruby (dalam kasus ini) juga tidak membutuhkan penulisan return secara eksplisit karena secara otomatis baris terakhir dari suatu method akan menjadi return value. Code Ruby seperti di atas terlihat membosankan, ada cara lain yang lebih atraktif dan menyenangkan (cara yang paling sering digunakan programmer Ruby), yaitu:

attr_accessor :my_string_1
attr_reader :my_string_2
attr_writer :my_string_3

attr_accessor untuk setter dan getter
attr_reader untuk getter saja
attr_writer untuk setter saja

Jauh lebih sedikit dari versi sebelumnya, dan terlihat lebih cantik. Instance variable yang diawali dengan @ diganti dengan titik dua (:) yang menandakan bahwa dia adalah object dari Symbol. Bagaimana bila kita punya banyak instance variable? Bila itu cara konvensional, saya tidak berminat menuliskannya di sini (karena cukup panjang).

attr_accessor :my_string_1, :my_string_4, :my_string_5, :my_string_6
attr_reader :my_string_2, :my_string_7, :my_string_8
attr_writer :my_string_3, :my_string_9

Bila ada lebih dari satu instance variable yang akan dibuatkan setter, getter, atau keduanya, maka programmer dengan mudah menambahkan variable tersebut dengan menggunakan tanda pisah koma (,).

Java is a hands down winner. Sorry, Ruby is not even close (yet).


http://flickr.com/photos/anildigital/178961991/

But, today is a different day. A better day...



http://flickr.com/photos/acangiano/2617051318/

Programmer Java biasanya menggunakan cara penulisan camel-case untuk nama method, dimana method tersebut diawali dengan huruf kecil. Tidak demikian dengan Programmer Ruby yang lebih senang menggunakan underscore sebagai pemisah antar kata.

The Java Way:

public void myMethod {
  // ...
}

The Ruby Way:

def my_method
  # ...
end

Baik Ruby maupun Java memiliki berbagai jenis method (dan hak akses-nya), seperti private, protected, dan public.

The Java Way:

private void myMethod1 {
  // ...
}
private void myMethod2 {
  // ...
}

The Ruby Way:

private
def my_method_1
  # ...
end
def my_method_2
  # ...
end

Demikian pula, baik Java maupun Ruby memiliki class method, alias method yang bisa diakses tanpa harus melakukan instansiasi terhadap class tersebut (orang Java menyebutnya dengan istilah static method).

The Java Way:

public static void myMethod {
  // ...
}

The Ruby Way:

def self.myMethod
  # ...
end

Bila dilihat pada code Ruby, ada tambahan kata "self" di depan nama method. Self mirip dengan this pada Java, walaupun sebenarnya tidak sama. Sebagai informasi, self adalah salah satu teman kesayangan para Ruby Metaprogrammer.

Nah, ada satu hal yang sangat cantik di Ruby tentang penamaan method, yaitu penggunaan tanda tanya (?) dan tanda seru (!) di belakang method. Ini hanya konvensi dari para programmer Ruby saja, yang suka boleh pake dan bagi yang nggak suka juga ya silahkan mengabaikannya.

The Java Way:

// Sepertinya Java tidak bisa mengimplementasikan cara ini

The Ruby Way:

def is_cool?
  # ...
  # Return boolean value
end
def is_bad?
  # ...
  # Return boolean value
end

nama = "keralunub"
puts nama.upcase   # KERALUNUB
puts nama          # keralunub
puts nama.upcase!  # KERALUNUB
puts nama          # KERALUNUB

Ya, di Ruby untuk method yang diakhiri dengan tanda tanya (?), maka method tersebut (seharusnya) memiliki nilai kembali berupa boolean (true / false). Sedangkan untuk method yang diakhiri tanda seru (!), (seharusnya) mengakibatkan object yang dikenai method tersebut berubah nilainya. Seperti pada contoh di atas, upcase tidak mengubah object nama, sedangkan upcase! benar-benar mengubah object nama. Ini hanyalah konvensi yang sudah sangat umum di kalangan programmer Ruby.