Beeflang - open source performance-oriented compiled programming language

[Basile B.]

On Thursday, 9 January 2020 at 12:14:53 UTC, Gregor Mückl wrote:
> On Thursday, 9 January 2020 at 11:59:42 UTC, IGotD- wrote:
>> ... then the weird, it has a PREPROCESSOR that is even less 
>> capable than C. That's a very weird design decision.
>
> There's quite a bit of weirdness in Beef that has been copied 
> over from C#. The preprocessor is one example. It is pretty 
> much as capable as the one in C#. There it exists mostly to 
> enable conditional compilation.
>
> One other feature that seems to be inspired a bit by D is how 
> the scope keyword forces objects to be allocated on stacks. It 
> can also limit their lifetime to named blocks instead of the 
> entire function.

Also `defer { }` is like `scope (exit) { }`.
But I doubt the author is inspired by D **at all**.

   1. the pre-processor. no trace of any affiliation to D there 
(`version()`, `static if`
     etc.)
   2. attributes. no trace of any affiliation to D there either (@ 
+ introspection using
      __traits)
   3. syntax for template declaration. It does not even propose to 
fix the big C++ error. D
      fixes it at least
   4. `public` `public` `public` `public` `public` like in JAVA. 
Any influence of D here
     would have be to follow the principle of least astonishment.

Now there are things I didn't like, i.e 'personally'.

   1. sparse documentation. no global EBNF, no doc section for the 
declaration.
   2. the project source tree. hard to find the compiler. it's 
hidden in IDEHelper ?
   3. no linux binaries provided. Because the doc doesn't specify 
very well the things so I
      wanted to quick test if out of order declarations are 
supported, mutually dependent
      namespaces, aliases, etc. because this is something that 
tells much if a language is
      powerful or not.
   4. A conservative (CastTo)exp. I think that casts are important 
enough to make them well
      distinctguishable  like D `cast`.
   5. `repeat {} while ()` and `do {}` lacks of orthogonality. `do 
{} while (false);` could
      have been used instead, saving `repeat`. This new statement 
a very few value added
      but I understand that it's tempting to invent small things 
like that when creating a
      language.

A few good points however

   1. `??` and `?.` operators. D failed to get those.
   2. sane `switch` with implicit `break` and explicit 
`fallthrough`.