a. Analisa Kebutuhan sistem
Sebelum melangkah ke implementasi sistem
beberapa perangkat lunak yang perlu dipersiapkan
adalah :
- Compiler C++, karena sistem akan dikembangkan dibawah sistem operasi Linux, salah satu yang ada di paket linux untuk compiler C++ adalah g++.
- Perangkat lunak ORB C++ yang akan digunakan yaitu MICO-C++ yang bisa didownload secara gratis dari mico.org. Kemudian diinstalasi di sistem operasi linux. Untuk pengujian client server dengan 2 komputer atau lebih maka MICO-C++ ini harus diinstalasi pada semua komputer yang akan digunakan. MICO-C++ yang digunakan adalah versi 2.3.11 yang sangat selaras dan mendukung CORBA spesifikasi 2.3.
- Implementasi yang akan dipakai untuk uji coba program adalah aplikasi perbankan. Dalam aplikasi ini ada beberapa layanan diantaranya withdraw, balance dan deposit.

b. Pemrograman MICO-C++
Sesuai dengan analisa kebutuhan sistem diatas maka aplikasi yang akan dipakai adalah bank account. Bank account menawarkan 3 layanan, withdraw yaitu pengambilan sejumlah uang, deposit yaitu menyimpan sejumlah uang, dan balance yaitu aplikasi bank untuk menghitung jumlah uang yang ada. Langkah pertama adalah membuat file IDL. Untuk aplikasi bank account ini maka file IDLnya adalah sebagai berikut:

interface Account {
void deposit (in unsigned
long amount);
void withdraw(in unsigned
long amount);
long balance();
};

kita dapat melihat bahwa aplikasi bank account ini memiliki 3 layanan deposit dan withdraw dengan nilai input amount, dan layanan balance. File IDL ini disimpan dengan nama file account.idl dan kemudian dikompilasi dengan compiler IDL yang ada didalam MICO-C++. Kompilasi yang dilakukan adalah sebagai berikut:

c/>idl --boa –nopoa account.idl

hasil kompilasi file tersebut akan men-generate file account.h dan account.c. Dalam file-file itu memuat deklarasi class sebagai dasar class untuk implementasi objek account. Untuk setiap layanan/interface yang dideklarasikan di file idl maka IDL Compiler akan men-generate sebuah C++ class. Untuk lebih jelas bagaimana aplikasi MICO ini dibangun.
Langkah berikutnya adalah membangun aplikasi client dan server. Agar client bisa memanggil aplikasi server maka client harus tahu identitas server yang akan dipanggil. Kalau dalam jaringan komputer kita mengenal IP Address untuk mengalamati sebuah host dalam sebuah jaringan, dalam CORBA pengalamatan ini bisa menggunakan sebuah layanan yang disediakan oleh CORBA Common Object Services. Layanan untuk pengalamatan ini adalah Naming Service (layanan penamaan). Naming Service ini akan memberi sebuah ID (identitas) sesuai dengan format CORBA.
Salah satu metode agar programmer tahu seperti apa pengalamatan yang dilakukan oleh CORBA adalah Stringification. Stringification ini mengubah alamat objek (yang akan dipanggil) ke bentuk string, kemudian disisi client string ini akan di konversi lagi oleh CORBA ke format aslinya. Dalam implementasi pemrograman method ini dilakukan dengan cara memanggil string_to_object dan object_to_string. Untuk ap likasi server maka program bank account ini bisa ditulis sebagai berikut:

// file account_server.cc
#include
#include
#include “account.h”
class Account_app : virtual public
Account_skel
{
//Definisi implementasi Account
Account::Account()
{
_current_balance = 0;
}
void Account::deposit(unsigned long
amount)
{
_current_balance += amount;
}
void Account::withdraw(unsigned long
amount)
{
_current_balance -= amount;
}
long Account::balance ()
{
return _current_balance;
}
int main(int argc, char *argv[])
{
// inisialisasi ORB
CORBA::ORB_var orb = CORBA::init (argc,
argv, “mico-local -orb”);
//inisialisasi ORB
CORBA::BOA_var boa = orb->BOA_init
(argc, argv, “mico-local-boa”);
//Inisialisasi Object adapter
Account_app* server = new
Account_app;
//objek server
CORBA::String_var ref=orb-
>object_to_string (server);
//panggil method stringification
//untuk memberi ID ke objek server
ofstream out(“/home/maman/tmp/
account.objid”);
//simpan di direktori
out << ref << endl;
//tampilkan refensi objek ID
out.close();
boa->impl_is_ready
(CORBA::ImplementationDef::nil());
//menginisialisasi object adapter
orb->run;
//running ORB untuk memposisikan
//server menjadi posisi
//mendengarkan panggilan
//dari client
CORBA::release(server);
//melepaskan panggilan jika sudah
// selesai
return 0;
}

sedangkan untuk aplikasi client harus dibuat sebuah
program yang memanggil ID server dan memanggil
aplikasi yang ada di server .

//file account_client.cc
#include
#include
#include “account.h”
int main(int argc, char *argv[])
{ //main method
CORBA::ORB_var orb = CORBA::init (argc,
argv, “mico-local -orb”);
//inisialisasi ORB
CORBA::BOA_var boa = orb->BOA_init
(argc, argv, “mico-local-boa”);
//inisialisasi objek adapter
ifstream in
(“/home/maman/tmp/account.objid”);
char_ref[1000];
in >> ref;
in.close();
//membaca file objek ID yang masih
//dalam bentuk string
CORBA::Object_var obj =
orb->string_to_object (ref);
//menkonversi string ke objek ID
Account_var client =
Account::_narrow(obj);
//objek client
client->deposit (1000);
client->withdraw (500);
cout << “Balance is “ <<
client->balance() << endl;
//memanggil aplikasi sambil memberi
//nilai untuk diproses
return 0;
}

Langkah berikutnya adalah mengkompilasi program server dan client yang sudah dibuat menjadi objek (.o). Untuk mengkompilasi dengan menggunakan MICO-Compiler maka digunakan perintah berikut:
mico-c++ -I. –c account_server.cc –o
account_server.o
mico-c++ -I. –c account_client.cc –o
account_client.o
mico-c++ -I. –c account.cc –o account.o

objek-objek yang sudah dibuat kemudian dikompilasi lagi untuk membuat sebuah program yang bisa dieksekusi. Perintahnnya adalah:
mico-ld –o server account_server.o
account.o –lmico2.3.11
mico-ld –o client account_client.o
account.o –lmico2.3.11

Pengujian Setelah semua class yang di-generate oleh Compiler IDL di kompilasi, aplikasi server dan client juga didevelop dengan acuan kerangka dari class-class yang sudah ada, langkah berikutnya adalah running program dan pengujian program. Program yang harus pertama kali dijalankan adalah class Server, berikutnya baru dari sisi client dijalankan aplikasi client. Untuk pengujian ini hal yang pertama kali harus di perhatikan adalah koneksi dari client ke server, dalam hal ini kemampuan untuk sebuah objek koneksi ke objek lain dan mampu melakukan interoperasi, atau dalam istilah lain disebut interoperabilitas. Interoperabilitas adalah kemampuan antara 2 sistem atau lebih untuk bisa saling bertukar informasi dan menggunakan informasi tersebut.
Menjalankan Server Server bisa dijalankan dengan memanggil class
aplikasi server sesuai dengan perintah berikut:
server Menjalankan Client Client bisa dijalankan dengan memanggil class
aplikasi client dengan perintah sebagai berikut:
client Aplikasi client bisa dilakukan di sebuah komputer yang sama dengan server atau di mesin komputer yang berbeda.
Respon dari hasil setelah client dijalankan adalah sebagai berikut:
Balance is 500