Software Restructuring

by DEWA


Menurut Chikofsky dan Cross II, restructuring adalah proses transformasi dari satu bentuk representasi ke bentuk representasi lainnya pada level abstraksi yang sama, ketika memelihara perilaku dari sistem. Kata “restructuring” menjadi sangat populer digunakan untuk transformasi dari souce code ke souce code program yang tidak terstruktur ke bentuk program yang lebih terstruktur, contoh program yang dibuat dengan menggunakan bahasa pemrograman pascal diubah dan dibuat dengan menggunakan bahasa pemrograman visual basic. Akan tetapi, makna ini menjadi semakin luas artinya, karena tidak hanya melibatkan source code program lagi. Normalisasi data misalnya, merupakan restrukturisasi antar data yang akan meningkatkan model data logical di dalam proses pendesainan database. Banyak tipe dari restructuring yang dapat dilakukan lewat pengetahuan mengenai teknik pemrograman tanpa harus mengetahui logika dari program itu sendiri. Misal, struktur “IF” bisa diganti dengan struktur “CASE” ataupun sebaliknya tanpa harus mengetahui logika program dibalik kondisi ini.

Restructuring juga sering digunakan sebagai bentuk preventif dalam software maintenance untuk memperpanjang lifetime dari sistem yang bersangkutan ataupun digunakan untuk menyesuaikan sistem yang akan diimplementasikan di platform hardware / software yang baru.

Kegunaan

  • Untuk membuat versi baru dari sebuah software dimana dapat berjalan pada platform yang berbeda misal : hanya dapat berjalan pada desktop, meneluarkan versi baru yang dapat berjalan pada web ataupun mobile.
  • Memaksimalkan fungsional software yang akan direstructuringkan.
  • Meminimalkan requirement kebutuhan pada software yang direstructuringkan.
  • Memperpanjang daur hidup dari sebuah software dengan cara menyesuaikan baik dari software dan hardwaer terbaru.
  • Menurunkan biaya maintenance.
  • Meningkatkan kemampuan software untuk digunakan ulang.

Mekanisme Kerja

Sistematik proses restructuring dapat mengimprovisasi cohesion dan coupling atribut dari sebuah sistem.

1.       Lokasikan modul dengan level cohesion yang  rendah dan tentukan modul mana yang memiliki desain yang paling membutuhkan restructuring diantara semua modul yang ada dari semua project.

2.       Lakukan reduksi identifikasi pada modul yang memiliki design kurang didapat dari hasil proses pertama.

3.       Kemudian lokasikan modul yang overmodularized yang dapat meningkatkan coupling pada sebuah sistem dan mendekomposisinya ulang.

Selama restrukturisasi, dekomposisi harus mendahului komposisi karena potensi keberadaan sebagian modul/modul yang digunakan pada setiap komponen output yang digunakan oleh dierent sebuah modul.

Metode Yang Sudah Ada

  • Slicing And Restructuring

Adalah metode yang memanfaatkan gagasan kekuatan modul (kohesi).  Mereka mengeblok pengolahan yang mirip dengan ‘potongan data’ dari Bieman dan Ott (1994). Sebuah blok pengolahan adalah sekelompok token data dengan data atau hubungan kontrol ketergantungan dengan variabel output. Sebuah aturan mengakui fungsi modul ‘logis asosiasi yang bergantung bersama-sama pada output. Mereka memperlakukan masing-masing fungsi secara logis diasosiasikan sebagai sebuah blok pengolahan. Sayangnya, analisis kode program tidak dapat selalu secara otomatis mendeteksi secara logis terkait fungsi. Pemeriksaan dependensi saja tidak dapat menentukan apakah suatu predikat variabel digunakan untuk memilih fungsi atau untuk menghitung fungsi.

  • Finding Hierarchical Relationships

Choi dan Scacchi (1990) mengusulkan restrukturisasi proses untuk mengubah hubungan antara modul dari hubungan sumber daya tukar hubungan hirarkis. Di sini, les sumber diperlakukan sebagai modul. Sumber daya-tukar hubungan yang diwakili oleh sumber daya-ow Diagram (RFD) dimana sumber daya ditukar antara modul meliputi tipe data, prosedur, dan variabel. Hubungan hirarkis menunjukkan koneksi kontrol antara modul dan modul kontrol, dan diwakili oleh resource-structure diagram (RSD).

  • A Documentation-based Approach

Tesch dan Klein (1991) mengusulkan sebuah optimasi desain berdasarkan metode pengukuran cohesion dan coupling dari dokumentasi yang ada. Tujuannya adalah untuk mengembangkan bagan hirarki lengkap dari proses terorganisir dalam top-down, optimal fashion. Sebuah ukuran gabungan diformulasikan dari tindakan cohesion dan coupling. Ukuran komposit digunakan untuk mengurai proses dalam sistem menjadi berturut-turut pengelompokan modul pada grafik hirarki dengan mengelompokkan modul yang terkait erat dan memisahkan modul yang melakukan fungsi dierent.

  • Converting Procedural Programs into Object-Module Programs.

Zimmer (1990) menunjukkan konversi program prosedural ke dalam program objek-modul. Baik program asli dan restrukturisasi dilaksanakan dalam FORTRAN. Objek yang dihasilkan modul program memanfaatkan variabel regional yang mensimulasikan variabel modul-scoped digunakan  alam sebuah bahasa berbasis obyek, atau atribut, elds, atau variabel instance yang digunakan dalam sebuah bahasa berorientasi objek. Restrukturisasi membutuhkan pengetahuan semantik dari program termasuk kation Speci cukup formal termasuk invariants negara, pemahaman yang \ koheren Tujuan “segmen kode, dan pemahaman kode rincian Misalnya, data Analisis menentukan dependensi antar variabel, sarang laba-laba disebut.

Contoh Penggunaan

  • Mengimprofisasi gaya coding
  • Melakukan edit dokumentasi
  • Mentransformasi componen pada program (merubah variable, memindahkan ekspresi, mengabstraksikan fungsi, dll)
  • Memperhandal struktur fungsional (merelokasi komponen menjadi modul-modul baru)

Program Code Restructuring Example

A.1. Original Code: print info

/*************************************************************************************
print_info writes given class-inheritance information in three   files, a file named
by an out-parameter `string', a file named by another   out-parameter `output', and
a standard output file.
*************************************************************************************/

void print_info(char *string, char *flag, int print_it, char   *output, int verbose)
{
 save_class *cl;
 children *buffe;
 parent *temp;
 float childof_private_pct = 0.0,
 childof_non_private_pct = 0.0,
 private_pct = 0,34
 non_private_pct = 0;
 FILE *fp,*fd;

 int CTG = 0,
 parent_ct = 0,
 private_ct = 0,
 non_private_ct = 0,
 num_class = 0,
 num_undefined = 0,
 childof_private = 0,
 childof_non_private = 0,
 multiple_inheritance = 0,
 i;

 fp = fopen(string, flag);
 for(cl = class_tree; cl; cl = cl->next)
 {
 if (cl != class_tree)
 num_class++;
 fprintf(fp,"class: %s\tprivate: %d\tdepth: %d\tchild:   %d\tparents: %d\n",
 cl->name, cl->private, cl->inh_depth, cl->child_count,   cl->parent_count);
 fprintf(fp,"defined: %d\n" , cl->defined);
 temp = cl->parent;
 while (temp)
 {
 fprintf(fp, "parent: %s \t %d\n", temp->name,   temp->scope);
 temp = temp->next;
 }
 fprintf(fp, "parent: 0 \t %d\n", 0);
 buffe = cl->child;
 while (buffe)
 {
 fprintf(fp, "child: %s\n", buffe->name);
 buffe = buffe->next;
 }
 fprintf(fp, "child: 0\n");
 if ((cl != class_tree) && cl->not_printed == 1)
 {
 if(cl->private==1)
 {
 childof_private += cl->child_count;
 private_ct++;
 }
 else
 {
 childof_non_private += cl->child_count;
 non_private_ct++;
 }
 cl->not_printed = 0;

 if (cl->parent_count >= 2)
 multiple_inheritance++;

 if (cl->defined == 0)
 num_undefined++;
 }
 }

 fclose(fp);
 if (print_it)
 {
 fd = fopen(output, "a");
 fprintf(fd, "\n\n");
 private_pct = 100 *((float) private_ct) / ((float) num_class);
 non_private_pct = 100 *((float) non_private_ct) / ((float)   num_class);
 childof_private_pct = 100 * ((float) childof_private) /
 ((float)(childof_private + childof_non_private));
 childof_non_private_pct = 100 * ((float) childof_non_private) /
 ((float)(childof_private + childof_non_private));
 fprintf(fd, " Total | %5d\n", num_class);
 fprintf(fd, " Undefined | %5d\n", num_undefined);
 fprintf(fd, "\n\n");
 fprintf(fd, " Private | %5d\n", private_inh);
 fprintf(fd, " Non_private | %5d\n", public_inh);
 fprintf(fd, " Multiple | %5d\n", multiple_inheritance);
 fprintf(fd, "\n\n");
 fprintf(fd, " Private || %5d %4.2f%% | %5d %4.2f%%\n",
 private_ct, private_pct, childof_private, childof_private_pct);
 fprintf(fd, " Non-Private || %5d %4.2f%% | %5d   %4.2f%%\n",
 non_private_ct, non_private_pct, childof_non_private,
 childof_non_private_pct);
 fprintf(fd, "\n\n");
 fprintf(fd, "Nodes ");

 for (i = 0; i <= depth; i++)
 fprintf(fd, "%5d", child_count[i]);

 fprintf(fd, "\n\n\n");
 fclose(fd);

 if (verbose)
 {
 printf("\n\n");
 printf("Total number of classes: %5d\n", num_class);
 printf("Classes with private section: %5d \t %3.2f%%\n",
 private_ct, private_pct);
 printf("Classes without private section: %5d \t   %3.2f%%\n",
 non_private_ct, non_private_pct);
 printf("Num of classes derived from classes with private   sections:\n\
 %5d \t %3.2f%%\n", childof_private, childof_private_pct);
 printf("Num of classes derived from classes without private   sections:\n\
 %5d \t %3.2f%%   \n",childof_non_private,childof_non_private_pct);
 printf("Private inheritance: %5d \n", private_inh);
 printf("Non-private inheritance: %5d \n", public_inh);
 printf("Multiple inheritances: %5d \n",   multiple_inheritance);
 printf("Undefined classes: %5d \n", num_undefined);
 printf("Tree depth: %5d \n", depth + 1);

 for (i = 0; i <= depth; i++)
 printf("Num of nodes in tree level %d: %d\n", i,   child_count[i]);
 }
 }
}

Kesimpulan

Software restructuring seharusnya mudah, efisien, dan semantik lestari. Telah disediakan
restrukturisasi perangkat lunak kerangka di mana struktur desain dapat diekstraksi dari kode, divisualisasikan, dan restrukturisasi. Software analis langsung dapat diterapkan dan disajikan dalam
model, ukuran, operasi restrukturisasi, dan proses restrukturisasi. Langkah-langkah cepat mengidentifikasi komponen yang siap untuk direstrukturisasi. Membayangkan desain tingkat model
memberikan intuisi lebih lanjut untuk membantu calon restrukturisasi pilih, tanpa termasuk semua
rincian dalam kode. Proses restrukturisasi dan prosedur operasional memberikan langkah-demi-langkah untuk mengoptimalkan perbaikan dalam cohesio dan coupling. Sekali lagi, model visualisasi membantu membimbing proses.

Referensi