Skip Navigation
Programming Languages @programming.dev armchair_progamer @programming.dev

June 2023 monthly "What are you working on?" thread

As in /r/ProgrammingLanguages, we will have a thread every month where you can post PL-related projects you are working on. Unlike the main posts, this thread is much more lenient: you should post even if you only have minor updates or something tangentially related to programming languages.

How much progress have you made since last time? What new ideas have you stumbled upon, what old ideas have you abandoned? What new projects have you started? What are you working on?

Once again, feel free to share anything you've been working on, old or new, simple or complex, tiny or huge, whether you want to share and discuss it, or simply brag about it - or just about anything you feel like sharing!

The monthly thread is the place for you to engage /c/programming_languages on things that you might not have wanted to put up a post for - progress, ideas, maybe even a slick new chair you built in your garage. Share your projects and thoughts on others' ideas, and most importantly, have a great and productive month!

Also see: https://www.reddit.com/r/ProgrammingLanguages/comments/13x2iv3/june_2023_monthly_what_are_you_working_on_thread/

11

You're viewing a single thread.

11 comments

  • A language designed around the idea of data mutation. Like, just doing data mutation. No functions, no stack, just here's some data and here's how it changes. It's very similar to imperative languages as you might guess, but it basically removes functions from the main data path and simplifies everything which leads to some weird syntax and features.

    There are still functions in some ways via a trait system kind of like Rust (also where and polymorphism appears), but it's not quite the same.

    I don't really know exactly how to explain it beyond that, so here's a snippet:

    [Import]
std

[Data]
a :: Int = 4
b :: Int = 5
a_str :: &Char = []

[Mut]
std.out write "The sum of 4 and 6 is "
b += 1
a += b
a_str alloc_num_str a
std.out write a_str

    Not that += here is not equivalent to a = a + b, but rather += is the name of a Numeric trait procedure. Using words I might call it add. It's a add b or with C++-esque syntax it's like (&c)->add(b) or something.

    There is a File struct in the std module and a Write trait implemented for &Files that includes a write(&Char) procedure as well as an instance of an &File called "out." So to write a string of characters to stdout, you do std.out write <characters>

    So from this, I can say that procedures in traits in this language are like mini versions of the stuff under [Mut] that you can call with parameters. These procedures can also have embedded C code which is how you interact with external stuff and how the core and standard libraries are implemented.

    Trait and struct definitions go under [Type] and have their own syntax

    Forcing all logic to be an explicit mutation of a singular datum may end up being the worst way to program ever, but it's at least a different way

    • Update: I wrote up a quick manual for the language explaining concepts in more depth and reworking the syntax

      • Here's a couple example programs.

        hello_world.mjut

        # Print a simple hello world message
let msg :: &Char = "Hello, world!\n"
mutate:
- stdout write msg

        truth_machine.mjut

        # Truth machine - if you input a 1, it prints 1 forever
# But a 0, it prints 0 & quits
let inp :: Char = 0
mutate:
- stdin alloc_read_line # Read data into stdin :: &Char
- inp := stdin:0
- inp -= '0'
- if inp - goto quit;
- forever:
    + stdout write "1"
    + goto forever
- quit:
    + stdout write "0"

        I think I have it fleshed out enough to get a basic version working. I'll write up a lexer and parser tomorrow (it's after midnight, so actually today lol) probably

11 comments