Show HN: Alumina Programming Language

Post by Art9681 » Sat, Sep 03, 2022, 7:38 PM UTC

aliqot wrote: post #18

Asraelite wrote: post #9

Earlier quoted context omitted.

That's a strange take. Do you mean that you would rather call external binaries directly, like Bash does, or that you would rather re-implement all functionality you need, however complex?

To me, there is value in the process and craft. It started as a one year challenge to use only stdlib in all projects, for work and personal code, and became a way of life. Though it may not work for everyone, or all languages, or all skillsets, it was a revealing experience. In retrospect, it made sense given that in my community we make our own furniture, instruments, tools, foods from whole items. Code seemed like…

Post by aliqot » Sat, Sep 03, 2022, 7:50 PM UTC

Art9681 wrote: post #31

aliqot wrote: post #18

Earlier quoted context omitted.

To me, there is value in the process and craft. It started as a one year challenge to use only stdlib in all projects, for work and personal code, and became a way of life. Though it may not work for everyone, or all languages, or all skillsets, it was a revealing experience. In retrospect, it made sense given that in my community we make our own furniture, instruments, tools, foods from whole items. Code seemed like…

I too suffer from obessively overcoming challenges. I will say this, in a snarky and friendly way. I hope you understand. If developing with high level abstractions wasn't challenging enough, your vision was too small. Surely you can think of a problem to solve that even Copilot would be of little use. Imagine what you could build if you got a little more help from third party libs and a little more ambition?

Post by tibordp » Sat, Sep 03, 2022, 8:08 PM UTC

noncoml wrote: post #34

tibordp wrote: post #21

Earlier quoted context omitted.

Scoped destruction is awesome in general, and I agree that it is superior to defer. I think one case where defer might be nicer is for things that are not strictly memory, e.g. inserting some element into a container and removing it after the function finishes (or setting a flag and restoring it). This can be done with a guard object in RAII languages, but it's a bit unintuitive. Defer makes it very clear what is goi…

> This can be done with a guard object in RAII languages, but it's a bit unintuitive Some syntactic sugar, like Python’s “with” should help with that, shouldn’t it?

    seen_names = {}

    class EnsureUnique:
        def __init__(self, name: str):
            self.name = name
        
        def __enter__(self):
            if self.name in seen_names:
                raise ValueError(f"Duplicate name: {self.name}")
            seen_names.add(self.name)

        def __exit__(self, exc_type, exc_value, traceback):
            seen_names.remove(self.name)


    def bar():
        with EnsureUnique("foo"):
            do_something()
            ...

    static seen_names: HashSet = HashSet::new();

    fn bar() {
        if !seen_names.insert("foo") {
            panic!("Duplicate name: foo")
        }
        defer seen_names.remove("foo");

        do_something();
    }

Post by xpe » Sat, Sep 03, 2022, 8:09 PM UTC

wtetzner wrote: post #32

pipeline_peak wrote: post #2

Quoted post unavailable.

What an odd comment when the post contains this: > It is mostly for fun and exercise in language design, I don't have any grand aspirations for it.

Post by xpe » Sat, Sep 03, 2022, 8:13 PM UTC

pipeline_peak wrote: post #2

Quoted post unavailable.