Arsip mwmag[Files]  [Up]© 2002 PT Masterweb Media

Batak

Sejarah Pengembangan Bahasa Pemrograman Batak

Keputusan Desain

Konsolidasi, Bukan Inovasi

Penutup

Lampiran

Daftar Pustaka

Daftar gambar

  1. Notasi UML sebuah label
Batak

Bernaridho Hutabarat

Subjek bahasa pemrograman adalah suatu rimba raya yang hampir tak terpetakan, tercermin dari banyaknya usulan tentang klasifikasi bahasa pemrograman [APPL1991], dan terlalu banyaknya istilah yang bersifat different thing to different people [APPL1997].

Untuk bahasa yang strongly typed pun rimba raya masalah masih banyak. Ada istilah kelas, tipe, kelas abstrak, tipe data abstrak, parameterized type, dan sebagainya. Hal ini diperparah dengan tidak adanya hirarki tipe yang terpadu.

Terakhir, banyak bahasa pemrograman dirancang dengan tingkat kepaduan konsep (conceptual integrity) yang rendah. Frederick P. Brooks [BROO1975] menyatakan bahwa kepaduan konsep adalah pertimbangan terpenting dalam desain sistem. Lebih baik memiliki sistem yang menghilangkan fitur-fitur anomalis tertentu dan mencerminkan satu set pemikiran desain, ketimbang sistem yang memiliki banyak pemikiran yang bagus tapi tidak terkoordinasikan.”

Pentingnya Bahasa Pemrograman

Besarnya pengaruh bahasa pemrograman tak bisa dibantah. Bahasa pemrograman adalah satu-satunya alat komunikasi programmer dengan komputer, dan salah satu alat komunikasi terpenting antar para programmer. Menara Babel gagal dibangun bukan karena bencana alam, ketiadaan biaya, atau kekurangan jumlah pekerja. Kegagalan disebabkan oleh kekacauan bahasa—komunikasi. Demikian pula kegagalan, keberhasilan, dan produktivitas proyek pembuatan perangkat lunak banyak bergantung dari [keputusan akan] bahasa pemrograman yang dipakai.

Cara pandang untuk melihat peran bahasa pemrograman harus menghindarkan dua ekstrim. Ekstrim pertama adalah bahwa semua bahasa sama saja, cuma berbeda-beda sedikit. Dengan kata lain, bahasa dipandang cuma suatu alat. Ekstrim kedua adalah fanatisme buta terhadap suatu bahasa.

Pendapat Tentang Perancangan Bahasa Pemrograman

Pendapat seseorang tentang upaya perancangan bahasa sangat dipengaruhi oleh kemampuannya menghindari kedua ekstrim di atas. Orang yang berpikir terbuka tidak akan secara serta merta mematahkan semangat untuk merancang bahasa pemrograman baru, terutama bahasa yang ditujukan untuk keperluan khusus. Kelayakan dari sisi ekonomi—penerimaan pasar—perlu dipertimbangkan, namun merupakan masalah tersendiri.

Prinsip-Prinsip Perancangan Bahasa Pemrograman

Ada beberapa prinsip penting perancangan bahasa pemrograman. Yang pertama adalah kepaduan konseptual seperti yang telah dipaparkan sebelumnya.

Prinsip kedua adalah ortogonalitas ([APPL1991], [SEBE1996]). Ortogonal berarti bebas, sementara derajat ortogonalitas berarti tingkat kebebasan untuk membentuk sesuatu yang besar dari hal-hal yang lebih kecil. Bahasa yang tinggi derajat ortogonalitasnya memiliki sedikit pengecualian dalam hal sintaks dan semantik.

Prinsip ketiga diajukan oleh Charles A. R. Hoare—penemu algoritma quick sort—yang berbunyi “Konsolidasi, bukan inovasi.” Artinya, setiap perancang bahasa baru harus senantiasa mengupayakan lebih dulu konsolidasi keputusan-keputusan desain yang bagus dari bahasa-bahasa yang sudah ada, karena sangat kecil kemungkinan ada hal yang betul-betul baru. Tentu saja penerapannya harus diimbangi dengan upaya pencapaian kepaduan konseptual. Tanpa pengimbangan ini, suatu bahasa bisa menjadi amburadul karena asal comot sana comot sini.

Sejarah Pengembangan Bahasa Pemrograman Batak

Awalnya adalah “meditasi” panjang selama hampir 4 tahun; pengembaraan pemikiran tentang apa benang merah dari semua subjek dalam informatika, dalam hal apa semua topik tersebut memiliki kesamaan, dalam hal apa berbeda, dan apa yang benar-benar membedakan? Lebih jauh dari itu, apakah pengajaran dan pemaparan harus serumit yang ada saat ini, apakah tidak bisa dilakukan upaya penyederhanaan terhadap seluruh subjek agar terlihat peta dari seluruh subjek dalam informatika?

Hasilnya telah dimuat dalam karya ilmiah yang dipaparkan di King Mongkut Institute of Technology, Bangkok, 1996. Karya tersebut memuat konsep dasar komputasi: VOTO—Value, Object, Type, Operation—dan bagaimana VOTO akan menyederhanakan pemaparan semua subjek dalam informatika. Lebih jauh, penerapan VOTO dapat memperjelas kesamaan dan perbedaan suatu topik dengan topik lain, dan merangsang siapapun untuk dapat mengajukan pertanyaan yang esensial ke suatu topik.

C++ Sebagai Pemicu

Dalam skala yang kecil, penulis telah menerapkan VOTO untuk mengajar tentang C++ dan pemrograman berorientasi objek di Tokyo, Jepang, 1995. Usai even ini dan presentasi paper di Bangkok, ada keinginan untuk membuat buku C++ seraya mengikuti program S2 di Inggris.

Proyek pembuatan buku ini dibatalkan karena C++ ternyata berkembang makin kompleks dan makin tak karuan, diganti dengan proyek pembuatan buku software engineering. Buku software engineering ini akhirnya usai juga pada awal tahun 1998 [HUTA1999] dan sempat diajukan ke Addison Wesley. Dengan 5 peninjau dan perbandingan 1 setuju lawan 4 menolak, Addison Wesley akhirnya tak menerbitkan buku ini.

Efek Buku Software Engineering

Proses penulisan buku software engineering melibatkan bacaan tentang bahasa pemrograman yang sangat beragam. Nyata bahwa belum ada satu bahasapun yang sangat bagus mengimplementasikan prinsip-prinsip software engineering. Dengan tidak diterimanya buku software engineering, usaha kemudian dialihkan ke upaya perancangan bahasa baru.

Upaya Awal Di STT Telkom

Desain sintaks Batak dimulai dengan mengamati deklarasi tipe, deklarasi objek, dan deklarasi operasi. Mengacu pada prinsip ortogonalitas, diperoleh sintaks yang sangat ortogonal bagi ketiganya. Berikutnya adalah pembuatan hirarki tipe yang terpadu, yang dirasa hilang dari semua bahasa pemrograman yang ada saat ini. Karena sesuatu hal, sintaks yang ortogonal belum dapat dipadukan ke rancangan bahasa pada saat itu. Rancangan pertama Batak usai pada awal tahun 1999 dan masuk ke perpustakaan STT Telkom sebagai karya ilmiah, bekerjasama dengan mahasiswa saat itu bernama Rudy Harinugroho—yang sekarang bekerja di RISTI Telkom.

Keputusan Desain

Bagian berikut memaparkan beberapa keputusan desain dalam Batak disertai alasannya. Keputusan perancangan yang masih belum disertakan dalam parser diberi tanda #.

Pemakaian Kata Module

Berikut contoh sebuah modul.

module m;

interface

type int_array := integer[10];
integer j;

Ekivalensi di C/C++:

typedef int int_array[10];

Ekivalensi di Pascal:

Unit m;

interface

Type int_array = array[1..10] of integer;

implementation

Alasan pemakaian module adalah untuk memudahkan siapa pun memahami makna pemrograman modular. Dalam pengalaman saya selama bertahun-tahun mengajar dan bekerja di industri, terlalu sedikit orang yang mampu menjelaskan apa itu pemrograman modular dan apa itu modul. Banyak yang menyamakan modul dengan function.

Kurang dipahaminya makna pemrograman modular tidak mengherankan karena:

C/C++ tak memakai kata ini secara eksplisit;

C/C++ memakai 2 file untuk module: file header (.h) dan file implementasi (.c, .cpp) yang menyulitkan seseorang untuk melihat bahwa sebuah modul merupakan paduan keduanya;

Java memakai kata yang berbeda: package. Tak ada istilah package programming; yang ada modular programming;

Pascal memakai kata unit. Tak ada istilah unit programming.

Memang adalah mungkin untuk memberi penjelasan bahwa package adalah seperti modul, atau unit pada intinya adalah modul, atau bahwa .h dan .c membentuk sebuah modul, namun:

Tidak cukup banyak buku yang menulis tentang hal ini (kalaupun ada);

Mengapa harus memakai kata lain jika bisa memakai kata yang lebih tepat?

Bagian Interface dan Implementation

Keputusan perancangan ini mengacu kepada hasil rancangan bahasa pemrograman Modula 2—yang pada gilirannya diimplementasikan di Turbo Pascal dan Microsoft Pascal. Kedua bagian ini secara bersama-sama mewujudkan penyembunyian informasi. Perbedaan besar antara Batak dan Pascal dalam menangani bagian interface dan implementation akan dijelaskan pada bagian tentang deklarasi tipe.

Pemakaian Kata Program

Program adalah unit logika translasi, sama seperti sebuah modul. Berbeda dengan modul-modul yang lain, sebuah program adalah module yang khusus:

Tidak bisa dipakai atau diacu oleh module atau program lain;

Tidak memiliki bagian interface dan implementation (implikasi dari butir di atas).

Adalah mungkin untuk membuat keputusan sehingga kata module tetap dipakai. Konsekuensinya, nama modul yang khusus ini juga harus khusus, misalnya: main. Ini berakibat pada pemrosesan semantik yang lebih sulit.

Program yang memakai module m bisa ditulis seperti ini

Program p;

Use (m);

Integer main()
{ return (0); }

Alasan-Alasan Lain

Pemakaian kata program memiliki alasan lain, namun sebelumnya mari kita lihat beberapa bahasa lain yang tidak memakai kata ini.

  1. C/C++ tak memakai kata program. Ini membuat penulisan program (main module) sedikit lebih sederhana.
  2. Java memakai cara yang lebih sulit. Nama program (sekalipun kata-kata program tidak eksplisit) harus identik dengan nama satu-satu tipe (class) yang publik.

Seperti terlihat pada contoh pertama ada deklarasi objek—dalam hal ini variabel—bernama j. Pada deklarasi tersebut terlihat bahwa deklarasi objek bertipe integer dimulai dengan nama tipe.

Hal yang sama juga berlaku pada deklarasi objek yang bertipe program. Dalam contoh terakhir, p adalah objek bertipe program.

Tipe integer dan program berbeda terutama atas operasi yang berlaku. Pada objek-objek bertipe integer berlaku operasi-operasi numerik—aritmetika, algoritma, dan lain-lain—sedangkan pada objek bertipe program—dan module—berlaku operasi compile (translate), sesuai dengan sifatnya sebagai unit logika translasi.

Singkatnya, alasan pencantuman program sebagai nama tipe (di deklarasi program) :

  1. menyamakan persepsi tentang deklarasi objek;
  2. membantu memperjelas konsep VOTO, untuk memperjelas bahwa programmer sedang berhadapan dengan sebuah program, dan objek-objek bertipe program terkait dengan sekumpulan operasi tertentu;
  3. membantu pembuatan hirarki tipe yang terpadu, seperti akan terlihat nanti.

Sampai titik ini, kita secara ringkas telah melihat penerapan 3 dari 4 konsep pada VOTO: Object, Type, Operation. Ada 3 objek: m, j, dan p. Ada 4 tipe yang terlibat: module, integer, int_array, dan program. Ada 3 operasi yang terlibat: assignment (:=), array-typing ([]), use, dan main.

Mengacu kepada prinsip kepaduan konseptual, tersirat bahwa prinsip ini cukup dipenuhi. Semua dapat dijelaskan dengan mengacu kepada konsep tentang objek, tipe, dan operasi.

Catatan:

Deklarasi Tipe

Mari kita buat modul m2 sebagai berikut:

module m2;

interface

type int_array := integer[10];
integer j := -2;
int_array the_array;
integer k := the_array[1];

Dalam kode di atas terlihat ada deklarasi tipe int_array dan object j (selain object ia dan k). Mari kita lihat persamaan keduanya:

Dua keputusan perancangan yang penting pada Batak adalah:

Tidak diambilnya kedua keputusan ini di bahasa-bahasa lain sangat berpengaruh bagi seseorang untuk memahami ekspresi tipe. Selanjutnya pemahaman ekspresi tipe sangat berpengaruh bagi kemampuan seseorang untuk memahami pemrograman (minimal dalam hal penanganan tipe) serta topik-topik pemrograman kompiler.

Berikut adalah gambaran mengapa ketiadaan kedua keputusan di atas berpengaruh bagi susahnya pemahaman ekspresi tipe. Contoh pertama diambil dari C.

typedef int int_array[10];

Sangat sulit melihat ekspresi tipe dalam kasus ini karena operasi pembentukan tipe ( [] ) dan operan lainnya (10) diletakkan pada objek (int_array), bukan pada tipe (int). Andai C membuat deklarasinya seperti di bawah ini, akan lebih mudah memahami ekspresi tipe.

typedef int[10] int_array;    /* int[10] adalah ekspresi tipe */

typedef int_array = int[10]; /* lebih baik lagi */

Contoh kedua diambil dari Pascal.

type int_array = array[1..10] of integer; 
(* assignment memakai lambang = *)
var j : integer;
begin
J := 5; (* assignment memakai lambang := *)
end;

Keputusan perancangan pada Pascal:

Sebagai hasilnya, tetap sangat sulit untuk melihat bahwa kita memberikan ekspresi tipe. Konsekuensi lanjutan, programmer cenderung menjadi penghafal sintaks: sesudah ini lalu itu, dan seterusnya.

Dari contoh yang sama kita bisa melihat kesamaan ekspresi non-tipe dan ekspresi tipe: keduanya adalah ekspresi, dan tiap ekspresi dapat melibatkan operasi dan operan.

Ekspresi numerik (non-tipe) yang diberikan ke j melibatkan operasi dan operan 2.

Ekspresi tipe yang diberikan ke int_array melibatkan operasi [], operan 2, dan operan integer.

Operasi [] bersifat unik. Bila diterapkan pada tipe, ia menjadi operasi pembentuk ekspresi tipe. Sedangkan bila diterapkan pada non-tipe (pada objek, the_array pada contoh) ia menjadi operasi subskrip, untuk mengekstrak suatu elemen dari array.

Operasi-Operasi Deklaratif

Yang dimaksud operasi-operasi deklaratif adalah operasi-operasi yang tak mensyaratkan tanda kurung untuk melingkupi operan-operan. Contoh adalah operasi +. Pemanggilannya 5 + 3, bukan + (5, 3).

Operasi-operasi pembentuk ekspresi tipe ada yang bersifat deklaratif dan ada yang imperatif. Pada bagian berikut ini kita akan melihat operasi-operasi yang deklaratif.

Orientasi Yang Sama Bagi Operasi-Operasi Pembentuk Ekspresi Tipe

Keputusan perancangan lain yang penting pada Batak adalah orientasi yang sama bagi operasi-operasi (deklaratif) pembentuk ekspresi tipe. Keputusan ini sangat berpengaruh bagi kemudahan pembacaan ekspresi tipe yang besar. Module m3 memberi ilustrasi. Nama-nama pada contoh sengaja dibuat kurang user-friendly untuk menunjukkan kemudahan pembacaan ekspresi tipe.

module m3;

interface

type int_array := integer[],
h := integer[]^,
i := integer^[];

Orientasi pembacaan operasi deklaratif pembentuk ekspresi tipe pada Batak adalah dari kanan ke kiri. Operasi ^ berperan sebagai pointer-typing, sehingga ekspresi

integer[]^ dibaca sebagai pointer ke array integer

integer^[] dibaca sebagai array dari pointer ke integer.

Kode di atas bisa ditulis ulang menjadi lebih deskriptif seperti berikut:

type int_array := integer[],
ptr2array_int := integer[]^,
array2int_ptr := integer^[];

Perbandingan tentang cara C/C++ dapat dilihat pada Lampiran.

Pemisahan Item Pada Deklarasi Tipe Dan Deklarasi Objek

Mengacu kepada prinsip ortogonalitas, ada keputusan perancangan pada Batak untuk memiripkan deklarasi tipe dan deklarasi objek. Kemiripan yang dimaksud di sini adalah kesamaan bahwa untuk suatu ekspresi tipe yang sama bisa dideklarasikan lebih dari satu item. Berikut adalah contohnya.

module m4;

interface

type int_array := integer[],
h := integer[]^,
i := integer^[];

char[] a, b, c;
integer j := 1, k, l;

Pada baris 5 sampai 7 item-item yang dideklarasikan adalah item-tipe. Pada baris 9 dideklarasikan 3 objek dengan ekspresi tipe char[]. Pada baris 10 dideklarasikan 3 objek dengan ekspresi tipe integer.

Ada 2 keuntungan dari keputusan perancangan ini:

Programmer tak perlu berulangkali menuliskan metatipe (type) untuk deklarasi banyak tipe. Ini sangat membantu dalam pemrograman skala besar yang melibatkan banyak deklarasi tipe.

Mengurangi beban menghafal. Sintaks deklarasi tipe sangat mirip dengan sintaks deklarasi objek. Tanda baca koma berperan untuk memisahkan item, dan setiap item bisa diberikan ekspresi.

Sekali lagi, ini adalah contoh penerapan prinsip ortogonalitas. Seandainya tidak ada pengecualian yang perlu dibuat, maka janganlah dibuat.

Hasil keputusan perancangan pada C/C++ bisa dilihat pada Lampiran.

Operasi Subtype

Keputusan perancangan berikutnya adalah tentang operasi subtype. Operasi subtype adalah cara Batak untuk mewujudkan pewarisan (inheritance). Berikut adalah sebuah contoh.

module m4;

interface

type shape := { boolean is_visible; },
ellipse := subtype (shape) + { integer a, b; },
e := { boolean is_visible;} + { integer a, b; },
f := { boolean is_visible; integer a, b; } ;

Baris ke-5 menyatakan pemberian nilai (Value, satu dari empat konsep dasar VOTO) tipe ke shape. Untuk melihat bahwa { boolean is_visible; } adalah sebuah nilai, bisa dibandingkan dengan

 

Program p2;

integer next (integer i) { return (i + 1); }

integer main()
{
integer k := 5,
n := next(4);
}

Dari contoh m4 dan p2, kedua baris berikut memiliki kesamaan: yang diberikan adalah nilai (literal).

 

type shape := { boolean is_visible; };
integer k := 5;

Seperti halnya hasil evaluasi next(4) memberi nilai numerik 5, demikian pula hasil evaluasi subtype(shape) memberi nilai tipe { boolean is_visible; }. Dengan pemahaman ini jelas bahwa struktur ketiga tipe (ellipse, e, dan f) adalah sama, yakni { boolean is_visible; integer a, b; }. Operasi + adalah operasi yang berlaku bagi ekspresi tipe, yang memiliki makna penggabungan ekspresi tipe, persisnya penggabungan 2 ekspresi tipe komposit (record).

Kesamaan tipe ellipse, e, dan f berlaku hanya pada struktur, tidak pada semantik. ellipse sebagai tipe turunan dari shape memiliki hak untuk mewarisi operasi yang berlaku pada shape. Sebagai contoh:

 

void display (shape s);

shape s1;
ellipse e1;
e e2;
f f1;

display (s1);
display (e1);
display (e2);
display (f1);

Pemanggilan operasi display dengan operan e2 dan f1 akan membangkitkan kesalahan.

Keputusan perancangan ini memudahkan penjelasan dan menjawab berbagai pertanyaan tentang pewarisan. Contoh: apa itu pewarisan? Pewarisan adalah fasilitas untuk:

memberikan nilai-tipe ke tipe lain;

mengizinkan berlakunya operasi-operasi di supertipe ke subtipe;

mengizinkan berlakunya operasi-operasi pada objek dari supertipe ke objek dari subtipe;

diimplementasikan lewat operasi subtype.

Contoh pertanyaan lain: bagaimana melepas fasilitas pewarisan dari Batak? Jawabannya: hilangkan operasi subtype.

Mengacu kepada prinsip ortogonalitas, keputusan perancangan ini membuat Batak ortogonal:

Pemberian nilai untuk ekspresi tipe pada pewarisan sama dengan pemberian nilai untuk ekspresi tipe yang tak melibatkan pewarisan.

Pemberian nilai untuk ekspresi tipe pada pewarisan sama dengan pemberian nilai ekspresi non-tipe.

Mengacu kepada VOTO dan prinsip kepaduan konseptual:

Artinya: Batak memenuhi prinsip kepaduan konseptual dalam keputusan perancangan ini.

Information Hiding: Bagian Interface Dan Implementation

Ilustrasi tentang penyembunyian informasi memakai module m5 yang merupakan sedikit modifikasi dari m4. Mari kita lihat dulu program p3 yang memakai module m4.

Program p3;

Use (m4);

Integer main()
{
shape s;
s.is_visible := true;
}

Pengaksesan is_visible absah karena aksesibilitas s bersifat publik, sejalan dengan penempatannya di bagian interface. Sebagai perbandingan, berikut adalah module m5 dengan program p4.

module m5;

interface

type shape, ellipse := subtype (shape);

implementation

type shape := { boolean is_visible; },
ellipse := subtype (shape) + { integer a, b; };

program p4;

use (m5);

shape s;

integer main()
{
s.is_visible := true; /* error */
}

Kedua bagian adalah sarana penyembunyian informasi. Yang tercantum di interface tidak disembunyikan sama sekali, sehingga semua tipe, operasi, dan objek yang ada bisa diakses oleh semua modul atau program yang mengacu modul yang bersangkutan. Atribut yang dicantumkan di bagian ini juga dapat diakses dengan operasi dot (.).

Yang tercantum di implementation suatu modul tidak terlihat bagi modul atau program yang mengacunya. Inilah alasan mengapa pengacuan dalam program p4 gagal.

Dengan kata lain, interface dan implementation adalah pembeda akses (access qualifier) seperti halnya public, private, dan protected pada C++ dan Java.

Sebagai ilustrasi lebih lanjut mengenai penyembunyian informasi : katakanlah ada kasus di mana satu atau lebih programmer implementor module m5 ingin memberi hanya informasi yang dibutuhkan (sebagai interface), dan ingin menyembunyikan informasi yang rahasia. Pembuat module m5 bisa menyalin source code m5 sampai bagian interface saja (menjadi sebuah file interface), mengkompilasi m5, dan memberi file interface serta intermediate codenya. Dengan asumsi bahwa file interface adalah m5.itf (lihat di bawah) dan intermediate codenya file m5.obj, maka sedemikian mudahlah caranya untuk mengimplementasikan penyembunyian informasi di Batak. Berikut adalah file m5.itf.

Module m5;

Interface

Type shape, ellipse := subtype (shape);

Keputusan perancangan ini adalah lebih baik daripada C, C++, Java dan Turbo Pascal. Keempatnya meletakkan pembeda akses pada tipe sehingga pembeda akses cenderung harus terus-menerus diketik ulang untuk tiap tipe. Dengan membuat pembeda akses berlingkup modul, di Batak hal di atas tak perlu terjadi.

Sebagai contoh, andai dibuat module m6 yang mendeklarasikan tipe shape, ellipse, dan complex; pembeda akses tak perlu diulangi untuk 3 (atau lebih) tipe seperti ini.

Module m6;

interface

type shape, ellipse := subtype (shape), complex;

Kepaduan konseptual dan ortogonalitas sekaligus dicapai dalam keputusan perancangan ini. Pembeda akses seharusnya merupakan urusan modul, bukan tipe. Ini sejalan dengan konsep pemrograman modular yang menyatakan modul sebagai sarana penyembunyian informasi (bukan tipe).

Implementasi penyembunyian informasi di C/C++/Java dan Pascal dapat dilihat pada Lampiran.

Parameterized Type

Merupakan fasilitas pendukung untuk mengimplementasikan tipe-tipe seperti stack. Sstack adalah tipe dengan operasi-operasi yang terdefinisi dengan baik: push dan pop. Masalahnya : bagaimana membuat stack sekali saja, tak tergantung apakah elemennya bertipe integer, character, atau apapun ?

Batak menyediakan penyelesaian masalah berupa parameterized type yang mirip dengan C++ namun lebih sederhana. Solusi dalam Batak adalah sebagai berikut:

module stack2;

interface

type stack <type thing> ;
stack <type thing> stack <type thing> ();
boolean push (stack <type thing>& s; thing t);
thing pop (stack <type thing>& s);
stack <char> s1;
stack <float> s2;

implementation

type stack <type thing> := { thing[] elements; word count, status; };

boolean push (stack <type thing>& s; thing t)
{
if (s.count = 10)
{ return (false); };
s.count++;
s.elements[s.count] := t;
return (true);
}

thing pop (stack <type thing>& s)
{
if (s.count = 0)
{ }; /* do nothing */
s.count--;
return (s.elements[s1.count+1]);
}

Terlihat bahwa kita bisa mendeklarasikan stack yang elemennya bertipe integer, float, dan apa saja.

Keputusan perancangan ini sekali lagi memperlihatkan kepaduan konseptual.

Cara menyembunyikan informasi parameterized type (struktur stack pada contoh di atas) sama dengan cara menyembunyikan informasi pada non parameterized-type, yakni lewat modul.

Batak tidak memakai istilah atau ‘kata kunci’ lain untuk parameterized type (C++ memakai katakunci lain: template). Jadi ada kepaduan konseptual yang menyatakan bahwa kebanyakan parameter-parameter yang berperan adalah tipe. Pemakaian kata kunci lain mengisyaratkan kurangnya kepaduan konseptual.

Untuk memahami parameterized type, mari kita lihat fakta berikut. Stack adalah parameterized type, tipe yang membutuhkan parameter. Dalam hal ini, parameternya adalah nama tipe. Dan dalam contoh di atas, tipe tersebut bernama Thing. Operasi untuk membentuk parameterized type adalah <>. Tipe Thing akan ditinjau lebih lanjut pada bagian lain. Parameterized type di C++ dapat dilihat pada Lampiran.

Operasi Polimorfik

Batak mendukung operasi polimorfik. Karena keterbatasan tempat, rinciannya tidak dibahas di sini dan dapat Anda lihat di Tutorial Batak.

Spesialisasi Dengan Konstrain

Mekanisme ini merupakan salah satu usulan untuk model formal bagi pewarisan ([DATE1998], [DATE2001]). Model ini menyatakan bahwa:

Dalam Batak, item ke-3 bersifat bersyarat:

Penerapan spesialisasi dengan kendala (constraint) bisa dilihat pada contoh berikut:

Module m7;

Interface

Type shape, ellipse := subtype (shape), circle := subtype(ellipse);

Implementation

Type shape := { boolean is_visible; },
Ellipse := subtype (shape) + { integer a, b; },
Circle := subtype (ellipse) constraint (a = b);

Penjelasan lebih lanjut tentang model formal bagi pewarisan di Batak di luar lingkup artikel ini, namun sebagian besar (bukan seluruhnya) mengacu kepada model yang ditawarkan di [DATE2001].

Tipe Numeric, Range, Dan Enumerated

Tipe numeric merupakan induk dari tipe integral (non floating point) dan tipe floating point. Tipe numeric adalah parameterized type.

Sebagai contoh, tipe float dan byte secara internal didefinisikan

Type float := subtype (numeric<9, 2>) range { ..., ... };
Type byte := subtype (numeric<3>) range { 0, 255 };

Adanya tipe numeric memungkinkan pembuatan tipe dengan tingkat keluwesan yang tinggi. Source code module matrix memperlihatkan hal ini (lihat Lampiran). Memang rancangan Batak saat ini belum memampukan pembuatan kode tersebut, namun kemampuan pembuatan kode seperti itu merupakan sebuah sasaran yang ingin dicapai.

Tipe enumerasi bisa dibuat dengan cara yang mirip:

byte constant
MINGGU := 1, senin := 2, selasa := 3, rabu := 4, KAMIS := 5,
jumat := 6, sabtu := 7;
Type hari := subtype (byte) enumerated {MINGGU, senin, selasa, rabu,
KAMIS, jumat, sabtu};
Type hari_kerja := subtype (byte) enumerated {senin, selasa, rabu,
KAMIS, jumat};

Operasi-operasi pada byte dengan demikian berlaku pada tipe hari dan hari_kerja. Ini memudahkan pemahaman bahwa objek-objek bertipe hari dan hari_kerja bisa dikenakan operasi aritmetika, inkremen, dekremen (dan suksesor atau predesesor, jika ada).

Keputusan perancangan ini sekali lagi memperlihatkan kepaduan konseptual dan ortogonalitas pada Batak:

Sebagai sedikit catatan dalam hal ortogonalitas: Batak akan mengizinkan operasi masukan/keluaran pada objek bertipe enumerated dengan memproses value (1, 2, 3, bukan nama konstanta seperti MINGGU, SENIN, SELASA). Pascal dalam hal ini kurang ortogonal karena tak mengizinkan operasi I/O beroperasi pada objek bertipe enumerated.

Pemakaian lambang <> untuk operasi pembentuk ekspresi tipenya merupakan keputusan perancangan untuk memenuhi prinsip kepaduan konseptual. Semua tipe yang memakai <> adalah parameterized type. Dengan cara pandang konseptual seperti ini, numeric<> adalah parameterized type, seperti halnya stack dalam contoh sebelumnya. Kita akan lihat juga bahwa tabel adalah parameterized type (lihat Integrasi dengan Database).

Parameterized type dibuat ortogonal dengan pembagian tipe atas primitif, komposit, dan koleksi:

  1. Numeric adalah primitive parameterized type;
  2. Stack adalah (contoh) composite parameterized type;
  3. Table adalah collection parameterized type.

Array sebenarnya juga adalah collection parameterized type. Batak tidak menyediakan cara built-in untuk deklarasi tipe seperti array <integer>, array <integer, 10>, array <integer, 10, 10> (yang ekivalennya adalah integer[], integer[10], integer[10, 10]). Cara ini dibiarkan dilengkapi pada pustaka pemrograman. Cara yang konvensional lebih mudah dimengerti.

Pemakaian lambang lain—misalnya ()—akan melanggar prinsip ini. Disadari bahwa beberapa bahasa pemrograman memakai lambang (), misalnya SQL. Contoh:

CREATE TABLE T
( A NUMERIC(9, 2));

Lihat juga bagian Integrasi Dengan Database untuk penjelasan yang terkait dengan database.

Sebagai penutup, hirarki tipe di Batak mencantumkan bahwa tipe enumerated juga bisa diturunkan dari tipe karakter. Contoh:

Type vocal := subtype(char) enumerated 
{A := 'A', E := 'E', I := 'I', O := 'O', U := 'U'};

Mengapa variabel bertipe vocal bisa dikenakan operasi-operasi karakter? Karena tipe vocal adalah turunan dari tipe character. Ini contoh dari kepaduan konseptual: padunya konsep tentang enumerated type dan pewarisan. Hal ini bisa terlihat juga dari diagram tipe pada Batak.

Kendali Alur (1): Repeat_Until

Definisi operasi imperatif telah diterangkan sebelumnya. Berdasarkan definisi tersebut, mudah dimengerti bahwa dalam contoh program berikut, for, repeat_until, dan while adalah operasi.

Program p5;
integer main()
{
integer j;
for (j := 1; j < 5; j++)
{ writeline (j); }
repeat_until (j < 5)
{
writeline (j);
j++;
}
while (j > 10)
{
writeline (j);
j++;
}
}

Alasan lengkap untuk mengemukakan bahwa for, repeat_until, dan writeline adalah operasi dapat dijumpai di Tutorial. Sebagai gambaran singkat, ketiganya memakai tanda kurung untuk mengelompokkan operan[-operan]. Dengan cara ini, mudah untuk memandang ketiganya sebagai operasi [imperatif].

Semantik operasi repeat_until mirip dengan repeat ... until pada Pascal, atau do ... while pada C/C++. Blok atau pernyataan diulangi minimal satu kali, kemudian kondisi diperiksa. Nalar pembuatan sintaks yang sama dengan semantik berbeda adalah sebagai berikut.

Pemrosesan dengan semantik yang berbeda bisa dicapai dengan 2 cara:

Sintaks yang berbeda;

Sintaks yang sama.

Cara pertama akan menambah beban: semantik berbeda, sintaks berbeda; sehingga programmer harus mengingat kedua perbedaan. Cara kedua tidak menambah beban: yang perlu diingat hanya perbedaan semantik.

Secara umum (sesuai prinsip ortogonalitas) cara kedualah yang harus dipakai. Cara kedua dipakai hanya bila ada alasan-alasan yang lebih kuat. Penulis tidak melihat adanya alasan-alasan yang cukup kuat untuk memakai cara pertama (untuk membuat pengecualian dari prinsip), sehingga repeat_until tetap dibuat seperti di atas. Keuntungannya adalah kemudahan untuk menghubungkan dengan VOTO, mudah untuk melihat repeat_until sebagai operasi.

Kendali Alur (2): if(), case() Dan in_case()

Keputusan perancangan tentang if mengacu pada perilaku if di C. Keputusan perancangan tentang case mengadopsi perilaku case pada Pascal. Berikut sebuah contoh:

program case2;

integer main ()
{
write ('Enter the month (1-12): ');
byte b;
read (b);
case (b)
{
1, 3, 5, 7..8, 10, 12 : { writeline (' 31 days'); }
4, 6, 9, 11 : { writeline (' 30 days'); }
else : { writeline (' 28 days, 29 for leap years'); }
}
}

Yang bagus dari keputusan perancangan ini bisa dilihat dengan mengacu pada prinsip konsolidasi. Pascal telah menunjukkan cara yang lebih baik daripada C/C++/Java, dan cara ini tinggal diadopsi. Keputusan perancangan ini juga mendemonstrasikan ortogonalitas, kepaduan konseptual. Secara konseptual percabangan else pada case adalah sama dengan percabangan else pada if. Karena itu tak perlu dipakai kata kunci lain. C/C++ tidak memenuhi kriteria ini karena memakai kata kunci lain, yakni default.

#include <stdio.h>

void main()
{
printf ("Enter the month (1-12): ");
unsigned short b;
scanf("%d", &b);
switch(b)
{
case 1 : case 3: case 5: case 7: case 8: case 10: case 12:
puts(" 31 days"); break;
case 4: case 6: case 9: case 11:
puts(" 30 days"); break;
default : puts(" 28 days, 29 days for leap years");
}
}

Berbeda dengan Pascal, Batak tidak membatasi nilai-nilai pada label kepada nilai integral; melainkan membolehkan nilai primitif floating point, nilai koleksi, dan nilai komposit. Hal ini juga merupakan butir tambahan Batak memenuhi prinsip ortogonalitas.

Operasi berikutnya adalah in_case. Operasi ini ditujukan untuk memberi alternatif kode yang lebih mudah dibaca daripada deretan if-else. Berikut sebuah contoh:

program compare0;

type date := { byte day, month; word year; };

boolean infix < (date d1, d2)
{
in_case()
{
d1.year < d2.year : { return (true); }
d2.year < d1.year : { return (false); }
else :
{
in_case()
{
d1.month < d2.month : { return (true); }
d2.month < d1.month : { return (false); }
else :
{
in_case()
{
d1.day < d2.day : { return (true); }
else : { return (false); }
}
}
}
}
}
}

boolean infix > (date d1, d2)
{ return (not (d1 < d2)); }

thing max (thing a, b)
{
if (a > b )
{ return (a); }
else
{ return (b); }
}

thing min (thing a, b) { return (a < b #? a : b); }

integer main()
{
date d1, d2, d3;
/* if the parser is better, conversion to date is not needed */
d3 := date(min (d1, d2));
}

Kode di atas bisa ditulis dengan if-else, dan akan terlihat bahwa program dalam Batak lebih mudah dibaca.

Kendali Alur (3): break() Dan continue()

Sebagai tambahan untuk kendali alur disediakan pula operasi return, exit, break, dan continue. Kedua operasi pertama tidak terkait dengan perulangan. Operasi return digunakan untuk mengarahkan eksekusi ke akhir badan operasi. Operasi exit untuk mengakhir program secara keseluruhan.

Kedua operasi terakhir terkait dengan perulangan, dan hanya absah dalam perulangan. Operasi break menghentikan perulangan, sedangkan operasi continue untuk melanjutkan perulangan (mengabaikan semua pernyataan yang mengikuti continue, jika ada).

Berikut adalah contoh source code scanner untuk memroses komentar di C (juga dalam bahasa C).

scan_again :

for (c = getc(input_file); c == ' ' || c == '\t' || c == '\n'; c =
getc(input_file))
{
if (c == EOF || c == 0XFF)
return(0);
else if (c == '/')
break;
}

if (c == '/')
{
c2 = getc(input_file);
if (c2 == '*')
{

scan_asterisk :

for (int c = getc(input_file); (c != '*') && (c != EOF);
c = getc(input_file));
if (c == EOF)
return (0);
c = getc(input_file);
if (c == EOF)
return (0);
if (c != '/')
goto scan_asterisk;
else
goto scan_again;
}
else
{
ungetc(c2, input_file);
goto check_again;
}
}

check_again:

Padanannya dalam Batak adalah sebagai berikut:

for (c := read(input_file); c = ' ' or c = '\t' or c = '\n'; c := 
read(input_file))
{
if (c = EOF or c = char(255))
return(0);
if (c != '/')
break(1); /* the character won’t start a comment, break the loop */
c2 := read(input_file);
if (c2 = '*')
{
for (c := read(input_file); ; c := read(input_file))
{
if (c = EOF)
return (0);
if (c != '*')
continue(1);
c := read(input_file);
if (c == EOF)
return (0);
if (c != '/')
continue(2);
/* this comment ok, now get possible token after this comment */
else
continue(1);
/* find again the asterisk that helps closing the comment */
}
}
else
{
unget(c2, input_file);
/* '/' alone (without '*') does not start a comment */
break(); /* ekivalen dengan break(1); */
}
}

Pemanggilan operasi continue(2) berarti bahwa eksekusi akan dicabangkan ke perulangan yang 2 level dari pernyataan tempat pemanggilan ini. Dalam contoh kode di atas, pencabangan terjadi ke perulangan for yang paling atas (yang bersyarat c = ' ' or c = '\t' or c = '\n').

Terlihat bahwa ketiadaan operan membuat operasi break dan continue di C hanya bisa untuk mencabangkan eksekusi dari perulangan 1 level (bukan nested). Keterbatasan ini memperumit penulisan kode, baik tanpa maupun dengan goto :

Adanya operan level meniadakan keperluan akan goto bagi pemrosesan seperti di atas. Jadi apakah goto masih diperlukan? Jawabannya bergantung pada domain permasalahan. Untuk pengembangan aplikasi mungkin tidak diperlukan. Untuk pengembangan infrastruktur atau development tool masih diperlukan; misalnya: source code compiler, terutama bagian parsing. Batak memakai nama jump, bukan goto; untuk kesamaan dengan operasi pada bahasa assembly. Ini merupakan wujud kepaduan konseptual.

Apa konsekuensinya? Bisa—dan mungkin seharusnya—dibuat (minimal) 2 dialek Batak. Satu dialek dibuat untuk pengembang aplikasi, tidak menyertakan operasi jump (serta tanpa tipe pointer dan operasi pointer). Dialek lain dibuat untuk pengembang tool, menyertakan operasi jump dan menyertakan juga tipe pointer dan operasi pointer.

Keputusan perancangan untuk membuat operasi return, break, dan continue mudah dipandang sebagai operasi (imperatif) menolong kepaduan konseptual: dalam arti bahwa semuanya terpadu ke dalam konsep VOTO. Kita bisa menjelaskan kendali alur dan semua operasi di atas dalam kerangka Value, Object, Type, and Operation.

Diskusi tentang kendali alur pada C/C++ dapat dilihat pada Lampiran.

Label Dan Operasi Jump

Label yang menjadi operan dalam pemanggilan operasi jump harus dideklarasikan lebih dulu, dan namanya adalah label. Berikut contoh:

Program p6;

integer main()
{
label label­_1;
integer j := 1;

label_1: write (j, ' ');

j++;
if (j < 5)
jump(label_1);
}

Motivasinya kembali adalah kepaduan konseptual, untuk memudahkan pemahaman akan operasi jump. Notasi UML di Gambar 1 mendeskripsikan tipe label dan operasi yang berlaku atasnya. Gambar tersebut menunjukkan bahwa objek-objek bertipe label dapat dikenakan—berperan sebagai operan dari—operasi jump.

Tipe Thing

Tipe ini adalah tipe dummy yang menurunkan semua tipe lain yang bisa diberikan (dan beberapa tipe lain yang tidak bisa diberikan, misalnya File). Adanya tipe Thing sangat berguna untuk mewujudkan kepaduan konseptual. Thing memungkinkan terbentuknya hanya satu cara untuk mewujudkan operasi jenerik, dan menghindari terlalu banyaknya variasi seperti pada C++ (dengan #define makro dan template).

Contoh: pembuatan operasi max untuk mengembalikan nilai yang terbesar dari antara dua nilai. Berikut adalah contoh C.

#define max (a, b) a > b ? a : b

Untuk Batak:

Thing max (thing a, b) { return (a > b #? a : b); }

Jadi, Batak tak memerlukan sintaks baru. Catatan: ada juga alternatif untuk kode Batak di atas dengan memakai if-else, dan alasan pemakaian #? dan bukannya ? seperti pada C adalah untuk menghindarkan konflik jika subset Batak dipakai dalam pemrograman shell (seperti halnya C). Dalam pemrograman shell adalah umum untuk memakai ? sebagai lambang wildcard karakter tunggal untuk nama file.

C++ menyediakan cara di atas, dan menambahkan cara baru, dengan template fungsi. Contoh:

template <class T> void MySwap( T& a, T& b )
{
T c( a );
a = b; b = c;
}

Batak menangani masalah yang serupa dengan penyelesaian seperti di bawah:

void MySwap (Thing& a, b)
{
Thing c := a;
a := b; b := c;
}

Terlihat bahwa ada kepaduan konseptual di Batak, dan caranya lebih elegan. Operan pada pemanggilan operasi max dan MySwap bisa berupa objek bertipe apa saja.

Integrasi dengan Database

Batak dipadukan dengan database untuk memudahkan pemrograman aplikasi yang banyak berinteraksi dengan database. Sejalan dengan table sebagai parameterized type, maka hirarki tipe menyertakan tipe tabel, tercantum sebagai table<type thing>.

Beberapa operasi-operasi yang disediakan untuk database dibuat lebih eksplisit daripada yang ada di SQL saat ini, untuk memudahkan programmer memahami model relasional, yang pada gilirannya berpotensi meningkatkan produktivitas.

Misalkan ada deklarasi:

Type student := { word id; char[] name; };

Table<student> students;
UPDATE students DO id++;
UPDATE students DO { id := id – 1; name += ‘a’; };

Butir penting yang dapat dilihat:

Saat ini tidak ada bahasa pemrograman yang mengizinkan dipakainya operasi-operasi numerik pada bahasa tersebut untuk atribut-atribut numerik. Pemanggilan operasi update (pada kasus pertama) harus dituliskan seperti ini pada SQL:

UPDATE students DO i = i + 1;
UPDATE students DO id = id – 1, name = concat(name, 'a');

Ada beberapa ketidakpaduan konseptual di sini:

Contoh lain dapat dilihat dari operasi INSERT. Berikut versi Batak:

Table<student> IT students, mech_students, tech_students;
INSERT table<student> ( {student(1, 'Merry')} ) INTO IT_students;

Jelas terlihat bahwa operasi INSERT adalah operasi tabel (relational operations) karena ia beroperasi atas tabel-tabel (sebagai operan).

Hal ini kurang jelas terlihat dari cara berikut:

INSERT INTO IT_students VALUES (1, 'Merry');

Walau lebih ringkas, cara ini tidak menolong untuk memahami INSERT sebagai operasi tabel, dan bahwa operan-operannya adalah ekspresi tabel.

Cara yang di Batak memang lebih panjang. Untuk mengurangi (“gap”) panjang tersebut, Batak membuat tipe row bersifat opsional, sehingga contoh penyisipan record pada Batak bisa ditulis ulang sebagai berikut:

INSERT table<> {student(1, 'Merry')} INTO IT_students;

Walau cara Batak lebih panjang, namun memungkinkan pemasukan lebih dari 1 record.

INSERT table<> {student(1, 'Merry'), student(2, 'Agus')} INTO IT_students;

SQL tak memungkinkan insertion lebih dari 1 record jika record-record tersebut tidak ada di tabel lain.

Jika ada di tabel lain, maka SQL memungkinkannya dengan cara sebagai berikut:

INSERT INTO tech_students SELECT * FROM IT_students;

Batak memberi alternatif yang jauh lebih baik (ringkas).

INSERT IT_students INTO tech_students;

Butir pentingnya adalah kepaduan konseptual. Kepaduan konseptual mengurangi beban belajar, memungkinkan programmer untuk segera memecahkan masalah yang dihadapi.

Hirarki Tipe Yang Sangat Formal Dan Terpadu

Hirarki tipe yang ada saat ini di C/C++/Pascal tidak formal sehingga masih menimbulkan banyak penafsiran (lihat [HARI1999]). Hirarki Java kurang formal dan kurang terpadu secara konseptual (pikirkan hubungan antara tipe int dengan Integer). Selain itu, semuanya tidak terpadu karena satu hal lagi: modul (package di Java) tidak termasuk dalam hirarki tipenya. C++ paling parah karena tidak ada hirarki tipe yang cukup menjelaskan perbedaan hirarki tipe yang diturunkan dari metatipe typedef dan metatipe class.

Hirarki tipe Batak sangat padu secara konseptual (lihat dokumen Visio): menjelaskan kepada objek bertipe apa operasi subtype berlaku, bahwa operasi [] (subskrip) berlaku pada array, bahwa operasi use berlaku pada tipe module, dan seterusnya. Belum pernah ada deskripsi hirarki tipe sepert ini!

Konversi Tipe

Konversi tipe diperlakukan seperti pemanggilan operasi imperatif, melulu hanya memakai ekspresi tipe, sehingga tak diperlukan sintaks tambahan. Berikut adalah contoh sederhana.

Program p1;

Integer main()
{
char c;
byte b;
char^ ptr1; /* pointer to char – ekspresi tipe : char^ */
byte^ ptr2; /* pointer to byte – ekspresi tipe : byte^ */
b := byte (c);
c := char(b);
ptr1 := char^(ptr2);
type student := { word id; char[20] name; };
table<student> students; /* ekspresi tipe: table<student> */
student[] student_array; /* ekspresi tipe: student[] */
student_array := student[] (students);
/* konversi tabel ke array */
students := table<student> (student_array);
/* konversi array ke tabel */
}

Konversi di C memakai cara yang lebih sulit.

int main()
{
char c;
unsigned short b;
c = (char) b;
b = (unsigned short) c;
}

Hal ini menimbulkan ketidakpaduan konseptual pada bahasa C++ (hasil evolusi dari C) karena konversi C++ memungkinkan 2 cara: cara seperti di C dan cara seperti di Batak.

Cara konversi ini akan sangat meningkatkan produktifitas. Konversi pada source code bisa mencapai lebih dari 30% dari seluruh code yang dibuat. Konversi saat ini sering sekali memberi tambahan beban yang besar dalam hal menghapal nama operasi dan sintaksnya.

Di Batak, relatif tidak ada hal yang perlu dihapalkan : ekspresi tipe tujuan sudah menyiratkan “nama” operasi yang harus dipanggil.

Array: mulai dari 1, dan pemikiran lebih lanjut (#)

Nilai subskrip (indeks) terendah untuk array adalah 1 di Batak, bukan 0 seperti di C/C++ dan Java. Ini menyederhanakan upaya pemrograman untuk banyak kasus. Kasus manajemen memori (yang beralamat mulai dari 0, dan mungkin dianggap sebagai alasan yang ‘sah’ oleh perancang C untuk membuat array dimulai dari 0) dapat ditangani pada level pustaka pemrograman. Indexing dari 1 juga konsisten untuk pemrograman database.

Ada rencana untuk membedakan antara:

Motivasinya untuk mencapai tingkat kepaduan konseptual yang lebih tinggi dengan pemrograman database tanpa harus membuat kata kunci baru. Di SQL:

Batak ingin mencapai kepaduan konseptual sehingga:

Suatu pemikiran saat ini adalah pemakaian <> untuk mendeklarasikan jenis array kedua (panjang tak tetap, panjang maksimum ditetapkan). Contoh:

char[] s1;     /* variable-length array with max-length unspecified */
char[25] s2; /* fixed-length array */
char[<25>] s3; /* variable-length array with max-length specified */

Pilihan lain adalah dengan memakai nama VARCHAR, dan memperlakukannya sebagai parameterized type. Parameter keduanya adalah panjang string. Contoh alternatif ini:

char[] s1;     /* variable-length array with max-length unspecified */
char[25] s2; /* fixed-length array */
varchar<25> s3; /* variable-length array with max-length specified */

Bila keputusan ini yang dibuat, maka VARCHAR diletakkan ke pustaka (bukan ke bahasa) pemrograman. Selain itu, cara-cara untuk mendapatkan panjang pada dimensi ke-2 dan seterusnya masih harus diselidiki.

Case Insensitive

Sifat ini sengaja dibuat untuk memberi toleransi yang lebih besar kepada programmer. Selain itu juga untuk mencapai tingkat kepaduan konseptual yang tinggi dengan pemrograman database. Pemrograman database dengan SQL saat ini bersifat case insensitive dan sebaiknyalah dipertahankan demikian.

Jika bahasa Batak bersifat case sensitive sedangkan SQL tidak, maka pemakaian objek dan operasi di Batak untuk pemrograman database akan menimbulkan masalah.

Spesifikasi Operan

Sintaks spesifikasi formal operan pada heading operasi sangat mirip dengan sintaks deklarasi objek.

program nothing0;

void do_nothing(float a, b; char c, d) { }

integer main()
{
float v, w; char x, y;
do_nothing (v, w, x, y);
}

Selain itu Batak juga memungkinkan hal yang berikut.

program p;

integer op1(), op2(); /* deklarasi 2 operasi */
integer a, b; /* deklarasi 2 objek */

integer main()
{
b := 10;
}

Batak sangat memaksimalkan commalist—list yang elemen-elemennya dipisahkan oleh koma. Titik koma biasanya dipakai sebagai pemisah dalam skala yang lebih besar:

Keputusan perancangan ini mengambil analogi dari bahasa alami. Dalam bahasa alami (Inggris, Indonesia), koma dipakai untuk pemisahan skala kecil sedangkan titik koma dipakai untuk pemisahan skala besar (umumnya pemisah anak kalimat).

Operasi with

Operasi ini cukup membantu untuk pemrograman, dan berperilaku seperti with pada Pascal. Ada 2 perbedaan ciri operasi with pada dengan pada Pascal:

berciri operasi imperatif;

dapat juga dipakai untuk tipe koleksi (bukan tipe record/komposit) asal diikuti dengan pemanggilan operasi ITERATE (lihat contoh dan bagian berikutnya).

Operasi ITERATE Untuk Objek-Objek Bertipe Koleksi

Operasi ITERATE bisa berlaku untuk semua objek koleksi, baik yang bertipe tabel untuk pemrograman database maupun bukan.

program p;

type student := { word id; char[] name; };

integer main()
{
integer i;
table<student> students;
with (Students)
iterate { id++; }
}

Batak memakai sintaks yang jauh lebih sederhana daripada C++ dan Java.

Inisialisasi Implisit

Batak memberlakukan inisialisasi implisit yang akan sangat meringankan beban programmer. Rincian tidak dimuat di sini, dapat Anda lihat di Manual Batak. Tidak seperti Java, inisialisasi implisit juga berlaku bagi objek bertipe koleksi dan komposit.

Tidak Pelit

Sesuatu penghematan bisa menjadi pelit bila dilakukan berlebihan. Batak tidak melakukan hal ini. Itulah sebabnya nama tipe yang dipakai adalah integer, bukan int; boolean, bukan bool. char adalah sebuah perkecualian. Qualifier yang dipakai adalah constant, bukan const. Ini akan membuat pembacaan program lebih menyenangkan. Program lebih sering dibaca daripada ditulis. Bahasa pemrograman harus juga menjadi alat komunikasi antara manusia dengan manusia, tidak hanya manusia dengan komputer.

Pemeriksaan Tipe

Pemeriksaan tipe dilakukan dengan memanggil operasi type. type memang adalah nama tipe (persisnya metatipe). Nama tipe juga bisa dipakai sebagai nama operasi (ini sangat logis, penjelasan lebih lanjut bisa dilihat di Tutorial). Dengan type juga sebagai nama tipe, adalah mungkin untuk melakukan hal yang sama, dan dalam Batak hal tersebut dilakukan.

program p;

integer main()
{
char c;
if (type(c) = integer)
{ writeline ('integer'); }
else
{ writeline ('non-integer'); }
}

Ini berbeda dengan:

Java yang memakai instanceOf;

Pascal yang memakai typeof;

C++ dengan RTTI (Run Time Type Information).

Ketiga alternatif di atas membutuhkan hapalan tambahan dan lebih rumit.

Atas dasar keperluan untuk mencapai ortogonalitas yang tinggi, ruas kanan dari perbandingan (pada contoh, ruas kanan adalah integer) tidak hanya berupa nama tipe, melainkan ekspresi tipe. Ini memungkinkan verifikasi apakah tipe suatu objek merupakan pointer ke char, misalnya.

Operasi-Operasi Bagi Tabel (#)

Batak akan menyediakan operasi-operasi bagi tabel sehingga pemrograman database akan lebih mudah dipahami, akan lebih mudah dilihat kesamaannya dengan pemrograman non-database. Contoh berikut memberi ilustrasi. Hal penyiapan koneksi tidak dideskripsikan, untuk menyederhanakan masalah. Kode yang lugas seperti di bawah ini sepanjang pengetahuan penulis belum bisa dituliskan dalam tool apa pun saat ini.

Program p;

Type student := { word id; char[] name; };

Table<student> IT_students, mech_students, tech_students;

Integer main()
{
tech_students := IT_students UNION mech_students;
}

Daftar berikut adalah sekilas pandang operasi-operasi yang disediakan Batak untuk pemrosesan tabel:

Enam operasi perbandingan tabel (lihat [DATE1995]). Operasi-operasi ini sangat berguna untuk penyederhanaan query.

Operasi EXCEPT (bukan EXCEPT pada SQL standard) yang memungkinkan untuk menspesifikasi sekumpulan atribut yang tidak diproyeksikan. Ini sangat berguna bila ada banyak field dalam suatu tabel (misal: 12), dan kita hanya ingin mengabaikan 2 atribut saja.

Operasi use

Bersifat imperatif, dapat memiliki lebih dari 1 operan, semua operan bertipe module. Contoh:

Use (module1, module2);

Dengan demikian operasi ini tak memerlukan hapalan yang banyak, kontras dengan C:

#include <stdio.h>
#include "module1.h"
#include "module2.h"

C menambahkan konsep baru: inklusi file.

C menambahkan sintaks baru, mulai dengan #.

C mengharuskan pengulangan #include untuk tiap header modul.

C mengharuskan pengulangan delimiter (seperti <> dan "") untuk tiap modul.

Batak juga tidak mengadopsi 100% cara di Pascal dan Modula 2 karena adanya sintaks baru, yang tidak memakai tanda kurung. Ini contoh kurangnya kepaduan konseptual, dan mengharuskan beban tambahan untuk menghapal.

Konsolidasi, Bukan Inovasi

Konsolidasi

Batak mengkonsolidasi hal-hal yang baik dari C, C++, (Java?) dan Pascal:

[Mungkin] Inovasi

Inovasi

Berikut adalah hal-hal yang inovatif pada Batak.

Jelas terlihat bahwa prinsip “konsolidasi, bukan inovasi” juga dipenuhi di Batak. Di satu sisi, item-item konsolidasi lebih banyak daripada inovasi. Di sisi lain, item-item inovasi ini juga berpengaruh besar untuk membuat Batak sangat mudah dipelajari dan membuat Batak menjadi bahasa yang elegan.

Pemikiran Lebih Lanjut: Pustaka dan Penanganan Eksepsi

Berikut ini hal-hal yang masih menjadi pemikiran untuk pengembangan Batak lebih lanjut.

Penutup

Kekuatan Minus Kompleksitas [Yang Tak Perlu]

Tidak ada bahasa pemrograman umum yang memiliki kepaduan konseptual cukup tinggi sampai saat ini. Bahasa-bahasa lain seperti BASIC dan Eiffel memang tidak dibahas, dan Java kelihatan hanya sekilas dibahas, namun berdasarkan paparan di sini pembaca bisa menyelidiki sendiri kebenaran klaim ini. Sebagai hasilnya, upaya mempelajari bahasa-bahasa di atas masih sangat sulit. Jikapun ada bahasa yang sangat mudah seperti BASIC, bahasa tersebut cenderung menjadi kurang ampuh atau kurang cocok untuk pemrograman yang lebih serius seperti untuk pembuatan OS, kompiler, atau aplikasi besar.

Paparan ini, bersama-sama dengan Manual Batak, membuktikan bahwa kita bisa membuat bahasa pemrograman yang jauh lebih mudah dikuasai daripada C/C++/Java/Pascal, tanpa kehilangan kemampuan bahasa-bahasa tersebut. Dengan kata lain: kita memperoleh kekuatannya minus kompleksitas yang tak perlu. Jika kelengkapan kakas (pustaka, bacaan, API, dsb) untuk pemrograman Batak sama dengan di Java, maka produktivitas pemrograman dengan memakai Batak akan lebih tinggi (tanpa memandang faktor manajerial).

Teori Yang Baik itu Praktis, Teori Buruk Tidak Praktis

Batak mampu membantu kita untuk memahami bahwa teori itu praktis (persisnya seperti judul di atas). Mudah-mudahan ini akan merangsang penelitian-penelitian yang lebih lanjut.

Mengapa Kompiler/Interpreter Batak perlu diwujudkan?

Mengapa kompiler Batak perlu diwujudkan?

Keberhasilan Jepang memicu semangat bangsa-bangsa Asia untuk merdeka, menyadarkan bahwa orang-orang Asia juga bisa mengalahkan, bisa sejajar dengan bangsa Eropa. Keberhasilan Utut Adianto juga mengilhami orang-orang Indonesia untuk mau belajar catur dengan serius.

Terlalu Mahal?

Tidak. US$8,000 cukup untuk membuat prototipe tanpa pemrosesan tabel, US$10,500 dengan dukungan pemrosesan tabel. Semua source code, kecuali generator parser, diberikan oleh perusahaan yang bersedia membuat prototipe Batak. Source code ini bisa menjadi sarana penelitian banyak mahasiswa di Indonesia.

Lampiran

Lampiran berikut terutama memberikan perbandingan dengan bahasa C dan C++. Selain itu ada paparan tentang fitur-fitur yang masih memerlukan pembenahan, dan tentang mengapa Batak perlu diwujudkan.

Orientasi Pembacaan Ekspresi Tipe Di C

Contoh ekspresi tipe yang sulit dibaca di C (baris kedua dan ketiga).

typedef int int_array [];
typedef (int*) h[];
typedef int* i[];

Ketidakpaduan orientasi pembacaan ini menyulitkan pembacaan ekspresi tipe. Ketidakpaduan ini juga contoh dari ketidakpaduan konseptual, konsep tentang ekspresi tipe.

Pemakaian Commalist Untuk Deklarasi Tipe Di C

C tidak ortogonal. Contoh, deklarasi berikut dibolehkan.

typedef void fv( int ), (*pfv)( int );

Namun, tanpa alasan yang cukup jelas, deklarasi berikut tak dibolehkan dan menimbulkan warning.

typedef int int_array[],
char char_array[];

Ini adalah contoh kurangnya kepaduan konseptual. Mengapa pada satu kasus dibolehkan deklarasi lebih dari satu tipe (dengan satu metatipe typedef), sedangkan pada kasus lain tak dibolehkan? Tidak ada alasan yang cukup kuat untuk ini.

Spesifikasi Operan Di C/C++

void do_nothing(float a, float b, char c, char d) { }

int main()
{
float v, w; char x, y;
do_nothing (v, w, x, y);
}

Lihat bagaimana sintaks deklarasi v, w, x, dan y terlalu berbeda dengan sintaks deklarasi a, b, c, dan d.

Kendali Alur Pada C

Ada beberapa istilah yang sangat keliru tentang kendali alur pada C, yakni return-statement, break-statement, and continue-statement. Istilah ini keliru karena:

Dengan kata lain, pemanggilan return, break, dan continue—tanpa memakai titik koma—adalah pemanggilan operasi, bukan pernyataan. Sebagai perbandingan (dan bukti), kita ambil contoh operasi +.

Storage Class

C/C++ tidak memakai istilah ekspresi tipe untuk nilai kembali fungsi. Istilah yang dipakai adalah storage class. Ini adalah contoh lain ketidakpaduan konseptual di C. Istilah ini sama sekali tak perlu ada.

Dua metatipe pada C++

C++ memakai dua metatipe. Adanya lebih dari 1 metatipe mengindikasikan kurangnya kepaduan konseptual.

Berikut beberapa contoh pengecualian yang cuma menambah beban:

typedef int integer;    /* bisa */
class int integer; /* tidak bisa */

typedef int int_array[10]; /* bisa */
class int int_array[10] /* tidak bisa */

Baris ke-2 contoh di atas mengindikasikan bahwa class tak bisa membuat suatu tipe alias (“alias”) dengan tipe aktual int. Contoh berikut memperlihatkan kasus saat class bisa.

template <class T> void MySwap( T& a, T& b )
{
T c( a );
a = b; b = c;
}

int main()
{
int a = 2, b = 3;
MySwap(a, b);
}

Adalah sangat melelahkan untuk mengingat pengecualian-pengecualian seperti ini.

Pemrosesan Matriks Yang Luwes (#)

Batak sudah mampu memproses deklarasi matrix seperti berikut.

module matrix1;

interface

type matrix <type numeric<>; byte an_amt_row, an_amt_column>;

Matriks seperti ini sangat luwes, entrinya bisa berupa tipe integral maupun floating point, panjang row dan column bisa diset. Keluwesan tipe entrinya ini merupakan hasil implementasi tipe numeric.

Sasaran jangka panjang adalah kemampuan untuk memproses kode sebagai berikut:

Module matrix;

interface

Type matrix <type numeric<>; byte an_amt_row, an_amt_column>;

matrix <type numeric<>; byte an_amt_row, an_amt_column>
matrix <type numeric<>; byte an_amt_row, an_amt_column> ();

void infix := (matrix <type numeric<>; byte an_amt_row, an_amt_column>& m;
numeric<> [][] values);

byte get_amt_row (matrix <type numeric<>; byte an_amt_row, an_amt_column> m);

byte get_amt_row (matrix <type numeric<>; byte an_amt_row, an_amt_column> m);

Matrix <type numeric<>; byte an_amt_row, an_amt_column> infix +
(Matrix <type numeric<>; byte an_amt_row, an_amt_column> A, B);

implementation

Type matrix <type numeric<>; byte an_amt_row, an_amt_column> :=
{ byte amt_row, amt_rows; numeric<> [][] contents };

matrix <type numeric<>; byte an_amt_row, an_amt_column>
matrix <type numeric<>; byte an_amt_row, an_amt_column> ()
{
matrix <type numeric<>; byte an_amt_row, an_amt_column> m;
with(m)
{
amt_row := an_amt_row;
amt_column := an_amt_column;
allocate (contents[amt_row, amt_column]);
}
return(m);
}

/* ----------------------------------------------------------------
return value of assignment operation is of type void, unlike C/C++
---------------------------------------------------------------- */
void infix:= (matrix<type numeric<>; byte an_amt_row,an_amt_column>& m;
numeric<> [][] values)
{
for (integer i := 1; i <= an_amt_row; i++)
for (integer j := 1; j <= an_amt_column; j++)
m.contents[i, j] := values[i, j];
}

byte get_amt_row (matrix <type numeric<>; byte an_amt_row, an_amt_column> m)
{ return (m.amt_row); }

byte get_amt_row (matrix <type numeric<>; byte an_amt_row, an_amt_column> m)
{ return (m.amt_column); }

Matrix <type numeric<>; byte an_amt_row, an_amt_column> infix +
(Matrix <type numeric<>; byte an_amt_row, an_amt_column> A, B)
{
Matrix <type numeric<>; byte an_amt_row, an_amt_column> C;
If (get_amt_row(A) != get_amt_row(B) OR
Get_amt_column(A) != get_amt_column(B))
Error (‘Not of the same size’);
Byte rows := get_amt_row(A), columns := get_amt_column(A);
For (j := 1; j <= rows; j++)
For (k := 1; k <= columns; k++)
C.contents[j, k] := A.contents[j, k] + B.contents[j, k];
Return (C);
}

Program p;

Use (matrix);

Matrix <float, 2, 2> A, B, C;
Matrix <byte, 2, 2> D, E, F;

integer main()
{
A := float[2, 2] ( {{1.0, 2.0}, {3.1, 3.0}} );
C := A + B;
F := D + E;
}

Yang Redundan Dan Sulit Dibaca Pada Konversi Tipe Di C

Kode berikut diambil dari sebuah source code kompiler nyata:

int m, sz = (int) (t1 >> 24), of = (int) ((t1 >> 16) & 0xff);

Pada Batak, hal ini akan dituliskan sebagai:

integer m, sz := integer(t1 >> 24), of := integer((t1 >> 16) and 255);

Untuk lebih memperjelas, penamaan akan diubah sebagai berikut:

integer m, size := integer(t1 >> 24), offset := integer((t1 >> 16) and 255);

Penulisan konversi tipe di C cenderung membuat pemakaian tanda kurung yang berlebihan (redundan).

Contoh berikut diambil dari source code yang sama, hanya nama variabel dan operasi yang diubah. Variabel n_ptr bertipe pointer ke unsigned int, an_instruction_code bertipe int.

nptr = (unsigned int *) ((char *) & (an_instruction_code) + 
sizeof(an_instruction_code));

Dengan menganggap bahwa unsigned int pada C sama dengan halfword pada Batak, maka kode di atas dapat ditulis sebagai berikut:

nptr := halfword^ (char^(@(an_instruction_code)) + 
sizeof(an_instruction_code));

Evaluasi ekspresi pada Batak lebih mudah dilakukan.

@(an_instruction_code) harus lebih dulu dilakukan (level terdalam).

Berikutnya ekspresi (pointer) ini menjadi operan bagi “operasi” konversi char^ (konversi menjadi pointer ke char).

Andaikan @(an_instruction_code) di assign ke p.

nptr := halfword^ (char^(p) + sizeof(an_instruction_code));

Tidak sulit untuk melihat kepada ekspresi apa saja operasi + diberlakukan dan apa ekspresinya. Dalam kasus Batak di atas, ekspresi penambahan di atas merupakan ekspresi penambahan alamat memori dengan nilai numerik tertentu (aritmetik pointer). Agak sulit melihat kenyataan ini dari kode C di atas, karena ada 3 tanda kurung bersusun.

(char *)
(an_instruction_code)
sizeof(an_instruction_code)

Pembaca program ini harus mengerti preseden operasi dari konversi, &, dan +. Hal ini tak perlu terjadi dengan kode di Batak.

Apakah perbedaan ini cukup berarti? Ya. Cukup besar porsi source code dengan ekspresi-ekspresi yang sulit di atas. Inilah salah satu penyebab (utama?) banyak orang Indonesia belum (?) mampu menguasai source code OS dan kompiler yang ditulis dalam C. Inilah sebabnya mengapa perlu untuk membuat source code OS dan compiler (terutama, namun tidak terbatas pada kedua jenis perangkat lunak ini) dalam bahasa lain (seperti Batak).

Penulisan ulang ini akan sangat berguna untuk lebih mendemokratisasi pengetahuan, yang selama ini cenderung dimonopoli oleh pengembang C.

Penyembunyian Informasi Di C++

class shape
{
public :
shape();
protected :
bool is_visible;
}


class ellipse : public shape
{
public :
ellipse();
protected :
int a, b;
};

class complex
{
public :
complex (float a, b);
private :
float real, imaginair;
};

Terlihat bahwa tanpa usaha tambahan, tidak ada penyembunyian informasi, karena interface (header) file memberi tahu semua informasi tentang struktur tipe-tipe (komposit). Penyembunyian informasi di C++ juga diperumit dengan access qualifier friend dan private. Batak sama sekali tak memerlukan access qualifier ini, namun bisa mencapai tujuan yang sama. Rincian bisa diperoleh di [HUTA1999].

Inortogonalitas Untuk Class Di C++

Inortogonalitas ini muncul karena pemaduan (bundling) atribut dan operasi dalam tipe. Batak memisahkan atribut dan operasi.

/* posisi.h */

class Posisi
{
protected:
int x, y;
public:
void show(); // deklarasi tidak memakai . dan ::
};

/* posisi.cpp */

void Posisi::show() { printf ("%d %d ", x, y); }; // memakai :: , diharuskan

/* main.cpp */

#include "posisi.h"

Posisi Posisi01;

void main()
{
Posisi01.show(); // memakai .
}

Pada Batak:

Module posisi;

interface

Type posisi;
void show(posisi p);

implementation

Type posisi := { integer x, y; };

void show(posisi p) { }

Program p;

Use (posisi);

integer main()
{
posisi p;
show (p);
}

Tidak ada pengecualian pada Batak (ortogonalitas lebih tinggi, mengurangi penghafalan).

Selain mendukung kepaduan konseptual, pemisahan atribut dan operasi ini juga meniadakan keperluan penghapalan kata kunci seperti this (C++) dan self (Pascal).

Parameterized Type Di C++

Mengambil kasus yang sama, stack.

template <class T> class Stack
{
public:
Stack(byte a_size)
{
if (sz < 2) sz = 2;
components = new T[pointer = size = a_size];
pointer = a_size - 1;
state = EMPTY;
}
~Stack() { delete [] components; }
private:
T* components;
byte pointer, size, state;
};

template <class T> void push(Stack<T>& S, T new_component);
template <class T> T pop(Stack<T>& S);

const byte EMPTY = 0;
const byte PARTIAL = 1;
const byte FULL = 2;

template <class T> void push(Stack<T>& S, T new_component)
{
if (S.state == FULL) // if the pointer does not yet reach the top (0)
return;
else
S.components[--S.pointer] = new_component;
if (S.state == EMPTY)
S.state = PARTIAL;
if (S.pointer == 0)
S.state = FULL;
}

template <class T> T pop(Stack<T>& S)
{
if (S.state == EMPTY)
throw "Error";
T c = S.components[S.pointer];
if (S.state == PARTIAL && S.pointer == S.size - 1)
S.state = EMPTY;
else if (S.pointer == FULL)
S.state = PARTIAL;
S.pointer++;
return(c);
}

template <class T> T top_of(const Stack<T>& S)
{ return(S.components[S.pointer]); }

Karena berbagai keterbatasan, parser Batak belum mampu memberikan sesuatu yang ekuivalen bagi kode di atas. Sebelum melihat ekivalensi bagi Batak di masa depan, mari kita lihat beberapa hal yang keliru di C++.

Baris pertama memperlihatkan pemakaian terlalu banyaknya kata kunci. Code dalam .h bisa berisi blok. Hal ini seharusnya tidak terjadi. Blok seharusnya tidak terletak di interface; melainkan, di bagian implementation.

Ketiga, operasi ~ (disebut destructor) juga tidak ortogonal. Ia bisa diletakkan di interface, namun tidak bisa dipanggil secara langsung.

Sekarang kita lihat ekuivalensinya di Batak, yang jauh lebih ringkas dan lugas/jelas.

Module stack;

Interface

byte constant EMPTY := 0, PARTIAL := 1, FULL := 2;

type Stack <type Thing>;

Stack <type Thing> Stack <type Thing> (byte a_size);
void push (Stack<type Thing>& S, Thing new_component);
Thing pop (Stack<type Thing>& S);
void delete_components (Stack<type Thing>& S);

implementation

type Stack <type Thing> :=
{ Thing^ components; byte ptr, size, state; };

Stack <type Thing> Stack <type Thing> (byte a_size)
{
Stack <Thing> S;
if (a_size < 2)
S.size := 2;
else
S.size := a_size;
S.ptr := S.size;
S.state := EMPTY;
return (S);
}

void push(Stack<type Thing>& S, Thing new_component)
{
if (S.state = FULL)
/* if the pointer does not yet reach the top (0) */
return();
else
S.components[--S.pointer] := new_component;
if (S.state = EMPTY)
S.state := PARTIAL;
if (S.ptr = 1)
S.state := FULL;
}

Thing pop(Stack<type Thing>& S)
{
if (S.state == EMPTY)
raise(-1);
Thing c := S.components[S.pointer];
if (S.state = PARTIAL and S.pointer = S.size)
S.state := EMPTY;
else if (S.pointer = FULL)
S.state := PARTIAL;
S.ptr++;
return(c);
}

Thing top_of(Stack<type Thing> S) { return(S.components[S.pointer]); }

void delete_entries (Stack<type Thing>& S); { delete (S.components); }

Module dan Program: Aturan Scope

Ada alasan lain pemakaian (secara eksplisit) tipe module dan program: untuk penyederhanaan implementasi aturan scope (namespace). Karena keterbatasan tempat, rinciannya tidak dibahas, dan pembaca bisa mengacu kepada Tugas Akhir Saudara Rudy Harinugroho [HARI1999].

Tipe Real-World Table

Tabel sebagai parameterized type bukanlah angan-angan belaka. Oracle telah mengimplementasikannya sejak tahun 1997 sejalan dengan munculnya produk Oracle 8. Berikut adalah contoh di Oracle:

CREATE TYPE student AS OBJECT
(
id INTEGER,
name VARCHAR(30)
);

CREATE TABLE students OF student;

UPDATE students DO id = id + 1;
UPDATE students DO id = id – 1, name = concat (name, ‘a’);

Oracle sudah cukup baik dalam hal ini dengan pemakaian kata TYPE (bukan CLASS). Yang jelek adalah pemakaian kata-kata AS OBJECT. Tipe bukanlah objek. Pemakaian kata OBJECT ini menunjukkan terlalu berpengaruhnya istilah object-oriented sehingga menimbulkan kegilaan pemakaian kata-kata object atau class. Object-oriented terlalu sering diidentikkan dengan keyword class dan object.

Daftar Pustaka

[APPL1991] Doris J. Appleby; Programming Languages: Paradigm and Practice; John Wiley and Sons

[APPL1997] Doris J. Appleby; Programming Languages: Paradigm and Practice, 2nd ed; John Wiley and Sons

[BORL1989] Borland International; Turbo Pascal 5.5 OOP Guide

[BORL1990] Borland International; Turbo Pascal 6.0 Reference Manual

[BROO1975] Frederick P. Brooks; The Mythical Man-month: Essays on Software Engineering; Addison Wesley

[BROO1995] Frederick P. Brooks; The Mythical Man-month: Essays on Software Engineering, 2nd ed; Addison Wesley

[DATE1995] Chris J. Date; An Introduction to Database Systems, 6th ed; Addison Wesley

[DATE1998] Chris J. Date dan Hugh Darwen; The Third Manifesto: Foundation for Object / Relational Databases; Addison Wesley

[DATE2000] Chris J. Date; An Introduction to Database Systems, 7th ed; Addison Wesley

[DATE2001] Chris J. Date dan Hugh Darwen; The Third Manifesto: Foundation for Future Database Systems, 2nd ed; Addison Wesley

[ECKE2000] Bruce Eckel; Thinking in Java; Prentice Hall

[ELLI1990] Margaret Ellis dan Bjarne Stroustrup; The Annotated C++ Reference Manual; Addison Wesley

[GHEZ1987] Carlo Ghezzi dan Mehdi Jazayeri; Programming Language Concepts, 2nd ed; John Wiley and Sons

[GHEZ1997] Carlo Ghezzi dan Mehdi Jazayeri; Programming Language Concepts, 3rd ed; John Wiley and Sons

[HARI1999] Rudy Harinugroho; Hirarki-tipe terpadu: Dasar Pemikiran, Sintaks, dan Implementasi Bahasa Pemrograman Batak ; STT Telkom

[HUTA1996] Bernaridho I. Hutabarat; Theoretical Foundation for Problem Analysis; Regional Symposium on Telecommunication, Electronics, Circuits, and Systems; King Mongkut Institute of Technology; Bangkok

[HUTA1999] Bernaridho I. Hutabarat; Software Engineering: Abstraction, Object-Oriented, and Beyond; draft

[KERN1988] Brian W. Kernighan dan Dennis M. Ritchie; The C Programming Language, 2nd ed; Prentice Hall

[KOEN1996] Andrew Koenig dan Barbara Moo; Ruminations on C++; Addison Wesley

[SEBE1996] Robert W. Sebesta; Concepts of Programming Language, 3rd ed; Addison Wesley

[SEBE1999] Robert W. Sebesta; Concepts of Programming Language, 4th ed; Addison Wesley

[STRO1991] Bjarne Stroustrup; The C++ Programming Language, 2nd ed; Addison Wesley

[STRO1997] Bjarne Stroustrup; The C++ Programming Language, 3rd ed; Addison Wesley

mw

 

Arsip mwmag[Files]  [Up]www.master.web.id/mwmag