So với các ngôn ngữ khác

Rust, C và Go là những ngôn ngữ trưởng thành, dùng trong sản phẩm thật, còn Kon chưa phát hành. Trang này cho thấy khác biệt về thiết kế, và lúc này nên dùng ngôn ngữ nào cho việc nào.

Cùng một chương trình

Một hàm sửa list, một hàm đọc list. Cả bốn đều in ra 66.

Kon

func addBonus(scores: edit List<i32>, bonus: i32) {
    var at: u64 = 0
    while at < scores.length {
        scores[at] += bonus
        at += 1
    }
}

func total(scores: view List<i32>): i32 {
    var sum: i32 = 0
    var at: u64 = 0
    while at < scores.length {
        sum += scores[at]
        at += 1
    }
    return sum
}

func main(): i32 {
    var scores: List<i32> = list[10, 20, 30]
    addBonus(edit scores, 2)
    print(total(scores))
    return 0
}

Rust

fn add_bonus(scores: &mut Vec<i32>, bonus: i32) {
    for score in scores.iter_mut() {
        *score += bonus;
    }
}

fn total(scores: &[i32]) -> i32 {
    scores.iter().sum()
}

fn main() {
    let mut scores = vec![10, 20, 30];
    add_bonus(&mut scores, 2);
    println!("{}", total(&scores));
}

C

#include <stdio.h>

void add_bonus(int *scores, size_t count, int bonus) {
    for (size_t at = 0; at < count; at++) {
        scores[at] += bonus;
    }
}

int total(const int *scores, size_t count) {
    int sum = 0;
    for (size_t at = 0; at < count; at++) {
        sum += scores[at];
    }
    return sum;
}

int main(void) {
    int scores[] = {10, 20, 30};
    add_bonus(scores, 3, 2);
    printf("%d\n", total(scores, 3));
    return 0;
}

Go

package main

import "fmt"

func addBonus(scores []int, bonus int) {
	for at := range scores {
		scores[at] += bonus
	}
}

func total(scores []int) int {
	sum := 0
	for _, score := range scores {
		sum += score
	}
	return sum
}

func main() {
	scores := []int{10, 20, 30}
	addBonus(scores, 2)
	fmt.Println(total(scores))
}

Bản Kon, Rust và C được biên dịch và chạy để kiểm tra trang này. Máy kiểm tra không cài Go, nên bản Go chưa được biên dịch ở đây.

Kon chưa có iterator kèm closure nên vòng lặp dài hơn Rust và Go. Đổi lại, edit scores ở lời gọi cho thấy list sẽ bị sửa, còn lời gọi trong Go trông như nhau dù có sửa hay không.

Đặt cạnh nhau

Tốc độ và kích thước đã được đo so với C và Rust ở trang Hiệu năng. Go chưa được đo.

So với Rust

Rust gần nhất, và ownership của Kon đi theo cùng ý tưởng. Mục tiêu của Kon là đạt độ an toàn tương tự mà không cần chú thích lifetime, chỉ dùng các từ đơn giản ở lời gọi. Sự đơn giản đó còn phải chứng minh: mô hình của Rust đã có nhiều năm dùng thực tế và nghiên cứu chính thức, còn Kon thì chưa. Rust hiện cũng làm được nhiều hơn hẳn.

So với C

Kon hướng tới tốc độ và file nhỏ như C, nhưng bắt lỗi bộ nhớ thay vì phó mặc. C chạy gần như ở mọi nơi và mọi ngôn ngữ đều nói chuyện được với nó, điều Kon chưa thể sánh. Kon gọi được C, nhưng việc truyền con trỏ qua ranh giới đó chưa được xác nhận.

So với Go

Go cũng hướng tới dễ đọc, và an toàn nhờ garbage collector, đổi lại có độ trễ và tốn bộ nhớ nhưng rất dễ dùng. Kon không có garbage collector, nên bạn phải nghĩ về ownership để đổi lấy thời gian chạy ổn định hơn. Với dịch vụ mạng, Go là lựa chọn thực tế: Kon có socket và server một luồng, nhưng chưa có thread, HTTP hay TLS.

Khi nào chọn Kon

Lúc này, hãy chọn Kon để thử ngôn ngữ, theo dõi tiến độ, hoặc viết công cụ và game nhỏ trên Windows cho vui.

Chưa nên chọn Kon cho việc gì cần chạy ổn định: Kon chưa có bản ổn định và code vẫn có thể thay đổi. Điều này cũng đúng với việc cần thread, HTTP hay TLS, hệ điều hành khác hoặc nhiều thư viện.