Tipe Data dan Operasi dalam Pemrograman Gleam

Updated: at 22.28

Table of Contents

Open Table of Contents

Ints, Floats, dan Format Nomor

Dalam pemrograman, kita sering berurusan dengan angka, baik itu bilangan bulat (integer) atau bilangan desimal (float). Gleam menyediakan dua tipe data utama untuk merepresentasikan angka: Int untuk integer dan Float untuk float.

Ints

Tipe data Int dalam Gleam digunakan untuk merepresentasikan bilangan bulat, baik positif maupun negatif. Contoh penggunaan Int:

let jumlah_pengguna: Int = 100
let skor: Int = -50

Dalam Gleam, kita dapat melakukan berbagai operasi aritmetika pada Int seperti penjumlahan (+), pengurangan (-), perkalian (*), pembagian (/), dan modulo (%). Selain itu, operator perbandingan seperti >, <, >=, dan <= juga dapat digunakan.

let x = 10
let y = 5

io.debug(x + y) // 15
io.debug(x - y) // 5
io.debug(x * y) // 50
io.debug(x / y) // 2
io.debug(x % y) // 0
io.debug(x > y) // True

Presisi adalah hal yang sangat penting saat berurusan dengan angka, terutama dalam konteks keuangan. Misalnya, jika Kita sedang membuat aplikasi perbankan, kita harus memastikan bahwa setiap perhitungan dilakukan dengan benar hingga sen terakhir. Kesalahan kecil dapat berakibat fatal dan merugikan pengguna.

Dalam kasus seperti ini, lebih baik menggunakan tipe data Int daripada Float untuk merepresentasikan nilai uang, karena Float dapat mengalami masalah presisi akibat keterbatasan representasi biner.1 Dengan Int, kita dapat melacak sen sebagai bilangan bulat dan menghindari kesalahan presisi.

Floats

Tipe data Float dalam Gleam digunakan untuk merepresentasikan bilangan desimal. Floats ditulis dengan menambahkan titik desimal pada angka.

let pi = 3.14159
let suhu = -10.5

Gleam menyediakan operator aritmetika khusus untuk Float yang dibedakan dengan tambahan titik (.) pada operator. Misalnya, penjumlahan float dilakukan dengan +., bukan +.

let x = 10.0
let y = 5.5

io.debug(x +. y) // 15.5
io.debug(x -. y) // 4.5
io.debug(x *. y) // 55.0
io.debug(x /. y) // 1.8181818181818181

Perlu diperhatikan bahwa dalam Gleam, pembagian dengan 0 pada Float tidak akan menghasilkan error, melainkan menghasilkan nilai Infinity atau -Infinity.[^2] Namun, menggunakan hasil Infinity dalam operasi lain dapat menyebabkan hasil yang tidak terdefinisi (NaN).

io.debug(1.0 /. 0.0)  // Infinity
io.debug(-1.0 /. 0.0) // -Infinity
io.debug(0.0 /. 0.0)  // NaN

Dalam dunia nyata, floats sering digunakan untuk merepresentasikan pengukuran fisik seperti suhu, berat, atau jarak. Namun, karena keterbatasan presisi, floats tidak cocok untuk situasi yang membutuhkan ketelitian tinggi seperti perhitungan keuangan. Dalam kasus seperti itu, ada tipe data desimal khusus (seperti Decimal) yang lebih tepat digunakan.[^3]

Format Nomor

Gleam menyediakan beberapa fitur untuk memformat angka agar lebih mudah dibaca. Kita dapat menambahkan garis bawah (_) sebagai pemisah ribuan pada angka yang besar.

let penduduk_indonesia = 273_523_615
let pib_indonesia = 1_058_400_000_000.90

Selain itu, literal Int juga dapat ditulis dalam format biner (dengan awalan 0b), oktal (0o), atau heksadesimal (0x).

let mask = 0b1111_0000
let permission = 0o644
let color = 0xFF_00_FF

Untuk Float, Gleam mendukung notasi ilmiah menggunakan huruf e.

let avogadro = 6.022e23
let electron_mass = 9.109e-31

Kemampuan untuk memformat angka dengan jelas sangat penting untuk meningkatkan keterbacaan kode. Dengan pemisah ribuan, representasi biner/oktal/heksadesimal, dan notasi ilmiah, kita dapat menyajikan angka dengan cara yang lebih bermakna dan kontekstual, sehingga mengurangi kesalahan interpretasi.

Dalam komunikasi sehari-hari pun, kita sering menggunakan format khusus untuk menyampaikan angka. Misalnya, kita menuliskan nomor telepon dengan pemisah, seperti “081-234-567-890”. Atau, dalam laporan ilmiah, angka sering ditulis dengan notasi ilmiah untuk menunjukkan skala. Memilih representasi yang tepat adalah kunci untuk komunikasi yang efektif, baik dalam pemrograman maupun dalam kehidupan.

Equality

Konsep kesetaraan (equality) adalah fundamental dalam pemrograman. Gleam menyediakan operator == untuk memeriksa apakah dua nilai sama, dan != untuk memeriksa ketidaksamaan.

let x = 10
let y = 10
let z = 11

io.debug(x == y) // True
io.debug(x != z) // True

Yang menarik, operator == dan != dalam Gleam dapat digunakan untuk membandingkan nilai dari tipe data apapun, asalkan kedua sisi operator bertipe sama. Ini berbeda dengan beberapa bahasa pemrograman lain yang membutuhkan operator khusus untuk perbandingan string atau tipe data lainnya.

io.debug("Hello" == "Hello") // True
io.debug(True != False) // True
io.debug([1, 2] == [1, 2]) // True

Perlu dicatat bahwa Gleam memeriksa kesetaraan secara struktural, bukan berdasarkan referensi memori. Artinya, dua nilai dianggap sama jika memiliki struktur atau isi yang sama, meskipun mereka adalah objek yang berbeda di memori.[^4]

Dalam konteks sosial, konsep kesetaraan menjadi lebih kompleks dan sarat makna. Kesetaraan sering dikaitkan dengan gagasan keadilan, non-diskriminasi, dan memberikan kesempatan yang sama bagi semua orang, terlepas dari perbedaan latar belakang.[^5]

Namun, seperti dalam pemrograman, kesetaraan tidak selalu berarti keidentikan. Dua individu mungkin memiliki hak dan martabat yang sama, tetapi tetap memiliki karakteristik dan keunikan masing-masing. Tantangannya adalah menemukan keseimbangan antara menghargai keragaman sambil memperlakukan semua orang dengan rasa hormat dan keadilan yang sama.

Dalam dunia yang semakin terpolarisasi, pemahaman yang lebih bernuansa tentang kesetaraan menjadi semakin penting. Kita perlu melihat melampaui kategori dan label, dan mengenali kemanusiaan yang sama dalam diri setiap orang. Dengan melakukannya, kita dapat membangun masyarakat yang lebih inklusif dan setara.

Strings

Dalam Gleam, tipe data String digunakan untuk merepresentasikan teks. String ditulis dalam tanda kutip ganda (""), dan dapat berisi berbagai karakter, termasuk karakter Unicode.

let nama = "John Doe"
let salam = "Halo, dunia! 😊"

String dapat mencakup beberapa baris dan mengandung beberapa karakter escape:

let puisi = "Mawar itu merah,\nViolet itu biru,\n\"Aku mencintaimu,\" katanya,\nDan aku pun tahu."

Untuk menggabungkan string, kita dapat menggunakan operator <>.

let nama_depan = "John"
let nama_belakang = "Doe"
let nama_lengkap = nama_depan <> " " <> nama_belakang

String adalah salah satu tipe data yang paling sering digunakan dalam pemrograman, karena begitu banyak informasi di dunia nyata yang direpresentasikan sebagai teks. Dari nama pengguna dan alamat email, hingga pesan chat dan postingan media sosial, pemrosesan string adalah bagian integral dari banyak aplikasi.

Namun, bekerja dengan string bisa menjadi rumit karena variasi encoding karakter, aturan pembandingan, dan lokalisasi. Misalnya, membandingkan string dengan mempertimbangkan case-sensitivity, atau mengubah string menjadi representasi yang sesuai untuk lokale yang berbeda.

Pustaka standar Gleam menyediakan modul string yang berisi banyak fungsi untuk memanipulasi dan memproses string dengan mudah dan efisien. Beberapa contohnya:

import gleam/string

io.debug(string.uppercase("hello")) // "HELLO"
io.debug(string.contains?("hello world", "world")) // True
io.debug(string.replace("hello world", "world", "gleam")) // "hello gleam"

Dalam komunikasi manusia, bahasa adalah analog yang paling dekat dengan string dalam pemrograman. Kita menggunakan bahasa untuk mengekspresikan ide, berbagi informasi, dan berinteraksi dengan orang lain. Sama seperti string, bahasa bisa sangat kaya dan beragam, dengan aturan tata bahasa dan nuansa yang kompleks.

Memahami konteks dan makna di balik kata-kata adalah keterampilan penting dalam komunikasi, seperti halnya memproses string dengan benar adalah penting dalam pemrograman. Dalam kedua kasus, tujuannya adalah untuk menyampaikan informasi dengan jelas dan akurat, sambil menghindari ambiguitas dan kesalahpahaman.

Bools

Tipe data Bool dalam Gleam merepresentasikan nilai kebenaran, yang hanya dapat berupa True atau False.

let benar = True
let salah = False

Bool sering digunakan dalam pernyataan kondisional dan perulangan untuk menentukan alur program berdasarkan kondisi tertentu. Gleam menyediakan operator logika && (dan), || (atau), dan ! (negasi) untuk memanipulasi nilai bool.

let hujan = True
let membawa_payung = False

if hujan && !membawa_payung {
  io.println("Kamu akan basah!")
}

Operator && dan || mengevaluasi kondisi secara “short-circuit”, yang berarti jika hasil operasi dapat ditentukan hanya dengan melihat nilai di sisi kiri operator, nilai di sisi kanan tidak akan dievaluasi. Ini berguna untuk mengoptimalkan performa dan menghindari error ketika mengevaluasi kondisi.

let pembagi = 0

if pembagi != 0 && 10 / pembagi > 2 {
  io.println("Hasil lebih besar dari 2")
} else {
  io.println("Pembagi tidak valid")
}

Dalam contoh di atas, jika pembagi adalah 0, kondisi kedua 10 / pembagi > 2 tidak akan dievaluasi karena bagian pertama pembagi != 0 sudah False, sehingga menghindari error “division by zero”.

Bool sering digunakan dalam pengambilan keputusan di dunia nyata. Kita terus-menerus menghadapi situasi di mana kita harus mengevaluasi kondisi dan memilih tindakan berdasarkan hasil evaluasi tersebut. Misalnya:

Namun, tidak seperti dalam pemrograman di mana segalanya hitam dan putih, pengambilan keputusan dalam hidup seringkali melibatkan area abu-abu dan ketidakpastian. Kita harus mempertimbangkan faktor-faktor tambahan, menimbang risiko dan manfaat, dan kadang-kadang membuat penilaian berdasarkan informasi yang tidak lengkap.

Terlepas dari kompleksitas tambahan ini, kemampuan untuk berpikir secara logis dan mengevaluasi kondisi tetap menjadi keterampilan penting. Dengan melatih otot “bool” kita, baik dalam pemrograman maupun dalam kehidupan sehari-hari, kita bisa menjadi pembuat keputusan yang lebih baik dan pemecah masalah yang lebih efektif.

Assignments

Dalam Gleam, kita dapat menetapkan nilai ke variabel menggunakan kata kunci let.

let x = 10
let y = "hello"
let z = True

Variabel dalam Gleam bersifat immutable, yang berarti nilainya tidak dapat diubah setelah ditetapkan. Jika kita mencoba menetapkan nilai baru ke variabel yang sudah ada, sebenarnya kita membuat variabel baru dengan nama yang sama, yang akan menggantikan variabel lama dalam cakupan saat ini.

let x = 10
io.debug(x) // 10

let x = 20
io.debug(x) // 20

Immutabilitas mungkin tampak seperti batasan pada awalnya, tetapi sebenarnya ini adalah fitur yang kuat. Ini membuat kode lebih mudah dipahami dan di-debug, karena Kita tahu bahwa nilai variabel tidak akan berubah secara tak terduga. Ini juga mendorong gaya pemrograman yang lebih fungsional dan deklaratif, di mana kita lebih fokus pada transformasi data daripada mutasi status.[^6]

Saat menetapkan variabel, kita dapat secara opsional menentukan tipe datanya menggunakan anotasi tipe.

let usia: Int = 30
let nama: String = "Alice"

Meskipun tidak wajib (karena Gleam memiliki inferensi tipe), anotasi tipe dapat meningkatkan keterbacaan kode dan membantu menangkap kesalahan tipe saat compile-time.

Konsep assignment dapat ditemukan di banyak aspek kehidupan kita. Kita terus-menerus menetapkan peran, tanggung jawab, dan arti ke orang, benda, dan ide di sekitar kita. Misalnya:

Seperti dalam pemrograman, “assignment” dalam hidup bisa bersifat sementara atau permanen, eksplisit atau implisit, dan dapat dipengaruhi oleh konteks dan cakupan. Terkadang, kita perlu “me-reassign” penilaian atau ekspektasi kita ketika kita mendapatkan informasi baru atau perspektif yang berbeda.

Inti dari assignment, baik dalam pemrograman maupun dalam hidup, adalah tentang memberi struktur dan makna pada dunia di sekitar kita. Dengan menetapkan nilai dan arti secara sadar dan disengaja, kita dapat membuat model mental yang lebih jelas dan koheren, yang memungkinkan kita untuk memahami, memprediksi, dan berinteraksi dengan realitas dengan lebih efektif.

Discard Patterns

Dalam Gleam, jika sebuah variabel ditetapkan tetapi tidak pernah digunakan, kompiler akan mengeluarkan peringatan. Ini adalah fitur yang berguna untuk menghindari variabel yang tidak perlu dan menjaga kode tetap bersih.

Namun, kadang-kadang kita mungkin ingin menetapkan nilai ke variabel hanya untuk efek sampingnya (seperti logging), atau karena itu adalah bagian dari pola yang lebih besar (seperti saat melakukan destructuring). Dalam kasus seperti ini, kita dapat menggunakan “discard pattern” dengan memberi awalan garis bawah (_) ke nama variabel.

let _tidak_digunakan = 42

let (x, _, z) = (1, 2, 3)
io.debug(x) // 1
io.debug(z) // 3

Pola ini memberi tahu kompiler bahwa kita sengaja mengabaikan nilai dan menekan peringatan tentang variabel yang tidak digunakan.

Konsep “membuang” atau “mengabaikan” juga relevan dalam kehidupan sehari-hari. Kita sering dihadapkan pada informasi atau rangsangan yang tidak relevan dengan tujuan atau prioritas kita saat ini. Kemampuan untuk memfilter “noise” dan fokus pada apa yang penting adalah keterampilan kunci dalam dunia yang semakin kompleks dan penuh informasi ini.

Misalnya, saat bekerja di sebuah proyek, kita mungkin perlu “membuang” ide-ide atau fitur yang tidak sesuai dengan cakupan atau kendala proyek, meskipun mereka mungkin menarik di tempat lain. Atau saat mempelajari keterampilan baru, kita mungkin perlu “mengabaikan” teknik atau pendekatan yang tidak efektif untuk kita, meskipun mereka mungkin berfungsi untuk orang lain.

Namun, penting untuk diingat bahwa “membuang” tidak selalu berarti menghapus sepenuhnya. Sama seperti variabel yang di-discard masih ada di memori (meskipun tidak dapat diakses), ide atau pengalaman yang kita kesampingkan masih bisa membentuk pemahaman dan pertumbuhan kita dengan cara yang halus. Terkadang, wawasan paling berharga muncul bukan dari apa yang kita fokuskan, tetapi dari apa yang kita pilih untuk tidak fokuskan.

Pada akhirnya, seni membuang adalah tentang memprioritaskan dan mengoptimalkan penggunaan sumber daya kita yang terbatas - baik itu memori komputer, waktu, atau energi mental. Dengan secara sadar memilih apa yang harus diperhatikan dan apa yang diabaikan, kita dapat menavigasi hidup dengan lebih ringan, lebih terarah, dan lebih efisien.

Type Imports

Dalam proyek Gleam yang lebih besar, kode biasanya dibagi menjadi beberapa modul untuk organisasi dan enkapsulasi yang lebih baik. Setiap modul dapat mendefinisikan tipe data kustom yang mewakili konsep domain yang relevan.

Untuk menggunakan tipe yang didefinisikan dalam modul lain, kita perlu mengimpornya. Gleam mendukung dua jenis impor tipe: impor terkualifikasi dan impor tidak terkualifikasi.

Dengan impor terkualifikasi, kita mereferensikan tipe dengan awalan nama modulnya.

import gleam/list

let my_list: list.List(Int) = [1, 2, 3]

Dengan impor tidak terkualifikasi, kita dapat menggunakan tipe secara langsung tanpa awalan modul. Ini dilakukan dengan mencantumkan tipe dalam pernyataan import dengan menggunakan kata kunci type.

import gleam/list.{type List}

let my_list: List(Int) = [1, 2, 3]

Memilih antara impor terkualifikasi dan tidak terkualifikasi sebagian besar adalah masalah preferensi dan konvensi. Secara umum, tipe lebih sering diimpor secara tidak terkualifikasi dibandingkan dengan fungsi, karena mereka cenderung digunakan lebih sering dan membuat kode lebih mudah dibaca.

Konsep impor tipe analog dengan ide berbagi dan menggunakan kembali pengetahuan dalam kehidupan nyata. Sama seperti modul memungkinkan kita untuk mengatur kode ke dalam unit yang kohesif dan dapat digunakan kembali, bidang pengetahuan manusia (seperti matematika, sains, seni, dll.) bertindak sebagai “modul” konseptual yang berisi abstraksi dan alat khusus domain.

Ketika kita menghadapi masalah di satu bidang, seringkali bermanfaat untuk “mengimpor” wawasan dan teknik dari bidang lain. Misalnya:

Namun, sama seperti dalam pemrograman, kita harus berhati-hati saat “mengimpor” ide dari konteks yang berbeda. Tidak semua konsep dapat diterjemahkan secara langsung antar domain, dan beberapa mungkin memerlukan adaptasi atau rekontekstualisasi agar sesuai dengan situasi baru.

Kuncinya adalah menyeimbangkan keluasan dan kekhususan - untuk menjadi terbuka terhadap perspektif lintas-disiplin sambil tetap menghormati kompleksitas dan nuansa setiap bidang. Dengan mengembangkan “keterampilan impor” ini, kita dapat menjadi pemikir yang lebih fleksibel dan inovatif, mampu menggambar dari beragam sumber pengetahuan untuk memecahkan masalah yang paling sulit sekalipun.

Type Aliases

Gleam memungkinkan kita untuk mendefinisikan alias untuk tipe yang sudah ada menggunakan kata kunci type. Alias tipe tidak menciptakan tipe baru, tetapi hanya memberikan nama alternatif untuk tipe yang sudah ada.

type UserId = Int
type Username = String

let id: UserId = 123
let name: Username = "alice"

Alias tipe berguna untuk memberikan makna kontekstual ke tipe data yang lebih umum. Mereka membuat kode lebih mudah dibaca dan dipahami dengan menyampaikan maksud dari nilai pada tingkat tipe.

Selain itu, alias tipe dapat membantu mengurangi pengulangan dan meningkatkan konsistensi di seluruh codebase. Jika tipe data kompleks digunakan di banyak tempat, memberikannya alias yang deskriptif dapat membuat kode lebih ringkas dan lebih mudah dikelola.

type Url = String

type User =
  {
    id: UserId
    name: Username
    email: Url
    website: Url
  }

Dalam contoh di atas, Url adalah alias untuk String, yang digunakan dalam definisi rekaman User. Ini membuat jelas bahwa nilai string tertentu dimaksudkan untuk mewakili URL, tanpa harus mengulangi String di setiap bidang.

Konsep memberikan “alias” untuk hal-hal juga hadir dalam banyak aspek kehidupan kita. Kita sering menggunakan panggilan sayang, julukan, atau gelar untuk merujuk ke orang, tempat, atau ide dengan cara yang lebih akrab, deskriptif, atau kontekstual.

Misalnya:

Dalam setiap kasus, alias berfungsi sebagai jembatan antara sesuatu yang abstrak atau umum dan realitas spesifik kita. Mereka memungkinkan kita untuk menghubungkan makna pribadi atau kontekstual dengan entitas yang mungkin tampak impersonal atau terpisah sebaliknya.

Namun, sama seperti dalam pemrograman, penting untuk menggunakan alias dengan hemat dan pertimbangan. Terlalu banyak alias dapat menyebabkan kebingungan dan ambiguitas, terutama jika mereka tidak konsisten atau intuitif. Alias harus memperjelas dan bukan mengaburkan makna yang mendasarinya.

Pada akhirnya, kekuatan alias terletak pada kemampuannya untuk menghubungkan dunia abstrak tipe dan dunia nyata pengalaman manusia. Dengan memberikan nama yang bermakna untuk pola dan struktur dalam hidup kita, kita dapat membuat realitas kita lebih dapat dipahami, lebih relatable, dan lebih mudah dinavigasi.

Blocks

Dalam Gleam, blok adalah serangkaian ekspresi yang dikelompokkan bersama menggunakan kurung kurawal ({}). Mereka memungkinkan kita untuk mengelompokkan kode terkait dan mengontrol cakupan variabel.

Setiap ekspresi dalam blok dievaluasi secara berurutan, dan nilai ekspresi terakhir menjadi nilai blok secara keseluruhan.

let hasil = {
  let x = 10
  let y = 20
  x + y
}

io.debug(hasil) // 30

Variabel yang dideklarasikan di dalam blok hanya dapat diakses dari dalam blok tersebut. Ini membantu mencegah kebocoran variabel dan menghindari bentrokan penamaan yang tidak disengaja.

let x = 10

{
  let x = 20
  io.debug(x) // 20
}

io.debug(x) // 10

Blok juga berguna untuk mengontrol urutan evaluasi dalam ekspresi. Dalam Gleam, operator * dan / memiliki prioritas yang lebih tinggi daripada + dan -. Kita dapat menggunakan blok untuk secara eksplisit menentukan urutan operasi.

let hasil = 10 + 20 * 2
io.debug(hasil) // 50

let hasil2 = { 10 + 20 } * 2
io.debug(hasil2) // 60

Konsep “blok” dapat ditemukan dalam banyak aspek kehidupan kita. Kita sering mengelompokkan aktivitas, ide, atau orang terkait bersama untuk menciptakan struktur dan organisasi.

Misalnya:

Seperti dalam pemrograman, “blok” dalam hidup membantu kita membuat abstraksi dan menyembunyikan detail. Mereka memungkinkan kita untuk berpikir tentang sistem yang kompleks dalam hal komponen modular, masing-masing dengan tanggung jawab dan cakupan yang jelas.

Namun, terlalu banyak “pemblokiran” juga bisa kontraproduktif. Jika kita terlalu ketat dalam mengelompokkan hal-hal, kita dapat kehilangan gambaran yang lebih besar dan melewatkan koneksi penting antar domain. Terkadang wawasan paling berharga muncul ketika kita melintasi batas dan melihat bagaimana “blok” yang tampaknya berbeda sebenarnya terkait.

Kuncinya, seperti banyak hal dalam hidup, adalah keseimbangan. Kita perlu struktur dan organisasi untuk mengelola kompleksitas, tetapi kita juga perlu fleksibilitas dan adaptabilitas untuk merespons perubahan. Dengan bijak menggunakan “blok” - baik dalam kode kita dan dalam hidup kita - kita dapat menciptakan sistem yang kuat namun fleksibel, mampu berkembang seiring waktu.

Lists dan Constants

Gleam menyediakan dua konstruksi penting untuk bekerja dengan koleksi nilai: lists dan constants.

Lists

List adalah struktur data yang berisi urutan nilai. Mereka ditulis sebagai nilai yang dipisahkan koma di antara tanda kurung siku ([]).

let numbers = [1, 2, 3, 4, 5]
let fruits = ["apple", "banana", "orange"]

List dalam Gleam bersifat homogen, artinya semua elemen dalam list harus memiliki tipe yang sama. Tipe list ditulis sebagai List(T), di mana T adalah tipe elemennya.

let numbers: List(Int) = [1, 2, 3]
let fruits: List(String) = ["apple", "banana"]

List adalah struktur data yang sangat serbaguna dan banyak digunakan. Mereka mewakili salah satu cara paling dasar untuk mengatur dan memanipulasi koleksi item.

Dalam kehidupan nyata, kita terus-menerus berurusan dengan “list” dalam berbagai bentuk:

Seperti dalam pemrograman, “list” dalam hidup membantu kita membawa tatanan pada dunia yang kacau. Mereka memungkinkan kita untuk mengambil kelompok entitas terkait (baik itu objek, ide, atau tindakan) dan memperlakukannya sebagai satu unit konseptual.

Namun, seperti list dalam Gleam, “list” dalam kehidupan nyata juga cenderung homogen - mereka paling efektif ketika mereka berisi item yang secara fundamental serupa. Daftar belanjaan yang mencampur bahan makanan dan tugas rumah tangga mungkin lebih membingungkan daripada membantu. Menu yang mencampur makanan utama dan makanan penutup mungkin sulit dinavigasi.

Tantangannya adalah menemukan tingkat abstraksi yang tepat - untuk membuat list kita cukup luas untuk menjadi inklusif, tetapi cukup spesifik untuk tetap koheren dan bermanfaat. Dan seperti dalam pemrograman, ini mungkin memerlukan beberapa iterasi dan penyempurnaan seiring waktu.

Constants

Selain variabel yang dideklarasikan dengan let, Gleam juga memiliki konsep konstanta. Konstanta didefinisikan menggunakan kata kunci const dan harus memiliki nilai literal.

const PI = 3.14159
const DEFAULT_NAME = "Anonymous"

Tidak seperti variabel let, konstanta tidak dapat diubah nilainya. Mereka mewakili nilai tetap yang dapat direferensikan di manapun dalam kode Kita.

Konstanta berguna untuk mewakili nilai yang memiliki makna khusus dalam domain masalah kita. Dengan memberi mereka nama yang bermakna, kita dapat membuat kode kita lebih mudah dibaca dan lebih mudah dipelihara.

Dalam hidup, kita juga memiliki “konstanta” - nilai, keyakinan, atau prinsip yang tetap konstan di tengah perubahan. Misalnya:

Seperti dalam pemrograman, “konstanta” dalam hidup memberikan rasa stabilitas dan kontinuitas. Mereka menjadi fondasi yang di atasnya kita dapat membangun pemahaman dan membuat keputusan kita.

Namun, penting untuk diingat bahwa bahkan “konstanta” dapat berubah dalam keadaan yang tepat. Nilai moral berkembang seiring perkembangan masyarakat. Teori ilmiah direvisi dalam menghadapi bukti baru. Tradisi beradaptasi untuk mencerminkan realitas yang berubah.

Jadi mungkin pelajaran terpenting adalah mengetahui kapan harus menganggap sesuatu sebagai “konstanta” dan kapan harus terbuka untuk kemungkinan perubahan. Dengan kebijaksanaan untuk membedakan antara keduanya, kita dapat menavigasi kehidupan dengan rasa tujuan dan fleksibilitas - tetap setia pada inti kita sambil beradaptasi dengan dunia yang terus berubah di sekitar kita.

Kesimpulan

Melalui eksplorasi berbagai fitur dan konsep dalam bahasa pemrograman Gleam, kita telah melihat bagaimana prinsip-prinsip pemrograman dapat diterapkan dalam kehidupan sehari-hari. Dari bekerja dengan tipe data yang berbeda hingga mengorganisasikan kode ke dalam blok dan konstanta, kita telah menemukan banyak kesamaan antara cara kita berinteraksi dengan komputer dan cara kita berinteraksi dengan dunia.

Beberapa tema utama yang muncul:

  1. Presisi dan Kejelasan: Baik dalam pemrograman maupun dalam komunikasi manusia, being precise dan jelas tentang makna dan maksud kita adalah kunci. Tipe data dan anotasi tipe membantu kita mencapai ini dalam kode, sementara pilihan kata dan konteks membantu kita mencapainya dalam bahasa.

  2. Abstraksi dan Modularitas: Mengorganisasikan sistem yang kompleks menjadi bagian-bagian yang lebih kecil dan lebih mudah dipahami adalah keterampilan penting dalam pemrograman dan dalam hidup. Teknik seperti pemblokiran kode, impor tipe, dan penggunaan konstanta semuanya berkontribusi pada tujuan ini.

  3. Fleksibilitas dan Adaptabilitas: Meskipun struktur dan organisasi itu penting, kita juga harus siap beradaptasi dan berubah seiring waktu. Dalam Gleam, ini tercermin dalam konsep seperti reassignment variabel dan shadowing. Dalam hidup, ini berarti terbuka untuk ide dan perspektif baru.

  4. Menjembatani Kesenjangan antara Abstrak dan Konkret: Pemrograman sering kali melibatkan penerjemahan konsep abstrak menjadi istilah konkret yang dapat dipahami komputer. Demikian pula, banyak tantangan terbesar dalam hidup melibatkan pengartian prinsip abstrak (seperti kebaikan, kebenaran, atau keindahan) dalam istilah praktis sehari-hari.

Pada akhirnya, pemrograman bukan hanya tentang menulis kode - ini adalah cara berpikir tentang dunia. Ini adalah tentang memecah masalah yang kompleks menjadi komponen yang dapat dikelola, tentang menemukan pola dalam kekacauan, dan tentang menciptakan makna dalam dunia abstraksi.

Dan bukankah itu juga esensi dari kehidupan manusia? Kita terus-menerus berusaha untuk memahami kompleksitas keberadaan kita, untuk menemukan urutan dalam kekacauan, dan untuk menciptakan makna dalam pengalaman kita. Kita adalah, dalam banyak hal, programmer realitas kita sendiri.

Jadi mungkin pelajaran terakhir dan terbesar adalah ini: Bahwa alat terbaik untuk navigasi kehidupan adalah pikiran yang terlatih dengan baik - pikiran yang dapat berpikir seperti programmer. Dengan menguasai seni berpikir logis, abstraksi, dan pemecahan masalah, kita menjadi lebih siap untuk menghadapi tantangan apa pun yang mungkin dihadapi oleh kehidupan.

Bahasa pemrograman mungkin datang dan pergi, tetapi keterampilan berpikir yang kita kembangkan melalui pemrograman adalah untuk seumur hidup. Merekalah yang, pada akhirnya, memungkinkan kita untuk menulis kode paling penting dari semua: kisah hidup kita sendiri.

Referensi

Footnotes

  1. Gleam Docs, “Built-in Types”. https://tour.gleam.run/table-of-contents/ ↩