Sunday, November 20, 2005
Tentang Adapter PatternAspek OO yang didukung : reusability
Kondisi :
Kita mempunyai sebuah class dan sebuah client yang akan menggunakan class tersebut, tetapi tipe class yang akan kita pakai tersebut tidak cocok dengan tipe yang dibutuhkan oleh client*. Yang dimaksud dengan “tipe class tidak cocok “ di sini adalah bahwa class tersebut secara hierarki tidak bisa masuk ke tipe yang dibutuhkan client. (Di akhir tulisan ini disertakan sebuah contoh kasus)
* Sebagai contoh di Java, client di sini dapat berupa sebuah method yang mempunyai parameter bertipe tertentu. Tipe parameter inilah yang tidak sesuai dengan tipe class yang sudah ada.
Tujuan :
Mengubah kontrak dari suatu class sehingga dapat memenuhi kontrak dari client.
Kontrak** di sini adalah behavior yang harus dipunyai oleh suatu class.
**Di Java, kontrak bisa diimplementasikan sebagai interface, abstract class, atau bahkan concrete class. Tapi pada desain yang baik (prefer interface rather than implementation), kontrak biasa diimplementasikan sebagai interface.
Solusi :
Cara untuk mengatasi hal ini cukup mudah, yaitu tinggal membuat sebuah class baru yang memenuhi kontrak dari client.
Implementasi :
Secara intuitif, ada dua pendekatan solusi yang bisa kita lakukan, yaitu dengan inheritance dan dengan composition. Cara yang pertama dikenal sebagai class adapter dan cara kedua dikenal sebagai object adapter.
Sebagai contoh kasus, jika kita sudah punya definisi class sebagai berikut (existing classes).
1 interface Animal {
2 public void sleep();
3 }
4
5 class Cat implements Animal {
6 public void sleep() {
7 System.out.println("I'm so sleeeepy.. Miauwww");
8 System.out.println("(Trying to find comfy place to sleep)");
9 System.out.println("(Find a place, and put its head on its hand)");
10 }
11 }
12
13 class Mouse implements Animal {
14 public void sleep() {
15 System.out.println("Soo sleeepy.. cit cit");
16 System.out.println("(Try to find a hole..)");
17 System.out.println("(Can't find one..creating a new one)");
18 System.out.println("Zzz..zzz.z");
19 }
20 }
Permasalahan : kita harus menggunakan beberapa ekor binatang (Animal) sebagai pemeran (Actor) pada sebuah adegan film (MovieScene), karena skenario film tersebut membutuhkan adegan dimana beberapa ekor binatang akan tidur.
1 class MovieScene {Kita mempunyai sebuah permasalahan baru, di mana kita harus menggunakan class yang sudah ada sebelumya (Cat) di dalam solusi permasalahan baru kita.
2
3 private List actorList = new ArrayList();
4
5 public void addActor(Actor actor) {
6 this.actorList.add(actor);
7 }
8
9 public void playScene() {
10 System.out.println("--Begin the scene--");
11
12 Actor actor;
13 for (Iterator iter = actorList.iterator(); iter.hasNext();) {
14 actor = (Actor) iter.next();
15 actor.act();
16 }
17
18 System.out.println("--End fo scene--");
19 }
20
21 }
22
23
24 interface Actor {
25 public void act();
26 }
27
28 class HumanActor implements Actor {
29 public void act() {
30 System.out.println("I'm an human actor and now doing my scenario script...");
31 }
32 }
1 class Movie {
2 public static void main(String[] args) {
3 MovieScene scene = new MovieScene();
4 Actor bruceWillis = new HumanActor();
5
6 scene.addActor(bruceWillis);
7
8 Cat tom = new Cat();
9 // Animal or Cat can't fit into Actor
10 // so we can't use scene.addActor(Cat cat);
11 // nor write Actor tom = new Cat() here
12 // nor using scene.addActor(Animal a); if we declare tom as an Animal
13
14 scene.playScene();
15 }
16 }
Untuk mengatasi hal ini, kita mengimplementasikan Adapter pattern, salah satu caranya yaitu dengan membuat sebuah class baru yang meng-implement interface yang dibutuhkan oleh MovieScene.addActor (yaitu Actor), dan menghubungkan method yang dibutuhkan oleh Actor dengan method yang disediakan oleh Animal.
1 class AnimalActor implements Actor{
2
3 private Animal animal;
4
5 public AnimalActor(Animal animal){
6 this.animal = animal;
7 }
8
9 public void act() {
10 animal.sleep();
11 }
12
13 }
Cara yang kedua adalah dengan melakukan composition antara subclass dari ActorAdapter berikut ini dengan Animal, dan meng-override method yang ada dengan pemanggilan method pada Animal.
1 class ActorAdapter implements Actor{
2 public void act() {
3 // do nothing..
4 }
5 }
Sekarang kita bisa menggunakan dua binatang kita untuk ikut serta dalam film.
1 class MouseActor extends ActorAdapter{
2
3 private Mouse mouse;
4
5 public MouseActor(Mouse mouse){
6 this.mouse = mouse;
7 }
8
9 public MouseActor(){
10 mouse.sleep();
11 }
12
13 public void act() {
14 super.act();
15 }
16 }
17
18
19 class Movie {
20 public static void main(String[] args) {
21 MovieScene scene = new MovieScene();
22 Actor bruceWillis = new HumanActor();
23
24 Cat tom = new Cat();
25 Mouse jerry = new Mouse();
26
27 Actor adaptedTom = new AnimalActor(tom);
28 Actor adaptedJerry = new MouseActor(jerry);
29
30 scene.addActor(bruceWillis);
31 scene.addActor(adaptedTom);
32 scene.addActor(adaptedJerry);
33
34 // suppose that we want to create a new type of Actor and add it to the scene
35 scene.addActor(new ActorAdapter(){
36 public void act() {
37 System.out.println("Simply do nothing..");
38 // hey, this looks like how we add an adapter on Swing ;)
39 }
40 });
41
42 scene.playScene();
43 }
44 }
permaLink() |
postComments() |
read1Comments()
For a seo company
that provides search engine
optimisation , and marketing solutions contact Proweb Direct.
Saturday, November 12, 2005
Programming language and scalability: are they related? Yes, but…Menyimak thread “1 juta email” di milis teknologia yang menyimpang dari arah pembicaraan semula, saya ingin meluruskan beberapa anggapan yang seolah-olah menyatakan bahwa bahasa pemrograman adalah faktor paling utama yang menjadi kunci skalabilitas suatu aplikasi. Tentu saja ini diskusi antara kubu Java vs others. Entah sudah berapa kali diskusi seperti ini muncul (dan banyak di antaranya yang menjadi flame war). Dan entah pula mengapa masih juga banyak orang yang menanggapi dan memberikan tanggapan yang itu-itu saja (VM vs non-VM, perbedaan level abstraksi, perbedaan kemampuan programmer, dst). Seharusnya ada orang yang berbaik hati mau menyumbangkan waktunya untuk menulis katalog yang berisi tanggapan masing-masing kubu dan mungkin malah menerbitkannya sebagai buku, misalnya dengan judul “Reply Pattern, Element of Reusable Language Holy War”. Hehe.
Catatan : pernyataan yang menyebutkan bahwa sesuatu itu “lambat” adalah pernyataan yang salah. Yang benar adalah sesuatu itu “lebih lambat” dari sesuatu yang lain. (pelajaran teori relativitas waktu SMA dulu :)
Sebelumnya perlu untuk diketahui dulu bahwa jika pada suatu aplikasi, penggunaan kata skalabilitas dapat digunakan di dua konteks. Yang pertama adalah dari sisi user / request, yang menyatakan kemampuan aplikasi untuk melakukan sejumlah permintaan pemrosesan secara konkuren, pada kurun waktu tertentu. Yang kedua adalah dari sisi data, yang menyatakan kemampuan dari aplikasi (berikut infrastrukturnya, dalam hal ini adalah database). Sisi yang kedua merupakan konteks yang tidak relevan dengan bahasa. Karena itu, konteks yang akan dipakai adalah skalabilitas dari sisi jumlah request yang dapat ditangani aplikasi.
Bahasa (atau sebaiknya saya gunakan kata teknologi ya, karena Java bukan hanya sekedar bahasa) yang digunakan memang menentukan skalabilitas aplikasi. Source code yang ditulis dalam bahasa tertentu pasti akan dijalankan oleh prosesor sebagai seperangkat instruksi mesin. Tiap bahasa hampir pasti akan menghasilkan seperangkat instruksi yang berbeda (1) untuk sekumpulan ekspresi yang merupakan implementasi dari suatu algoritma. Selain itu, waktu yang dibutuhkan untuk menghasilkan dan pemanggilan instruksi tersebut juga pasti akan berbeda (2). Karena itulah bahasa yang digunakan pasti menentukan skalabilitas aplikasi. Tapi, berapa selisihnya?
T1 = I1 * E1
T2 = I2 * E2 + G
T1 : total waktu eksekusi bahasa 1
I1 : jumlah instruksi yang dihasilkan oleh kompilasi bahasa 1
E1 : rata-rata waktu yang dibutuhkan untuk eksekusi satu instruksi oleh mesin)
T2 : total waktu eksekusi bahasa 2
I2 : jumlah opcode yang dihasilkan oleh kompilasi bahasa 2
E2 : rata-rata waktu yang dibutuhkan untuk eksekusi satu opcode oleh VM)
G : waktu untuk manajemen object (termasuk garbage collection)
Untuk mengetahui T2-T1 tentu saja sebelumnya kita harus memperoleh nilai I1,I2,E1, dam E2 terlebih dahulu. Untuk membuktikan bahwa selisih T2 dan T1 adalah nilai yang cukup besar, secara intuitif kita harus membuktikan bahwa selisih antara I2 dan I1 serta selisih antara E2 dan E1 cukup besar pula. Terus terang saya belum bisa memperkiraan selisih antara I2 dan I1, selain karena saya bukan pakar di bidang teknik kompilasi dan perancangan bahasa, juga hal yang tidak mudah untuk memperkirakan perbedaan implementasi suatu abstraksi (API / library) di masing-masing bahasa. Selain itu, perhitungan nilai G juga sangat kasuistik, karena itu walaupun dapat menentukan T2, saya terpaksa mengabaikannya.
Bahasa seperti C++ membutuhkan kompilasi untuk menerjemahkan source code menjadi sekumpulan instruksi yang akan dieksekusi langsung oleh mesin (saya mengabaikan teknik kompilasi ataupun linking secara statis di sini). Bahasa seperti Java akan dikompilasi menjadi sekumpulan instruksi bytecode (opcode) yang akan dieksekusi oleh VM. Karena itu selisih yang harus dicari adalah selisih antara waktu eksekusi instruksi oleh mesin (native) dan waktu eksekusi instruksi bytecode oleh VM.
Tentu saja waktu eksekusi yang dilakukan oleh VM akan lebih besar dari pada waktu eksekusi mesin, karena VM bertindak sebagai layer di atas OS. Tetapi waktu eksekusi tersebut bisa diperkecil dengan beberapa teknik seperti kompilasi JIT dan kompilasi adaptif (hampir semua JVM secara default menyediakan fasilitas ini). Karena itu, selisih antara E1 dan E2 tidaklah sangat mencolok untuk aplikasi yang berjalan lama.
Yah, hanya sampai sinilah pemikiran saya tentang selisih waktu eksekusi. Jika I1 dan I2 ternyata tidak mempunyai selisih yang besar, maka terbantahlah opini bahwa Java jauh lebih lambat daripada bahasa native.
Berikutnya, patutkah faktor bahasa yang dipersalahkan jika suatu aplikasi tidak scalable? Skalabilitas adalah salah satu dari non functional requirement. Skalabilitas biasanya diperhitungkan di fase architectural design pada OO software development lifecycle. Saya merasa bahwa keputusan-keputusan yang berkaitan dengan arsitektur akan jauh lebih mempengaruhi skalabilitas daripada sekedar pemilihan bahasa implementasi. Keputusan untuk menggunakan DNS load balancing untuk cluster misalnya, akan jauh lebih berpengaruh daripada memutuskan menggunakan C++ untuk menambah scalability. Perbandingannya mungkin antara beberapa ratus/ribu persen melawan beberapa puluh persen saja.
Beberapa puluh persen itu digunakan untuk membayar beberapa hal. Clustering di business logic tier? Hal yang mudah dilakukan di beberapa application server yang populer. Legacy connectivity? Ya, hal ini salah satu alasan dipilihnya teknologi Java untuk implementasi. Kemudahan mengimplementasikan transaksi yang kompleks? Banyak vendor Java yang memfasilitasi hal tersebut.
