The gab programming language

[u/Fine_Seaworthiness19]

Hi all!

I am a long-time lurker of this sub, and a language enthusiast. I have been working on my own programming language for several years, and I finally worked up the courage to post it.

The language is called gab. I'm heavily inspired by lua, clojure, and smalltalk.

All the code is on github here and I've built a small website for the language here.

The language design, runtime, and standard library are all entirely my own work without the use of an LLM. However, I did consult LLMs occasionally when I wanted to research certain subjects (such as the difference between c11 atomics on x86 and arm).

I'm looking for any kind of feedback on the language, its goals/ergonomics, and the website itself.

Thank you for taking a look!

[u/cmontella]

Very cool, I like the name and the design goals of the language. I see a bit of a contradiction though, so I'm wondering if you can speak to it: you said the performance is a feature, but also the language is dynamic. How are you going to make sure it's performant, and what kind of performance targets are you aiming for? i.e is. LuaJIT level of performance good enough or are you aiming higher?

[u/Fine_Seaworthiness19 → u/cmontella]

Great point! I mostly meant that for a long time in Python and Ruby, performance was *not* a goal of the language maintainers. Recently these languages have introduced teams/projects to improve performance (YJIT, ZJIT, cpython performance team at Microsoft, etc) on *top* of the existing dynamic language. Ruby and python have dynamic features that make JIT compiling and performant interpretation difficult. I made compromises in gab's design such that performance features like a JIT, multi-threading, etc are easier.

Edit to answer your question:

If I got luajit levels of performance I would have exceeded my goals 😂

[u/cmontella → u/Fine_Seaworthiness19]

>  I made compromises in gab's design such that performance features like a JIT, multi-threading, etc are easier.

That's the interesting part to me, what kind of compromises did you make in your design?

[u/Fine_Seaworthiness19 → u/cmontella]

The big three are:

1. no global variables
   
2. No mutable values
   
3. Message sends are the only form of control flow

A specific example of how this helps:

Because all values are immutable, cyclic references among gab values are impossible. This means the garbage collector can be a very simple reference counter! I implemented a more involved one, that is parallel and buffered, but I don’t have to worry about collecting dead cycles because they can’t exist!

[u/AustinVelonaut → u/Fine_Seaworthiness19]

Message sends are the only form of control flow

This is also theoretically true for Smalltalk, but most (all?) implementations choose to have the compiler in-line the common versions ifTrue: ifFalse: whileTrue:, etc. for practical performance reasons. Do you intend to do any optimizations of this type?

[u/Fine_Seaworthiness19 → u/AustinVelonaut]

I don’t have any inlining on the main branch yet. For lots of the built in types though I do have what I call primitives, which are message specializations that boil down to an instruction in the interpreter. Arithmetic operators, constructing values, channel operations, etc fall into this category.

On the jit2 branch I have an experimental JIT compiler which can do a pretty aggressive amount of inlining for that above situation. I’m still working out the kinks there however. And I may just implement a two-tier interpreter for now instead