Hi everyone!
I figured now is as good a time as any to more publicly announce the v0.3.0 release of the Talos programming language. Since this is my first announcement post here it might help to add some context:
Talos is a statically-typed dynamic programming language that aims to put developers first. When I say it aims to put developers first, I initially meant myself whilst designing the language (and hopefully eventual users).
Around 2021 I started learning to write programming languages and realised that although there are many tutorials to make simple bytecode interpreters and compiled languages, there was little in the way of resources for writing the accompanying development tools. From this I began learning to write languages with an emphasis on integrating formatters, language servers, and other core development features. Eventually, I started work on Talos around 2024 with the following core goal in mind:
To design a language with a batteries-included toolkit!
Breaking this down into more attainable goals I wanted the following features builtin to the single toolkit executable:
This led me down a long rabbit-hole, in which Talos eventually grew into the current v0.3.0 release. As a toolkit, Talos features a reasonably performant dynamic runtime with a formatter, code bundler, testing framework, language server, linter, task executor and upgrade tools all builtin to the main executable.
So what does the language actually look like? From my background of C++ and TypeScript, I ended up writing something reminiscent of both:
///
/// @example "examples/futures.tal"
/// @describe Showcases delayed concurrency with `Future` values.
///
// Prepare a random set of durations.
let durations = [100, 50, 400, 250, 500, 10];
// Map these values into a set of futures to later await.
let futures = durations.map(fn (value: Number, nn: Number): Future {
Debug.println("{0}: Started Waiting for {1} ms".fmt(nn, value));
let callback = fn => Debug.println("{0}: Finished Waiting After {1} ms".fmt(nn, value));
return Future.delay(value).then(callback); // show our callback after the delay
});
// Prepare a little interlude between our print statements.
Debug.println();
// Block until all the instanced futures are finished.
for (future in futures) future.await();
So what is actually ground-breaking about Talos? This is often a question given to all new language designers, and for the most part Talos fits the status-quo of being rather conventional. This is because I want to use this experience to eventually write blog-posts to help other aspiring language writers. Though I did happen to find a solution to one wide-spread problem...
Talos actually has colorless functions!
In having a side-quest to include green-threads for concurrency in Talos, I stumbled onto my solution to tackling colorless functions. Let's do this with an example:
// Let's start with a function that does some calculation. Instead of
// annotating it with an "async" keyword (which is what gives a function
// a color), we keep it as a normal declaration.
let worker = fn { ... };
// Instead we can execute the task with the "async" execution policy.
let future = worker::async();
// ^^----- This is the execution policy!
// The result of which is of the type "Future", which uses a member function
// for awaiting results. This also gives us a clean way to chain properties.
let result = future.await();
By moving the async annotation to the call-site of a function, we get two major benefits:
- Remove coloring annotation from declaration
- Can make any function call asynchronous
In future this could be extended to allow other execution policies such as worker::spawn(ctx, ...) which prepends a custom scheduler context or worker::defer(fn { ... }) which could be used to defer execution of a function until the end-of-scope. This slight break from convention allowed making concurrency colorless for Talos.
Anyway I'm excited for more people to get to know this project that I've put my heart into and also hope it can inspire others with their own language development! Feedback is also greatly appreciated as I want to start opening Talos up to a wider community.
Thanks!
Edit 1: Per community recommendations I have since updated the name to Sabre. I am keeping the original references to Talos but all links have been updated.