Minggu uts baru saja lewat. Salah satu yang berkesan selama ujian kemarin adalah mata kuliah intelejensia kolektif. Ujiannya sebetulnya sederhana, hanya me-review sebuah paper, dengan catatan mencoba mengimplementasikan apa yang disampaikan paper tersebut dalam waktu satu minggu (sambil ada uts yang lain juga, hehe). Kebetulan saya mendapat paper yang isinya tidak terlalu sulit untuk diimplementasikan dalam artian tidak membutuhkan spesifikasi konfigurasi tertentu (mis. simulasi, jaringan komputer, atau framework parallel programming). Paper yang saya review adalah “A Hybrid ACO algorithm for the capacitated Minimum Spanning Tree Problem“, oleh Marc Reimann dari ETHZ.

Singkat kata, ada dua buah topik yang terlibat di sini. Pertama adalah algoritma ACO (Ant Colony Optmization) yaitu algoritma optimasi yang terinspirasi dari perilaku semut dalam mencari makanan. Berdasarkan hasil pengamatan, jalur yang dilalui oleh semut (dari sarang ke lokasi makanan) jika makanan ditemukan merupakan jalur yang terpendek (shortest path). Semut itu sendiri bergerak secara acak namun saling berkomunikasi a la pramuka dengan memanfaatkan jejak zat kimia bernama feromon. Jika makanan ditemukan maka semut tersebut akan meninggalkan feromon dalam perjalanan pulang ke sarang. feromon ini akan menguap seiring dengan waktu namun akan diperkuat jika ditambahkan oleh semut lainnya. Walaupun di awal dinyatakan bahwa semut bergerak secara acak namun dengan adanya media komunikasi berupa feromon, semut tersebut memiliki kecenderungan lebih tinggi untuk memilih jalan yang aroma feromonnya lebih kuat.

Topik kedua yaitu persoalan capacitated minimum spanning tree. Sejujurnya, baru kali itu saya mengetahui tentang persoalan tsb. Kalau persoalan minimum spanning tree tentu sudah pernah dengar dari kuliah matematika diskret di awal S1. Nah, kalau ditambah batasan tambahan? Ternyata setelah browsing sana-sini dan melototin papernya sambil begadang, lama kelamaan ngerti juga. Ternyata adanya batasan ‘capacitated‘ itu maksudnya adalah jika ada satu node yang dipastikan akan menjadi akar pohon dan tiap node lainnya punya nilai demand maka untuk tiap sub-pohon yang terhubung ke node akar tidak boleh melebihi nilai konstanta kapasitas untuk persoalan tersebut. ketika nilai demand dari tiap node merupakan nilai satuan, maka kapasitasnya secara sederhana berarti tiap sub-pohon hanya boleh mengandung node paling banyak senilai konstanta kapasitas.

Di paper tersebut, persoalan CMST diceritakan sebagai relaksasi dari persoalan Capacitated Vehicle Routing Problem. Untuk menyelesaikan persoalan ini langkah yang dilakukan antara lain pengelompokan node (node clustering), pertukaran node antar kelompok (local search), dan terakhir mencari MST untuk tiap kelompok menggunakan algoritma Prim. Adapun letak penggunaan algoritma ACO adalah pada pengelompokan node. Pembentukan kelompok node dilakukan sedemikian rupa sehingga ketika menggabungkan dua buah kelompok menjadi kelompok baru batasan kapasitasnya tetap terpenuhi. Pemodelan jalur semut atau pengambilan keputusan terletak pada menentukan kelompok mana yang akan digabung menjadi kelompok baru. Salah satu kriterianya adalah nilai saving yang dinyatakan sebagai nilai penghematan jika dua buah cluster digabung menjadi satu. kriteria ini digabung dengan distribusi feromon dalam ruang keputusan yang jumlah pilihannya dibatasi membentuk distribusi peluang (probability density function) yang dimanfaatkan untuk mengambil keputusan secara acak.

Langkah berikutnya adalah pertukaran antar node di satu kelompok dengan node di kelompok lain. Karena tidak dijelaskan lebih lanjut mengenai kriteria dampak penukaran dua buah node dan kalaupun menggunakan nilai saving saya hampir tidak menemukan perbedaan dengan langkah sebelumnya, saya tidak mengimplementasi langkah ini dan lanjut ke algoritma prim. Sebagai percobaan, sampel data kasus diambil dari OR Library. Berbeda dari paper tersebut yang membandingkan algoritma versi ACO dengan algoritma metaheuristik lain (Tabu Search dan Evolutionary), dalam percobaan yang saya lakukan solusi dibandingkan dengan solusi upper bound (karena persoalannya minimasi) yaitu tiap node terhubung ke node akar. Berdasarkan hasil percobaan menggunakan kasus tc80 solusi yang dihasilkan algoritma ACO yang saya implementasi berhasil mengurangi total cost sebesar 80% (biaya solusi < 20% biaya asal) dari nilai upper bound tersebut.

Program tsb saya implementasikan menggunakan delphi. Namun, sepertinya implementasi versi saya masih termasuk lambat (mungkin karena ada banyak operasi set, konversi string, dan array dinamik). Jadinya ketika mengikuti parameter di paper tersebut, untuk kasus di atas (80 node+1 node akar) perlu waktu rata-rata 20 menit (80 semut, 800 iterasi yang ditotal jadi 16000 percobaan) padahal setelah 200an iterasi hampir tidak lagi ditemukan solusi yang lebih baik dan sepertinya tidak perlu semut sebanyak itu untuk simulasi (10 semut sepertinya cukup walau untuk konvergen ke solusi terbaik ada di iterasi 250an).

Sebetulnya sebelum uts ini hal serupa (mengimplementasi dan mereview paper) juga dilakukan dan topik yang saya pilih mengenai contour correspondence yang dimodelkan menjadi persoalan Quadratic Assignment Problem. Tapi sepertinya lebih enak membahas yang ini dulu, hehehe

Flood Fill merupakan teknik mengarsir yang menggunakan analogi menuangkan cat warna di satu titik yang kemudian cat tersebut akan bergerak meluas hingga merata (menutupi seluruh area yang dibatasi). cat akan meluberi daerah yang memiliki predikat sama (warna yang sama, atau bukan warna tertentu). Adapun jika digunakan predikat bukan warna tertentu maka dikenal sebagai variannya yaitu boundary fill. titik awal warna dituang dinamakan dengan titik bakar.

Pada kuliah grafika komputer, dan buku teksnya. Algoritma Floodfill dideskripsikan secara rekursif sbb

{menggunakan predikat warna sama dengan warna titik bakar}
procedure floodfill(p:point, i:image; newcolor:color);
var
   oldcolor : color;
begin
   oldcolor := i.pixel[p.x][p.y];
   i.pixel[p.x][p.y] := newcolor;
   {i.pixel[neighbor.x][neighbor.y]=oldcolor merupakan predikat sebagai syarat rekurens}
   {tetangga kiri}
   if (p.x > i.left_bound) and (i.pixel[p.x-1][p.y]=oldcolor) then floodfill(point(p.x-1, p.y), i, newcolor);
  {tetangga kanan}
  if (p.x < i.right_bound) and (i.pixel[p.x+1][p.y]=oldcolor) then floodfill(point(p.x+1, p.y), i, newcolor);
  {tetangga atas}
  if (p.y > i.top_bound) and (i.pixel[p.x][p.y-1]=oldcolor) then floodfill(point(p.x, p.y-1), i, newcolor);
  {tetangga bawah}
  if (p.y < i.bottom_bound) and (i.pixel[p.x][p.y+1]=oldcolor) then floodfill(point(p.x, p.y+1), i, newcolor);
end;

Algoritma di atas merupakan contoh generik untuk citra 2D. Untuk citra 3D algoritma di atas dapat diperluas dengan ekspresi yang sama, yang berbeda hanyalah rekursif tetangganya yang bertambah yaitu tetangga depan dan tetangga belakang.

{menggunakan predikat warna sama dengan warna titik bakar}
procedure floodfill(p:point3d, i:image; newcolor:color);
var
   oldcolor : color;
begin
   oldcolor := i.pixel[p.x][p.y][p.z];
   i.pixel[p.x][p.y][p.z] := newcolor;
   {i.pixel[neighbor.x][neighbor.y][neighbor.z]=oldcolor merupakan predikat sebagai syarat rekurens}
   {tetangga kiri}
   if (p.x > i.left_bound) and (i.pixel[p.x-1][p.y][p.z]=oldcolor) then floodfill(point(p.x-1, p.y,p.z), i, newcolor);
  {tetangga kanan}
  if (p.x < i.right_bound) and (i.pixel[p.x+1][p.y][p.z]=oldcolor) then floodfill(point(p.x+1, p.y,p.z), i, newcolor);
  {tetangga atas}
  if (p.y > i.top_bound) and (i.pixel[p.x][p.y-1][p.z]=oldcolor) then floodfill(point(p.x, p.y-1,p.z), i, newcolor);
  {tetangga bawah}
  if (p.y < i.bottom_bound) and (i.pixel[p.x][p.y+1][p.z]=oldcolor) then floodfill(point(p.x, p.y+1,p.z), i, newcolor);
  {tetangga depan}
  if (p.z > i.front_bound) and (i.pixel[p.x][p.y][p.z-1]=oldcolor) then floodfill(point(p.x, p.y,p.z-1), i, newcolor);
  {tetangga belakang}
  if (p.z < i.rear_bound) and (i.pixel[p.x][p.y][p.z+1]=oldcolor) then floodfill(point(p.x, p.y,p.z+1), i, newcolor);
end;

algoritma rekursif memang memiliki ekspresi yang sederhana namun seringkali implementasinya terganggu dengan pesan stack overflow yang diakibatkan ukuran stack di heap untuk procedure call yang terbatas. Hal ini dapat diatasi dengan mengubah algoritma di atas menjadi iteratif dan mensimulasikan stack sebagai struktur data eksternal. Apakah kedua hal tersebut sudah cukup? tentu belum, jika mekanisme mencari tetangganya sama persis dengan algoritma rekursif di atas maka justru algoritma versi iteratif lebih buruk performanya. Kita perlu mengoptimasi pencarian tetangga sehingga ukuran untuk stack dapat dikurangi.

Untuk mengurangi pengisian stack tersebut kita dapat mengubah ide dari algoritma di atas dengan cara memusatkan perhatian pada tetangga yang berada di satu sumbu. Misalkan kita perhatikan di sumbu vertikal (sumbu Y), maka kita akan mendapatkan sebuah rentang minimum-maksimum yang memiliki predikat sama. Rentang ini kemudian ditelusuri. Selama menelusuri rentang tersebut, barulah kita memperhatikan tetangga di sumbu lainnya (sumbu X). Karena kita secara konstan menelusuri rentang vertikal maka kita cukup memperhatikan perubahan di tetangga. Kita hanya perlu menyimpan ke stack, tetangga yang baru kita temukan pertama. Tetangga yang letaknya di bawah tetangga tersebut jika memiliki predikat yang sama tidak perlu disimpan karena pasti dikunjungi ketika titik tersebut diproses pertama kali secara vertikal.

Algoritma tersebut diekspresikan dalam kode berikut:

{menggunakan predikat warna sama dengan warna titik bakar}
procedure floodfill(p:point3d, i:image; newcolor:color);
var
   oldcolor : color;
   stpt : stack;// stack of point3d;
   pt : point3d;
   y1, y2, yy : integer;
   span_left, span_right, span_front, span_rear: boolean;
begin
   oldcolor := i.pixel[p.x][p.y];
   stpt.push(p.x,p.y,p.z);
   while not stpt.is_empty() do begin
      pt := stpt.pop();
      y1 := pt.y;
      while (y1 > i.top_bound) and (i.pixel[pt.x][y1-1][pt.z]=oldcolor) do dec(y1);
      y2 := pt.y;
      while (y2 < i.bottom_bound) and (i.pixel[pt.x][y1+1][pt.z]=oldcolor) do inc(y2);
      span_left := false;
      span_right := false;
      span_front := false;
      span_rear := false;
      for yy := y1 to y2 do begin
         if (pt.x > i.left_bound) then begin
            if not span_left and (i.pixel[pt.x-1][yy][pt.z]=oldcolor) then begin
               span_left := true;
               stpt.push(pt.x-1, yy, pt.z);
            end else if span_left and not (i.pixel[pt.x-1][yy][pt.z]=oldcolor) then span_left := false;
         end;
         if (pt.x < i.right_bound) then begin
            if not span_right and (i.pixel[pt.x+1][yy][pt.z]=oldcolor) then begin
               span_right := true;
               stpt.push(pt.x+1, yy, pt.z);
            end else if span_right and not (i.pixel[pt.x+1][yy][pt.z]=oldcolor) then span_right := false;
         end;
         if (pt.z > i.front_bound) then begin
            if not span_front and (i.pixel[pt.x][yy][pt.z-1]=oldcolor) then begin
               span_front := true;
               stpt.push(pt.x, yy, pt.z-1);
            end else if span_front and not (i.pixel[pt.x][yy][pt.z-1]=oldcolor) then span_front := false;
         end;
         if (pt.z < i.rear_bound) then begin
            if not span_rear and (i.pixel[pt.x][yy][pt.z+1]=oldcolor) then begin
               span_rear := true;
               stpt.push(pt.x, yy, pt.z+1);
            end else if span_rear and not (i.pixel[pt.x][yy][pt.z+1]=oldcolor) then span_rear := false;
         end;
         i.pixel[pt.x][yy][pt.z] := newcolor;
      end;
   end;
end;

Sebetulnya UTS hari ini (jam 9 nanti) tentang intelejensia kolektif yang bahannya tentang EA (evolutionary algorithm) dan ACO (ant colony optimization), tapi yang dibaca sebelum tidur malah buku Practical Software Maintenance-nya Tom Pigoski. Kebetulan memang untuk kuliah pengujian perangkat lunak kebagian bab tentang testing pada saat maintenance. Baru baca bab-bab awal. Persepsi awal tentang isinya lumayan menarik sambil merefleksikan masa-masa yang pernah dialami (sebetulnya istilah pengalaman lebih singkat tapi punya makna konotasi yang bisa baik bisa juga jelek ).

Singkat kata, dari bacaan awal bisa diceritakan bahwa perawatan (padanan untuk maintenance) seringkali memiliki banyak interpretasi. Perawatan bisa jadi merupakan pengeluaran yang kecil dibanding biaya pengembangan atau justru menjadi pengeluaran utama dibanding biaya pengembangan. Interpretasi pertama dicirikan dengan adanya alokasi sekitar 10% untuk ‘support & maintenance‘, sedangkan interpretasi kedua mengalokasikan 80% untuk hal tersebut. Pertanyaan pertama yang muncul adalah “Yang mana yang lebih baik? untuk developer, maintainer, dan customer” (pengguna dibedakan dengan customer dan dikesampingkan dulu karena berdasarkan buku tsb, tersangka utama penyedot biaya perawatan adalah pengguna).

Pihak yang melakukan perawatan pun bisa jadi bukan pengembang perangkat lunak awal melainkan pihak lain yang mengkhususkan diri di bidang perawatan perangkat lunak (itu cerita di bukunya dengan situasi di US, kalau di Indonesia ada tidak yah (organisasi spesialis perawatan)?).

Sebelum mencoba menjawab pertanyaan di atas, cerita lain tentang isi buku tsb adalah bahwa aktivitas yang dilakukan dalam proses perawatan bisa digolongkan menjadi 3 kelompok, yaitu:

• corrective
• adaptive
• perfective/improvement

Kunci dari keberhasilan proses perawatan (lagi-lagi berdasarkan buku tsb.) adalah mengklasifikasikan hal-hal yang perlu berubah ke dalam kelompok tersebut. Pengklasifikasian di atas disusun berdasarkan prioritas dan resikonya. Kisaran proporsi ketiga kelompok tersebut berturut-turut 20%, 25%, dan 55%. intinya, kebanyakan dari perawatan adalah improvement. Celakanya permintaan atas improvement ini nggak melihat struktur perangkat lunak ada. Jadi ingat pernah ada yang minta ganti grid (standar VCL Delphi) biar tampak lebih menarik (Dibandinginnya dengan DataGrid defaultnya Flex). Ibaratnya, lagi nyetir mobil kecepatan tinggi tiba-tiba punggung itu gatal!.

IMHO, situasinya akan lebih enak kalau deskripsi sistem yang mau dibikin itu bisa selesai di 10% (lebih enak lagi kalau verifikasi kesesuaian dengan spesifikasinya bisa dilakukan otomatis menggunakan metode formal) waktu total pengembangan sistem sehingga 90 persen sisanya adalah proses maintenance & testing untuk menyesuaikan dengan kebutuhan yang diyakini selalu berubah. Aspek adaptif dan perfektif berhubungan dengan antarmuka dengan sistem lain (infrastruktur perangkat keras, API, sistem operasi, target deployment platform), dan manusia (user interaction).

Saya sendiri sebetulnya lebih tertarik ke interaksi. Bayangan saya adalah user interface yang dinamis (bukan sekedar style/theme yang hanya mencakup aspek estetis, tetapi juga struktur hierarki, tata letak, dan pemilihan komponen interaksi) yang menyesuaikan dengan target deployment platform (desktop, web, mobile) dan selera pengguna. Untuk itu diperlukan tool untuk membantu perancang interaksi (paradigma Microsoft) atau menjadi fasilitas yang terintegrasi dengan sistem yang digunakan oleh pengguna (end-user development). Satu hal yang pasti dengan adanya sistem antarmuka yang dinamis dan universal ini lahir kebutuhan baru yaitu pembuatan manual penggunaan yang otomatis juga.

Kalau diinventarisasi, untuk menyelesaikan persoalan di atas (pembangkitan antarmuka dan manual ~ user interface and instruction manual generation) perlu beberapa hal berikut:

• pemodelan domain arsitektur informasi, interaksi, dan kapabilitas platform (domain spesific modeling, MDA) termasuk model pembangkitan teks narasi untuk menceritakan skenario interaksi(natural language processing) menjadi bahasa spesifik (domain spesific language).
• teknik kompilasi, khususnya untuk proses generation dari domain spesific language ke kode target platform
• pengetahuan tentang interaksi (teori aktivitas dan teori kognitif) yang menjadi batasan pada proses pencarian solusi
• Teknik optimasi kombinatorial untuk menghasilkan solusi berupa konfigurasi yang diharapkan

Tampak terlalu besar cakupannya untuk dijadikan tesis (mungkin harusnya jadi program riset kk/unggulan?) dengan sisa waktu kurang dari satu semester. Mungkin bisa dibatasi lagi supaya lebih layak mengingat masih ada konsep-konsep yang sifatnya vague.

Fenomena ini terjadi di forum diskusi/mailing list di Indonesia.

A: Mas, nanya kalo X gimana caranya? (X = persoalan)
A: kok nggak ada yang jawab yah? (merasa penting sehingga harus dijawab)
A: Oh, sudah terjawab. (sudah mendapat jawaban, mungkin dengan meneror anggota lain atau dari forum tetangga)

suatu ketika ada anggota baru yang kebetulan menghadapi persoalan yang sama (X), Menggunakan fitur pencarian dan menemukan thread tersebut. Merasa tidak mendapatkan jawaban kemudian membuat thread baru. celakanya dengan perilaku yang sama (thread berakhir hanya berisi pertanyaan tanpa jawaban).

Pada akhirnya tidak ada pertambahan pengetahuan melainkan sampah. Situs forum diskusi/mailing list hanya digunakan untuk memenuhi kebutuhan pribadi sebagai tempat konsultasi gratis tanpa terbesit keinginan untuk membentuk pengetahuan bersama.

Convex Hull merupakan persoalan klasik dalam geometri komputasional. Persoalan ini saya ketahui pertama kali ketika lomba pemrograman waktu SMA. Persoalannya digambarkan secara sederhana dalam ruang dimensi dua (bidang) sebagai mencari subset dari himpunan titik pada bidang tersebut sedemikian rupa sehingga jika titik-titik tersebut dijadikan poligon maka akan membentuk poligon yang konveks. Suatu poligon dikatakan konveks jika digambarkan garis yang menghubungkan antar titik maka tidak ada garis yang memotong garis yang menjadi batas luar poligon. Definisi lain dari convex hull adalah poligon yang disusun dari subset titik sedemikian sehingga tidak ada titik dari himpunan awal yang berada di luar poligon tersebut (semua titik berada di batas luar atau di dalam area yang dilingkupi oleh poligon tersebut).

convex hull

Petunjuk untuk menyelesaikan persoalan ini adalah persamaan garis pada bidang. Persamaan garis pada bidang memisahkan bidang menjadi dua bagian yaitu area di sebelah kanan bidang (relatif terhadap orientasi garis). Sebagai contoh garis berorientasi adalah sumbu koordinat. Misalkan saja sumbu vertikal (ordinat, arah orientasi ke atas), seluruh titik di sebelah kanan garis ini memiliki nilai komponen koordinat horizontal (X) yang positif sedangkan seluruh titik di sebelah kiri garis memiliki nilai komponen koordinat horizontal negatif.

Petunjuk di atas dimanfaatkan dengan membuat definisi bahwa garis yang dibentuk oleh titik-titik poligon jika diasumsikan memiliki orientasi yang sama, maka setiap titik berada di sebelah kanan seluruh garis batas tersebut. Definisi ini kemudian dimanfaatkan untuk menentukan aksi awal yaitu memilih titik yang berada paling luar pertama. Mencari titik pertama cukup mudah yaitu cukup memilih titik yang memiliki nilai komponen koordinat (horizontal atau vertikal) yang ekstrim (minimum atau maksimum). Titik-titik convex hull lainnya ditentukan berdasarkan titik pertama tadi.

Algoritma awal yang intuitif dari deskripsi paragraf sebelumnya adalah.

Algoritma tersebut menggunakan pendekatan exhaustive (brute-force). kompleksitas algoritma tersebut mendekati O(n²). Algoritma tersebut dapat dioptimasi dengan membuat agar kumpulan titik-titik tersebut terurut secara lexicografis (urutkan dulu berdasarkan koordinat sumbu-X lalu untuk koordinat pada sumbu-X yang sama urutkan berdasarkan koordinat pada sumbu-Y). Sifat keterurutan ini kemudian dimanfaatkan sehingga pada setiap fase tiap titik hanya dikunjungi satu kali (kompleksitas linier). Adapun fase-fase yang perlu dilalui terdiri dari dua fase yaitu batas bagian atas (upper boundary) dan batas bagian bawah (lower boundary). Misal pada contoh algoritma berikut :

procedure TForm1.ConvexHull( ap: array of TPoint );
var

  pi                : array of integer;
  hull              : array of integer;
  h, i, j, k, l     : integer;
  dx, dy, dx2, dy2  : integer;
  found             : boolean;
begin
  { initialize index }
  setlength( pi, length( ap ) );
  for i := 0 to high( pi ) do
    pi[i] := i;

  { sort the index lexicographically, shown here using simple quadratic complexity sort algorithm }
  for i := 0 to high( pi ) - 1 do begin
    for j := i + 1 to high( pi ) do begin
      if ( ap[pi[j]].X < ap[pi[i]].X ) or ( ( ap[pi[j]].X < ap[pi[i]].X ) and ( ap[pi[j]].Y > ap[pi[i]].Y ) ) then begin
        k := pi[j];
        pi[j] := pi[i];
        pi[i] := k;
      end;
    end;
  end;

  { build upper boundary }
  setlength( hull, 2 );
  hull[0] := pi[0];
  hull[1] := pi[1];
  h := 1;

  for i := 2 to high( pi ) do begin
    found := false;
    for k := 1 to high( hull ) do begin
      dx := ap[hull[k]].X - ap[hull[k - 1]].X;
      dy := ap[hull[k]].Y - ap[hull[k - 1]].Y;

      dx2 := ap[pi[i]].X - ap[hull[k]].X;
      dy2 := ap[pi[i]].Y - ap[hull[k]].Y;

      j := dy * dx2 - dx * dy2;
      { delete previous non-convex edge w.r.t current point }
      if j > 0 then begin
        hull[k] := pi[i];
        setlength( hull, k + 1 );
        found := true;
        break;
      end;
    end;

    { add if current point lies on the right side of previous upper edges }
    if not found then begin
      setlength( hull, length( hull ) + 1 );
      hull[high( hull )] := pi[i];
    end;
  end; 

  { build lower boundary }
  h := high( hull ) - 1;
  for i := high( pi ) downto 0 do begin
    found := false;
    for k := h to high( hull ) do begin
      dx := ap[hull[k]].X - ap[hull[k - 1]].X;
      dy := ap[hull[k]].Y - ap[hull[k - 1]].Y;

      dx2 := ap[pi[i]].X - ap[hull[k]].X;
      dy2 := ap[pi[i]].Y - ap[hull[k]].Y;

      j := dy * dx2 - dx * dy2;
      if j > 0 then begin
        hull[k] := pi[i];
        setlength( hull, k + 1 );
        found := true;
        break;
      end;
    end;

    if not found then begin
      setlength( hull, length( hull ) + 1 );
      hull[high( hull )] := pi[i];
    end;
  end;

  { display result }
  Image1.Canvas.Pen.Color := clLime;
  Image1.Canvas.MoveTo( ap[hull[0]].X, ap[hull[0]].Y );
  for i := 1 to high( hull ) do
    Image1.Canvas.LineTo( ap[hull[i]].X, ap[hull[i]].Y );
  for i := 0 to high( hull ) do
    drawpt( ap[hull[i]].X, ap[hull[i]].Y, clRed );

end;

Algoritma di atas terdiri dari tiga bagian yaitu pengurutan titik, penyusunan batas bagian atas, dan penyusunan batas bagian bawah. Pada contoh di atas kompleksitas ditentukan oleh algoritma pengurutan titik yang cenderung kuadratik (O(n²)) untuk mempermudah pemahaman, jika dibutuhkan algoritma pengurutan dapat menggunakan algoritma yang memiliki kompleksitas lebih rendah/linearitmik (O(n.log n)).

Semasa SMA dulu saya sangat tertarik dengan euphoria dunia sains dan teknologi. Masa-masa yang sangat indah ketika bisa bebas bermimpi tentang teknologi tanpa terbebani dengan bagaimana mewujudkannya menjadi sebuah benda nyata yang fungsional. Pada suatu ketika saya ditugaskan untuk membuat sebuah brosur produk. Waktu itu saya terpikir untuk sebuah produk khayalan yang bisa membantu menyerap informasi dari buku tanpa perlu menghabiskan waktu untuk membaca melainkan bisa dilakukan sambil tidur. Ide ini didasari dari kebiasaan saya menghabiskan waktu istirahat untuk membaca buku-buku di perpustakaan sekolah dan kebiasaan tidur di kelas (biarpun duduk paling depan) pada saat jam pelajaran.

Beberapa waktu terakhir tampaknya mimpi waktu itu datang kembali, hanya saja kali ini sepertinya ada kesempatan untuk menyelidiki lebih lanjut apakah ide tersebut bisa diwujudkan atau tidak. Saya sendiri menganggap ide saya waktu sma tersebut masih mungkin diwujudkan setelah mempelajari beberapa informasi mulai dari model-model kemampuan berpikir dari bidang artificial intelligence, fisiologi otak dari perkembangan ilmu biomedik dan neuroscience, serta sedikit pengetahuan mengenai fisika (elektromagnetik) -kimia (organik dan molekuler).

Pada dasarnya untuk mewujudkan ide di atas adalah dengan membuat model kognitif manusia sebagai mesin komputasi atau dengan kata lain mensimplifikasi otak manusia sebagai komputer konvensional (von neumann). Alur proses yang terjadi antara lain :
- akuisisi informasi dari sumber fisik (buku)
- transfer informasi tersebut menjadi informasi yang disimpan dalam filesystem otak pada lokasi yang sesuai.
proses di atas diasumsikan representasi informasi yang digunakan di otak, fungsi untuk mentransformasi representasi informasi dan mentransfer informasi ke dalam otak, dan pemetaan organisasi informasi di otak sudah diketahui. Ketiga asumsi tersebut sudah ada beberapa teori serta studi yang dilakukan tetapi mungkin masih jauh dari cukup.

Otak manusia bisa didekomposisi berdasarkan fungsi dan anatominya. Sesuai dengan konteks di atas, Fungsi untuk pembelajaran dan memori dipercaya berada pada bagian hippocampus, cerebral cortex, cerebellum, dan amygdala. hippocampus merupakan bagian yang banyak dipelajari terkait dengan fungsi ingatan. cerebellum atau otak kecil dipercaya berfungsi mengendalikan sistem motorik. amygdala dipercaya mengendalikan informasi yang terkait ingatan respon emosional. cerebral cortex, di lain pihak mengendalikan ingatan-ingatan yang terkait dengan informasi sensorik, dan ingatan lainnya. cortex, kalau tidak salah ingat juga banyak menginspirasi teknik-teknik dalam computer vision.

Dari keempat bagian dari otak tersebut, yang banyak dipelajari khususnya mengenai ingatan adalah hippocampus dan neocortex. Hebb menganjurkan sebuah teori mengenai pembentukan ingatan sebagai hubungan antara dua buah sel syaraf (sinapsis) yang diberi rangsangan secara simultan yang menjadi pedoman dalam perkembangan teknik artificial neural network (Hebbian learning). Berdasarkan teori ini, ingatan (baik jangka pendek maupun jangka panjang) dianggap sebagai struktur keterhubungan antar sel. Ternyata, ada mekanisme lain yang juga berperan dalam ingatan khususnya ingatan jangka panjang. Todd Sacktor – Profesor neurologi dari amerika – mengungkap mekanisme molekuler yang mengelola “data center” tersebut yaitu enzim isoform protein kinase C bernama protein kinase MZeta (PKMZeta). Studi lebih lanjut menunjukkan dengan menggunakan obat untuk menghambat kerja protein tersebut berdampak pada kehilangan ingatan terhadap hal yang telah dipelajari selama satu hari, dan bahkan sebulan sebelumnya. obat penghambat tersebut tidak berdampak permanen atau menimbulkan kerusakan pada otak. Beberapa publikasi lanjutan dari Dr. Sacktor menjabarkan tentang jaringan regulatori enzim tersebut yang diharapkan dapat membantu usaha pengobatan penyakit seperti alzheimer.[1]

Untuk mewujudkan rekayasa otak diperlukan hal-hal seperti : pemahaman mengenai mekanisme kerja otak dari tataran molekuler hingga fenomena abstrak seperti ingatan dan perilaku, instrumentasi untuk pengukuran aktivitas yang terjadi di otak, dan instrumen untuk memanipulasi aktivitas otak. Ada berbagai macam teknik yang saat ini diketahui untuk melakukan stimulasi aktivitas di otak baik berupa implantasi perangkat yang berfungsi sebagai “pacu otak” (deep brain stimulation) maupun perangkat yang hanya perlu dikenakan (wearable) yang berbasis pada gelombang elektromagnetik (transcranial magnetic stimulation). Ada juga gosip yang beredar tentang pengembangan alat untuk komunikasi telepati buatan untuk kepentingan militer[2].

Mudah-mudahan di masa depan kita sempat merasakan teknologi ini.

Hari pertama kuliah if 6099 (tesis), ada sedikit pencerahan dibanding kuliah metode penelitian semester lalu. Khususnya pada definisi mendasar ‘informatika’ dan ‘algoritma’ selain cakupan dan batasan dari tugas akhir sarjana dengan tesis magister.

Dari sepuluh orang yang hadir hari ini, ternyata ketika diminta menuliskan definisi ‘informatika’ bisa didapat 10 definisi yang berbeda. Kalau cara anak sma atau mahasiswa sarjana mungkin mudah saja ‘mencontek’ dari definisi yang sudah dipublikasi dan diduplikasi di ranah internet, tetapi bagi mahasiswa pasca sarjana pendefinisian informatika sebagai ‘lahan garapan’ tentu mencerminkan visi dan akumulasi pengalaman historis.

Beberapa definisi yang sempat terbahas di kelas ternyata tidak lepas dari istilah ‘komputer’. Adapun komentar yang muncul adalah, kalau komputer itu merupakan bagian dari esensi mendasar informatika mengapa istilah ‘informatika’ tidak mengandung suku kata dari ‘komputer’?

Kemudian dilontarkan lagi pertanyaan mengenai kata kunci atau akar kata dari istilah ‘informatika’. Kebanyakan jawaban adalah hanya satu kata yaitu ‘informasi’ yang menyulut komentar berikutnya yaitu “jika memang hanya informasi, mengapa namanya tidak departemen informasi saja?”. Ada salah satu jawaban yang menyebut bahwa kata ‘informatika’ bisa disusun dari dua kata yaitu ‘infor’ yang berasal dari informasi dan ‘matika’ yang berasal dari…
…
..
otomatika (catatan: bukan matematika).

Definisi yang saya tulis sebagai jawaban pertanyaan waktu itu yang tersingkat dalam benak saya adalah “bidang ilmu yang mengkaji otomatisasi pengolahan informasi”. Jawaban terpendek yang sudah mencakup objek (informasi), predikat (pengolahan), dan kata sifat (otomatis). Walaupun masih meleset karena ternyata kerekayasaan juga masuk dalam kajian informatika. ha ha ha.

Jadi kata kunci hari itu adalah otomatis yang didefinisikan sebagai “perubahan keadaan tanpa campur tangan manusia (saat eksekusi/dijalankan)”. Kualitas ‘otomatisasi’ dijadikan sebagai ukuran keberhasilan terhadap aktivitas yang diotomatiskan (yang secara mendasar di dalam informatika kita kenal sebagai algoritma).

Lalu mengenai perbedaan antara cakupan tugas akhir sarjana dengan tesis magister dideskripsikan sebagai sebuah analogi membuat jembatan untuk menyeberang. Suatu tugas akhir sarjana hanya mensyaratkan mahasiswa agar ‘berhasil menyeberang’ atau ’sampai di seberang’. Adapun pertanggung jawaban yang dibutuhkan adalah ceritera pengalaman ketika menyeberang serta keputusan-keputusan yang diambil selama perjalanan. Sedangkan pada tesis magister, ada tambahan pertanggung jawaban selain prasyarat bahwa harus sudah bisa menyeberang/sampai di seberang yaitu nilai tambah (atau nilai kompetitif) dari jembatan yang dibuat. Nilai kompetitif inilah yang perlu dicari/digali melalui proses yang bernama penelitian. Memang tidak jarang ada tugas akhir sarjana yang memiliki kualitas seperti tesis magister jika kondisinya mendukung, namun jika tesis magister hanya memiliki kualitas seperti tugas akhir sarjana tentu menjadi hal yang menyedihkan.

disclaimer
cerita berikut adalah analogi terhadap persoalan matematis yang sedang saya hadapi, tidak ada hubungannya dengan perilaku manusia yang digambarkan.

misalkan sedang ada acara konser musik di suatu aula besar sehingga penontonnya duduk secara teratur pada kursi yang telah disediakan. katakanlah penonton bisa dikelompokkan menjadi penonton pria dan wanita. masing-masing bisa diidentifikasi melalui pakaian yang dikenakan. Umumnya para wanita mengenakan pakaian berwarna gelap sedangkan pria mengenakan pakaian yang bervariasi antara terang dengan gelap. walaupun demikian, karena pada umumnya wanita yang datang adalah socialista, kita bisa berasumsi bahwa para wanita akan duduk berdekatan satu sama lain.

sekarang seorang pengamat pria ( A ) duduk di balkon sehingga bisa melihat semua penonton di bawah namun tidak jelas. seorang teman ( B ) lalu menggambar peta yang berisi daerah mana yang kira-kira merupakan wanita (hanya berdasarkan pengamatan dari jauh juga). diasumsikan bahwa semua wanita yang hadir ditandai oleh B namun B tidak menjamin bahwa pria juga termasuk dalam tanda di peta yang digambar tersebut (dan memang ada pria yang ternyata ‘dicurigai’ sebagai wanita).

yang menjadi persoalan adalah, bagaimana caranya menseleksi pada tiap tanda yang dibuat oleh B agar A dapat menghapus tanda yang sebetulnya berisi pria sehingga pada akhirnya tiap tanda betul-betul menunjukkan lokasi tempat duduk yang diisi oleh wanita?

persoalannya mungkin tampak sederhana, tapi bagi saya yang nggak mudeng dengan topik probabilitas dan statistik (akibat banyaknya istilah yang aneh-aneh di buku berbahasa Indonesia dengan bahasa Inggris). bingung juga memodelkan persoalannya dalam konteks probabilitas.

beberapa kata kunci petunjuk/asumsi yang mungkin bisa digunakan:
- tempat duduk tersebar sebagai struktur grid regular
- bayesian
- markov random field

silakan isi jawaban berupa pemodelan persoalan dan algoritma penyelesaiannya pada komentar yang telah disediakan, hadiah $10 (atau akun rapidshare premium untuk 1 bulan) menunggu bagi penjawab pertama yang memuaskan (jawaban akan diuji terlebih dahulu). (hadiah akan ditransfer melalui paypal atau dikirm via e-mail (untuk akun rapidshare premium))

Sebetulnya sedang asik mengembangkan framework Web yang terinspirasi dari berbagai CMS (Django, WordPress, dan Drupal) lalu membaca e-mail dari milis HMIF yang mencantumkan tautan ke situs kampanye pilpres 2009 yang akhirnya penasaran ingin tahu apa engine/web framework/cms yang digunakan.

situs SBY-Boediono ternyata menggunakan drupal, Megawati-Prabowo menggunakan Joomla, dan JK-Wiranto menggunakan wordpress. tidak sulit sebetulnya untuk mengetahui apa engine yang digunakan apalagi untuk engine yang bersifat kode terbuka (open-source). kesimpulannya, tidak ada yang menggunakan cms buatan sendiri.

mengapa menyebut ‘tidak ada yang menggunakan cms buatan sendiri’?

jawabannya sederhana saja, pada saat tulisan ini dibuat pada situs megawati prabowo dan SBY-Boediono tercantum penanda Hak Cipta, atau Copyright ( © ) dan tentu saja pada situs yang mencantumkan tanda copyright tersebut jejak-jejak penanda bahwa situs tersebut dibuat menggunakan framework yang sudah ada tidak dimunculkan (coba saja cari kata ‘drupal’ di halaman situs SBY-Boediono atau cari kemunculan kata ‘joomla’ di situs Mega-Prabowo).

Memang ternyata walaupun hanya situs JK-Wiranto yang penampilannya kacau waktu dibuka, tetapi tidak menyatakan tanda copyright pengembang situs bahkan tetap mencantumkan atribut copyright milik wordpress serta tautan ke situs WordPress.

Catatan:

1: What is the license for Drupal?

Drupal and all contributed files hosted on Drupal.org are licensed under the GNU General Public License, version 2 or later. That means you are free to download, reuse, modify, and distribute any files hosted on Drupal.org’s CVS repository under the terms of either the GPL version 2 or version 3, and to run Drupal in combination with any code with any license that is compatible with either versions 2 or 3, such as the Affero General Public License (AGPL) version 3.

Joomla is free, open, and available to anyone under the GPL license.

now who’s conform to these licenses?

Prosesor multicore sudah tidak asing tetapi aplikasi yang umumnya dikembangkan biasanya hanya terdiri dari satu thread. Sejak dahulu ternyata sudah ada Win32 API untuk menentukan afinitas proses/thread ke prosesor tertentu. Kode di bawah menggunakan delphi 7.

Mendapatkan Jumlah core/Prosesor

var
  sinfo : TSystemInfo;
begin
  GetSystemInfo(sinfo);
  { jumlah prosesor ada di field dwNumberOfProcessors }
  showmessage(inttostr(sinfo.dwNumberOfProcessors));

Menentukan Afinitas ke core tertentu
Afinitas ke core menggunakan bit vector. Tiap 1 bit diasosiasikan ke core tertentu mulai dari LSB. karena tipe data yang dilemparkan ke fungsi tsb adalah 32 bit unsigned integer maka mungkin maksimum prosesor yang bisa diakses sejumlah 32.

berikut ini contoh kode agar aplikasi yang sedang berjalan hanya menggunakan core pertama (cpu0) saja.

SetProcessAffinityMask(GetCurrentProcess, 1);

berikut ini contoh kode agar aplikasi yang sedang berjalan hanya menggunakan core pertama (cpu0) dan kedua (cpu1).

SetProcessAffinityMask(GetCurrentProcess, 3);

sedangkan berikut ini contoh kode agar aplikasi yang sedang berjalan hanya menggunakan core kedua (cpu0) saja.

SetProcessAffinityMask(GetCurrentProcess, 2);