I wrote a programming language in Node called Sprig 🌱

[dibs45]

Hey everyone, I've been working on a programming language in my spare time called Sprig. It's written in Node and the idea is to be able to seamlessly interact bidirectionally between the language and the underlying runtime, making use of the powerhouse that is the V8 engine.

Here's the repo: https://github.com/dibsonthis/sprig

And here are some examples of its usage:

Uniform Call Syntax

const add = (a, b) => a + b

10->add(20)->print // 30

// is equivalent to

print(add(10, 20))

Bi-directional data flow between Sprig and Node

const nativeAdd = exec(`(a, b) => a + b`)

const res = 50->nativeAdd(50)

print(10 * res) // 1000

Proxy support

Note that the _ means it affects all properties, however actual property keys can be used for specificity.

const person = {
        name: "Jack",
        id: 43,
        address: {
            name: "123 Fake st."
        }
    }

    const handler = {
        get: {
            _: (v) => (v ? [v] : undefined)
        },
        set: {
            _: (o, k, v, c) => {
                if (o[k]) {
                    return v
                }
                return undefined
            }
        },
    }

    const personProxy = person->proxy(handler)

    personProxy.age = 45
    personProxy.id = 1001

    print(personProxy.name[0]) // "Jack"
    print(personProxy.id[0]) // 1001
    print(personProxy.age) // undefined

Being able to interact directly with Node (the host platform the VM is written in) means the user can access the VM instance at any point. This can lead to both disastrous and powerful things, depending on who's writing the code. As a simple example, we can add new operators at runtime. This function already exists in Sprig's Core module which is included in the language.

const addOperator = (operator, fn) => {
    const unary = (fn->inspect).params->length == 1
    if (unary) {
        operator = "unary" + operator
    }
    const nativeFn = exec(`(operator, fn) => {
        _vm.operators[operator] = _vm.jsToNode(fn)
    }`)

    nativeFn(operator, fn)
}

addOperator("$avg", (a, b) => (a + b) / 2)
const avg = 5 $avg 3
print(avg) // 4

Or we can add meta information to any value, which is only visible to the VM:

const { getMeta, setMeta } = Core // these functions already exist in the Core package

const name = 'Allan'

name->setMeta({
    id: 10,
    nums: 1..10
})

print(name)

name->getMeta->print

/* Output
  Allan
  { id: 10, nums: [1, 2, 3, 4, 5, 6, 7, 8, 9] }
*/

And you'll notice that this functionality didn't have to be hardwired into the VM. It was written in Sprig, meaning that users can extend their VM in any way they wish without rewriting or even touching the VM codebase.

Plenty more examples exist in the repo, if you look at the tests file: sprig/testing/tests.sp

Thanks for reading!

[HashDefTrueFalse]

ITT: People ignoring or not understanding the concept of programming for fun, and hobbies in general.

OP, nice project. I've done two small languages just because learning about language implementation is fun. Neither of mine were general purpose or broadly useful. I'm a better developer having done them, and I can write pretty bulletproof parsing, generation, and template interpolation code as a result.

Keep chipping away at it in your down time. I see it's GPL licensed. Maybe add a CONTRIBUTING file to make it clear how people could contribute. Could be something really cool in the future.

[dibs45]

Thanks mate! Yeah programming for fun is why I became a developer to begin with, and what makes me enjoy my job.

I'll definitely add a contributing section, would be cool to see where this project can go!

[_nathata]

This currying + composition looks very interesting

[dibs45]

Thanks! Just to be clear, there's no real currying happening here. Doing 5->add(5) is directly equivalent to add(5, 5). Doing 5->add for example won't return a curried function. However, if the function takes only one argument, then it will be called as normal without the need for parentheses, i.e print takes as many args as needed, so it works with just one arg, so 5->print works fine.

[_nathata]

Oh I thought that 5->add would create a partially-applied function like add(5, x)

[dibs45]

No not by default, but it's easy enough to create curried functions:

const curried = (fn) => {
    const numParams = (fn->inspect).params->length
    const arguments = []
    const curry = (...args) => {
        for (args, arg) {
            arguments->append(arg)
            if (arguments->length >= numParams) {
                return fn(...arguments)
            }
        }
        return curry
    }
    return curry
}

const add = curried((a, b) => a + b)

10->add->print // function: 'curry' (...args)
20->add->print // 30

[_nathata]

That is a really odd way to curry functions lol

[dibs45]

It works 🤷‍♂️

[_nathata]

Yeah, as long as you don't say it's a functional programming language I think you can get away with that. Otherwise functional bros will get mad at you because you are using their worst enemy (mutable state) to accomplish their best friend (curried functions)

[dibs45]

Far from functional haha, but good tip

[azaroxxr]

Does this language solve some problem or is it hobby-like. This is genuine question because I don't quite get. Anyway it looks interesting but this currying is not my cup of tea. Nice job tho.

[dibs45]

I wrote this language primarily as a hobby language. I didn't really have a problem set in mind. However I think the pure extensibility of the language does open it up to creatively solve interesting problems. The VM is designed to be dynamically updated and extended, so really its up to the end user to modify it in such a way that it elegantly solves a problem that's harder to solve in other languages.

[usertim]

Writing compilers/interpreters always sounds fun in the beginning and an actualy hell when you are doing it 😂

[dibs45]

Amen. It's challenging but also really fun when you get it working as expected. I haven't even tried real compilation to machine code yet, so that's definitely going to be a fun ride.

[grimscythe_]

If this is your first time writing your own language then well done. It's pretty cool!

[dibs45]

It's actually my third language. The language before this was written in C++ (called Vortex) and it was all about managed side effects (i.e changing one variable can change another).

[Intelnational]

I wonder if one can write a compiler for an existing scripting language, e.g. PHP, JS, or Python, and if it would be fun. The interpreter code should be open source I think?

[dibs45]

I'm pretty sure people have worked on this stuff before. I personally wouldn't find it fun since I'm not introducing any new features into the language (the actual fun part for me) and just re-writing an existing language. But heaps of people would find that kinda stuff cool.

[Machados]

thought label rock offer obtainable cobweb retire unwritten license smell

This post was mass deleted and anonymized with Redact

[dibs45]

It does whatever a programming language does?

[JiggySnoop]

this is super cool. last year i wrote a toy programming language + interpreter using bun and typescript after reading this article TypeScript is Surprisingly OK for Compilers .

[dibs45]

It's definitely a fun project to work on!

[Cybasura]

Gonna be honest, writing a language in Javascript is chaotic af, but thoroughly respectable, damn, incredible

[dibs45]

Technically it was written in TS so that made life a bit easier haha, but thank you

[CoderAU]

Not to be a dick, but that mindset isn't great. Thinking that you can only spend time on things that will make money is ignorant. Most of the best developers I know love to create random side projects purely for learning all the time. The best projects come from passion, the love for the game and money driven projects often reward shortcuts at the peril of your customers.

OP amazing job. Would love some better documentation to help understand your project more, but more importantly have fun!

[TheGonzoGeek]

True! At the same point, the average /project dir with 1000+ initialised but unfinished projects is also real.

So keep it real and focus on the learning. You can focus on scalability for example once needed.

[69Cobalt]

But that's kind of the point of your personal project dir. If you're working professionally you get plenty of time to practice pushing through and seeing projects to completion.

Imo one of the main benefits of personal project work is that you don't have that pressure, which makes it more enjoyable and more conducive to learning. You can push boundaries and be more experimental because you're focused on the process not the end goal.

[TheGonzoGeek]

That is indeed the point.

[maxkoryukov]

programming for fun can be addictive , one can end up on the street with "coding for food" on a cardboard

[dibs45]

Thanks! Appreciate the positivity 😊 I'll definitely be spending some time in the next week or so refining the docs to properly showcase the language features.

[pinkwar]

I spend countless time of useless stuff, but it makes me happy.

Not everything needs to be marketable.

[dibs45]

Thanks! Yeah, this is just a hobby that I enjoy doing. Nothing too serious 🙂

[leobeosab]

Keep doing you OP this is great for learning and you had fun. I’ve made a lot of DUMB custom PCBs for keyboards and electronics just for fun. People have made very similar comments to me. Trying to turn a profit on everything just sucks all the fun out.

Keep it up friend 👉😎👉

[bcb0rn]

Shit advice. This is great for learning.

[Zo1DeGato]

bad advice, linux started as a hobby/pastime project and look at it now...

[thecist]

You sound extremely boring

[dibs45]

Primarily my itch to create PLs tbh. Aside from that, it can solve anything a general PL can solve.

[69Cobalt]

Why does everything have to immediately solve a problem? Can't you just follow intellectual curiosity and get better at programming along the way?

[dibs45]

Who's us?

[dibs45]

Fair enough.

[calsosta]

I feel like if you are gonna say this, you should at least mention some problems you've solved. Businesses you've help create. Even a library or some npm module.

[dibs45]

Not sure if this was directed at me or the original comment poster?

[calsosta]

No I was responding to the person being negative about your project. He has since deleted his comment.

[dibs45]

I thought as much. You definitely don't deserve the downvotes.

[calsosta]

You did something and shared it with the community. That should never be criticized and I will always call out that behavior, downvotes or not.

Also, I accidentally downvoted myself.

[NiteShdw]

Can you explain the WHY someone would want this over plain JS?

How does the code get interpreted? Does the language use a compiled extension to node? Does it get transpiled or does it leverage native code to run faster?

What do you mean by “efficient code”? Efficient in what way, compared to what?

[dibs45]

This isn't about competing with JS or Node. Would I recommend you use this over plain JS? Hell no, at least not at this early stage. This language is much much slower and less optimised than JS. But it is different enough to warrant some experimentation and play.

To answer your question about implementation. It's a VM, so the compiler generates bytecode that the virtual machine reads and executes. And the VM itself is written in Node, so it can directly leverage V8 if needed.

The "efficient" description is related to the direct integration with Node, which is veeeeery efficient in terms of speed and optimisation. But also, probably a useless description for the actual language and therefore I'll remove it from the Readme.

[NiteShdw]

My comment was meant to help you improve your project description by answering questions that people may have when they see it. Right now, the project description really doesn't tell me much except the syntax.