**Magik** adalah bahasa pemrograman berorientasi objek yang memiliki karakteristik yaitu mendukung pewarisan berganda, *polimorfism*, dan tanpa adanya deklarasi tipe data seperti pada bahasa Smalltalk dan banyak bahasa script lainnya. Dikembangkan dan dipasarkan oleh GE Energy yang berbasis pada teknologi Smallworld dan didisain khusus untuk memenuhi kebutuhan aplikasi GIS yang sangat kompleks yang dibutuhkan oleh perusahaan besar seperti penyedia tenaga listrik dan telekomunikasi.

Magik pertama kali diperkenalkan pada tahun 1990 dan terus mengalami penyempurnaan hingga saat ini sudah mencapai versi Magik VM 6.12.8 SF (Small Footprint).

Kemiripan dengan SmallTalk
--------------------------

Ada beberapa kemiripan Magik dengan bahasa Smalltalk yaitu dalam fitur-fitur yang disediakan maupun arsitekturnya sendiri. Magik dikompilasi menjadi serangkaian kode binari yang diterjemahkan oleh *Magik Virtual Machine*. Magik Virtual Machine ini tersedia dalam berbagai platform sistem operasi termasuk Microsoft Windows, dan beberapa versi Linux dan Unix.

Bahasa Magik sendiri adalah berbasis Console (editor yang sering dipakai adalah GNU Emacs) dan kode program dapat langsung dimodifikasi meskipun aplikasi sedang berjalan. Console juga dapat digunakan untuk mengeksekusi baris perintah Magik dan melihat hasilnya.

Baris kode yang terkompilasi disimpan dalam satu file yang disebut *Image File*. Selain itu image file juga menyimpan segala perubahan yang terjadi pada saat sesi tersebut terakhir disimpan.

Fitur-fitur yang disediakan
---------------------------

Komentar
Magik menggunakan token `#` untuk menandai suatu baris yang ingin dijadikan komentar.

```
 # Ini adalah contoh cara membuat komentar dalam bahasa magik
```

Assignments / Penugasan
Magik menggunakan operator `<<` yang menandakan pemberian suatu penugasan:

```
 a<<1.234
 b<<b+a
```

Notasi di atas dapat diartikan "Variabel A diisi oleh 1.234" dan "Variabel b diisi oleh variabel b sendiri ditambah a".

Magik juga mendukung variasi penugasan yang lebih ringkas yang cara penulisannya mirip dengan bahasa **C**:

```
 b+<<a # Ekivalen dengan b<<b+a
```

Symbol
Magik memiliki tipe data symbol dimana tipe data ini sama seperti tipe data biasa seperti Integer, float and string.
Simbol adalah tipe data spesial yang sering digunakan dalam Magik untuk mengidentifikasikan secara unik suatu objek. Cara penulisannya adalah dengan menggunakan huruf titik koma diikuti oleh beberapa huruf. Simbol dapat juga ditambahkan garis lurus setelah titik koma jika nama simbol mempunyai spasi di antara dua huruf/kata. For example:

```
 a<<:hello  
 b<<:|hello world|
```

Tanpa deklarasi tipe data
Variabel dalam Magik tidak perlu dideklarasikan terlebih dahulu dan dapat menampung objek yang berbeda pada saat runtime. Semua yang ada di dalam Magik adalah objek (tidak ada perbedaan antara objek dan tipe data yang lain misalnya seperti integer):

```
 a<<1.2     # Variabel a menampung angka yang bertipe data float
 a<<"1.2"   # Disini variabel a juga dapat menampung tipe data string
```

Objek
Untuk mendefinisikan objek atau kelas di dalam Magik digunakan kata *exemplars*. Magik mensupport pewarisan berganda, and *mixins*(suatu function yang tidak ada datanya). Instan baru dapat dibuat dengan cara meng-cloning instan yang sudah ada.

Exemplars baru dapat dibuat menggunakan baris perintah `def_slotted_exemplar()`, sebagai contoh:

```
 def_slotted_exemplar(:objek_ku,
 {
   {:slot_a,34},
   {:slot_b,"hallo"}
 },{:objek_a,:objek_b})
```

Baris perintah di atas dapat diartikan bahwa kita membuat suatu kelas baru dengan nama:objek\_ku yang memiliki dua buah field yaitu:slot\_a yang berisi nilai 34 dan:slot\_b yang berisi kata "hallo" dan kelas ini mewarisi dari dua buah exemplars yang sudah ada yaitu:objek\_a dan:objek\_b.

Comparison / Perbandingan
Magik seperti bahasa yang lain juga menggunakan binari operator (`=`, `<`, `<=`, `>`, `>=`, `~=/<>`) untuk perbandingan.
Operator `_is` and `_isnt` juga dipakai sebagai perbandingan dan biasanya digunakan untuk membandingkan antara dua buah instan objek.

Contoh:

```
 a << "hello"
 b << "hello"
```

```
 a = b mengembalikan nilai True (_true) karena nilai dari a dan b adalah sama
 a _is b mengembalikan nilai False (_false) karena instan a tidak sama dengan instan b
```

```
 a << "hello"
 b << a
```

```
a = b mengembalikan nilai True (_true) karena nilai a dan b sama
a _is b mengembalikan nilai True (_true) karena b dan a ke instan objek yang sama tapi bukan nilainya
```

Methods
Methods didefinisikan dalam exemplars menggunakan baris perintah `_method` dan `_endmethod`:

```
 _method objek_ku.method_ku (a, b)
   _return a+b
 _endmethod
```

Methods bisa dijadikan private (tidak untuk digunakan oleh public) dengan menggunakan baris perintah `_private`. Private methods ini hanya dapat dipanggil dengan baris perintah `_self`, `_super` and `_clone`.

Iteration / Iterasi
Iterasi dalam Magik menggunakan baris perintah `_for`, `_over`, `_loop` and `_endloop`.

```
 _method objek_ku.method_ku (_gather values)
   total<<0.0
   _for a _over values.elements()
   _loop
      total+<<a
   _endloop
   _return total
 _endmethod
```

```
 m<<objek_ku.new()
 x<<m.method_ku(1.0,2,3.0,4) # x=10.0
```

Procedure
Magik juga mensupport penggunaan fungsi namanya procedure. Procedure juga merupakan objek dan dideklarasikan menggunakan baris perintah `_proc` and `_endproc`.

```
 procedure_ku<<_proc @procedure_ku (a, b, c)
   _return a+b+c
 _endproc
```

```
 x<<procedure_ku(1,2,3) # x=6
```

Ejaan khusus
Karena Magik awalnya dikembangkan di Inggris, method-method yang ada di dalam Smallworld Core menggunakan ejaan *British* bukan *American*. Contohnya:

```
  Gunakan kata "initialise", bukan "initialize".
```

|  |  |
| --- | --- |
| Pengawasan otoritas Sunting ini di Wikidata | 
* Microsoft Academic

 |