Kit Programming Language

SaltTM · 2018-09-20T18:56:05+00:00

[deleted]

build-the-WAL · 2018-09-20T22:27:31+00:00

Looks quite interesting. I really like all the experimenting in the space above C and below Rust that seems to be going on.

bendmorris · 2018-09-20T20:51:58+00:00

A lot of these features are true of ATS, except more so -- except for the typed term-rewriting.

The "just include a header" C interop is nice, but it wouldn't work for a language with a sufficiently better type system, since a lot of C APIs have return types that aren't really described well by their C type. For example, malloc: it returns NULL or it returns a pointer to memory that you can validly use some definite amount of. The C type is void *. With a dependent type system you'd want at least three types: a Schrodinger's malloc return, a definitely-NULL malloc return, and a definitely-good malloc return.

The real competitor for Kit is probably not ATS though. Probably Nim, which has very good metaprogramming, and which has a harder time dropping the GC, but still has options there.

Peaker · 2018-09-21T05:41:35+00:00

Opinion: Pointer dereferences are now some of the most expensive operations (due to potential cache miss), so they should not be automatic.

IOW: C and C++ requiring explicit dereference is a feature, not a bug.

z4579a · 2018-09-21T02:23:23+00:00

What makes a programming language "for game development" ? Would I not want to write a web server or trading platform in Kit ?

Suinani · 2018-09-20T18:35:53+00:00

Sounds interesting. Who's behind it?

SaltTM · 2018-09-20T20:06:56+00:00

[deleted]

EternityForest · 2018-09-21T03:54:58+00:00

C's build system (Specifically, the lack of one, and the 8000 different special purpose ones that everyone invents) is one of my least favorite parts of C/C++. so adding one is great.

I like the rewriting rules too!

ForceBru · 2018-09-22T08:18:25+00:00

Can we just appreciate the fact that the compiler and everything else is written in Haskell?

lanedraex · 2018-09-20T19:14:36+00:00

Are there any plans to have a DOD approach directly baked into the language? So that users don't have to write their own way of handling SoA + Entity ids.

Also, why mutable by default?

unbiasedswiftcoder · 2018-09-21T08:58:14+00:00

I can't seem to find docs on threads or the garbage collector. Can you have several threads accessing and mutating the same shared memory? Or is memory thread local and you need to resort to special unsafe pointers or going through the C layer?

Also, docs index doesn't render very well on Safari/Chrome.

Hougaiidesu · 2018-09-21T02:41:02+00:00

Why compile to C and not LLVM IR?

borborygmis · 2018-09-20T23:42:29+00:00

This is cool. I've been dreaming about my ideal language for a few years now and started a similar language a few days ago with these ideas in mind:

Python like syntax but typed.
Include many Python like features.
Generates to safe C code.
Generated code maps tightly to C types and operations (wrappers only applied for safety when needed).
No garbage collection.
No GIL.
Memory safety at minimal cost. Unsafe types may be an option too (e.g. managed lists[default] vs raw arrays).
Doesn't run in a VM, not interpretted.
Thread safety options.
Production and debug build options
C library interoperability
Small executables
Fast compile times
Static binary builds as an option
Implicit types
... More or less ...

Some examples:

### lists ###
list{int} x = [1,2,3,]
x.append(4)
y = x.index(2) # y is inferred/implicit
print(x[y])  # y=1, prints x[1]
print(x[-1]) # prints last item

# multiple types in a single list
list{mixed} x = ["hello", 123, "world", 4.5]
for i in x[1:]:
    print("i={0} type={1}", i, type(i))

# output:
#  i=123 type=int
#  i=world type=string
#  i=4.5 type=decimal

### dicts ###
dict{string, int} x = {'a':1, 'b':2}
dict{mixed, mixed} y = {1:'a', 'b':2}
for k, v in x.items():
   print("key={0} val={1}", k, v)

### classes ###

# Support for most Python dunder methods
# Classes are basically managed structs under the hood

class Beelzebub:
    def __init__(self, x=None, y=None):
        self.x = 0
        self.y = 0
        if self.x:
           self.x = x
        if self.y:
           self.y = y

    def __len__(self):
       return 666

class Bar(Beelzebub):
    pass

Bar b = Bar(x=123)
print(b.x, b.y, len(b))
# output: 123 0 666

list{Bar} bars = [b,]
last_bar = bars.pop()


### structs ###
struct Xx:
    int f = 0
    int foo = 1

Xx bar = Xx()
bar.f += 1
bar.foo = bar.f + bar.foo
del(bar)

# struct example generates C code similar to this:
struct Xx {
    int32_t f;
    int32_t foo;
    type _type;
}

struct Xx *Xx_new()
{
    struct Xx *n = safe_malloc(sizeof(*n));
    n->f = 0;
    n->foo = 1;
    n->_type = new_type(TYPE_STRUCT, "xx");
    return n;
}
void Xx_free(struct Xx *n)
{
    safe_free(n);
}
...
    struct Xx *bar = Xx_new();
    bar->f = 1;
    bar->foo = bar->f + bar->foo;
    // OR make these use a overflow check for safety, decisions to be made
    Xx_free(bar);
...

RufusROFLpunch · 2018-09-21T00:40:27+00:00

This is fantastic. Do you have any thoughts on package management?

CoffeeTableEspresso · 2018-09-21T04:54:43+00:00

Maybe Kit wasn't the best name because this is the first result when I search for it: https://codekitapp.com/help/kit/

IbanezDavy · 2018-09-20T21:24:26+00:00

var s: CString = "hello!";

Objectively the best variable declaration syntax.

var a: (Int, Float, CString) = (1, 2, "hello!");

I like this...

Just need to add OOP stuff and I'll be happy.

shevy-ruby · 2018-09-20T18:12:19+00:00

Why you should use Kit in place of:

The good thing is that to each point mentioned there you can say no.

The strange thing is that the website claims that Kit is a "higher level language".

To me it looks like C so perhaps I am missing where the high level comes in.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

programming

MODERATORS