Content: Revisit the basic.

Belajar lagi, lagi dan lagi. Jangan berhenti, nanti pasti ada kesempatan.

Lulus kuliah aku berhenti baca buku politik, teori sosial dan sejenisnya, berhenti ngutak-atik proyek CodeIgniter juga. Aku mau belajar web-design. Tapi di perpustakaan nemu buku Python setelah sampai di rumah aku install nodejs lalu clone proyek flask+react. Waktu itu ga mikir panjang kenapa aku melakukan hal begini begitu, lompat-lompat mengikuti permintaan pasar lapangan kerja. Pikiranku terbuka setelah dapat kerja tahun berikutnya, ga boleh begini terus, kalau mau ahli di suatu bidang harus belajar dari dasar. Aku mau jadi programmer beneran,...

Tahun 2018 nemu bahasan di stack overflow, isinya bahasa sistem yang sedang populer. Namanya Rust, dulunya dikembangkan di Mozilla, tahun ini punya foundation sendiri. Aku ikut senang, dari awal belajar bahasa ini compile message nya selalu lebih manusiawi daripada build aplikasi C++ dan C di linux atau windows. Yah, meskipun sebatas build aplikasi, tapi pengalaman itu cukup menyenangkan buatku. Sekarang sedikit paham gimana compiled language ditulis, ini catatan belajarku.

// Rust is an expression-based language
// The beginning of every Rust program is `main` function
fn main() {
    // Expression statement ending with exclamation mark
    // eg: (println!) which is a macro instead of a normal function
    // its argument is a statically allocated string
    // end with semicolon `;` indicates that this expression is over,
    // and the next one is ready to begin.
    println!("print the number!");
    // call normal function
    print_number(7);
    multiply_number(7);
    // function pointers
    let s: fn(i32, i32) -> i32 = sum;
    // variable binding with expression statement
    // that evaluate to signed integer
    let c: i32 = 7 * 7;
    // variable binding with an expression statement
    // note that `if` without else will return `()`
    // an empty tuple which is not what we want here
    let d: i32 = if c == 49 { 21 } else { 0 };
    // println! with string interpolation as argument
    println!("Sum of {} and {} is {}", c, d, s(c, d));
    print_range(7,10);
}

// function declaration
fn print_number(x: i32) {
    println!("This is your number {}", x);
}

// function declaration with variable binding inside
fn multiply_number(num: i32) {
    // let declaration
    let multiplier: i32 = 3;
    println!(
        "Your number is multiplied by {}, it is now {}",
        multiplier,
        num * multiplier
    );
    // Shadowing variable bindings enables us to rebind a name to a value of a different type
    // here we try to bind it to the argument of this function which is in the same scope
    // and the same type that will override the previous binding.
    let multiplier = num;
    // type inferred ^^^ but we must add type annotation on argument
    println!(
        "Then your number is multiplied by {}, it is now {}",
        multiplier,
        num * multiplier
    );
}

// function declaration with two arguments
fn sum(a: i32, b: i32) -> i32 {
    // Expressions statement return a value
    // or evaluates a value
    // The default value of an assignment is an empty tuple `()`
    // The assigned value can have only one owner
    // Last line of function always return an expression
    // This function intended to return `i32` not `()`
    // That's why no semicolon here
    a + b
}

fn print_range(e: i32, f: i32) -> () {
    // loop without labels and include the end of the range
    for i in e..=f {
        println!("Print number {} from range {} to {}!", i, e, f)
    }
}

Aku belajar SQL dan Rust niatnya ganti profesi, tapi kebanyakan tech-stack di sini masih anggap Rust bahasa exotic. Akhirnya setelah ngobrol lebih lanjut (dengan banyak orang dari berbagai sudut pandang) kerjaan selanjutnya lebih baik berkaitan dengan Desain. Mereka (yang aku ajak bicara) kenalan dari hal ihwal Desain, sedikit banyak tahu dunia Desain Visual tidak surut pangsa di pasar tenaga kerja, apalagi digitasi usaha semakin meningkat. Jadilah aku kembali ke bidang UI Engineering.

Bahasa desain cukup sulit, lho. Harus bener-bener pakai perasaan dan menekuni hal seperti ini butuh banyak waktu. Tapi jangan menyerah karena keadaan, jangan menyalahkan keadaan yang ga bisa mengikuti keinginanmu. Belajar lagi dari dasar, dari baca buku desain dan coba-coba layout baru. Aku tetap belajar apa yang kuinginkan di akhir minggu: System language. Don't say it's too late to reach what you dream of. Keep the spirit up, may the force be with you. Check out my latest project about rust here.

Agustus 01, 2021