Show HN: Alumina Programming Language

> I love the semicolon rule, I think that distinction is extremely important and too often gets muddled

Yes, the distinction is important. That's why it's extremely annoying that this distinction is almost invisible if you don't look very close on the code using magnifying glasses. Like I said: Marking such an important distinction through something almost invisible like a (missing) semicolon is pure craziness.

Usually nobody reads semicolons! They are usually just line noise coming form a time as parsing code was actually still some kind of science and people made syntax with the explicit intent to be easy readable by archaic computers (and not humans in the first place).

I think `return`s are superfluous but given the choice between some more line noise in the form of a `return` statement and this semicolon brain-fart I would clearly prefer the `return`…

> (though in Rust's case I think it's more accurate to say it distinguishes between "statements and expressions" than "procedures and functions")

Since when? Did I miss something? (This could be, I'm looking only occasionally into Rust).

AFAIK leaving out the semicolon is only an option on the last expression of a procedure, turning that "procedure" into a function.

Leaving out (the completely unnecessary!) semicolons elsewhere is a syntax error to my best knowledge.

  fn main() {
      let baz = if false {"bar"} else {"foo"}
      println!("Hello, {baz}!", baz = baz);
  }

The above code would not compile, afaik, because the semicolon is missing on the first line of the procedure.

The completely unnecessary semicolons are just one of the examples that make the Rust syntax heavyweight and needless noisy for no good reason. I don't get how a modern language can fall back to such antique syntax.

The very rare use-case where you really want to write some comprehensive one-liner could have been easy supported by optional semicolons. But in the general case one just doesn't need that line noise.

Rust is a great language, really! But they obviously didn't put any effort into the syntax. The result is that the language reads partly like C++, and I guess almost everybody could agree that C++ has one of the most terrible syntax out there.

Rust is "modern" language with a stone age look & feel. That's a big missed opportunity, imho.

> Perhaps I could invent a spoken language where disparaging remarks are possible but extremely lengthy, thereby discouraging negativity from people in bad moods.

I can see how you might think think my comment is passive aggressive, but it is not. Passive aggression is "the expression of anger, hostility, or resentment through indirect means, especially obstructive or uncooperative behavior: those who expected him to lambast his foes were always going to be disappointed; passive aggression is more his style." (Apple dictionary)

First, if you take my comment as a whole, you can see I was not indirect in my criticism of your comment. Second, I do not feel anger, hostility, or resentment about you or your comment.

Rather, I feel disappointment that this kind of thing happens so often. It is not just you (or any one person) that disparages creativity -- many people have done it, including myself.

The language design comment is sincere. It was a sort of thought experiment. I can also recognize that it is a pointed comment that led to some reflection (I hope), which is why it might have felt like an attack. Still, remember I criticized your behavior, not you.

The comment had the additional purpose of highlighting that language design has broad applicability, and perhaps might reduce some kinds of unwelcome behavior, whether it be bad-mood inspired negativity or error-prone programming abstractions. Rust and Alumina aim to have more expressive types than C, for example. Human language shapes culture and thought -- at least according to many linguists.

There's `contextlib.closing` for objects that do not support the context manager protocol and they should be closed.

And then one can simulate defer in the spirit of the `atexit` module with a single context manager (say `finalizer`), defined only once, which could be used as:

    with finalizer() as defer:
        ...
        req = requests.get('https://w3.org/')
        defer(req.close)  # just like contextlib.closing
        ...
        a_dict['key'] = value
        defer(a_dict.__delitem__, 'key')
        ...
        defer(print, "all defers ran", file=sys.stderr)
        ...

The `__call__` of finalizer adds callables with their *args and **kwargs to a fifo or a stack, and its `__exit__` will call them in sequence.

I'm sure you're right. Rust is a popular language in Haskell user surveys, as it's not such a stretch coming from Haskell.

The majority of the lines I've ever written were in C. When I look at Rust, all I see is `{};`