The Nelua Programming Language

by nonbirithm • 5 years ago

242 118 5 years ago

soapdog• 5 years ago

Looks really cool. I wonder how it compares to teal

edubart10• 5 years ago

Teal add type annotations and type checking to Lua, and transpiles to Lua, while Nelua is a new systems programming language with optional type annotations and compiles to C.

@ubertaco also made a good comparison in his comment with Teal.

Zababa2• 5 years ago

The website to present it is beautiful and has all the necessary info, it's great. I also really like the name and logo.

strappedup• 5 years ago

It looks like every other Bootstrap site

lonk2• 5 years ago

At least better than brutal design

Zababa2• 5 years ago

I think good design/UX is more important than originality, so I have no issues with this.

nixpulvis2• 5 years ago

Documentation needs a better way to navigate by module and ident.

Svoka• 5 years ago

Interesting. If you want to write whole application in Lua-like language, this looks very nice. However one would need some framework to work with it to make, say a simple game.

nice if you are brave enough to use language which wasn't released yet and installs from `master`.

andrewmcwatters6• 5 years ago

God, does no one have respect for things in development anymore? This place shits on anything that doesn’t have documentation and an ecosystem with the equivalent of 10 years of free labor out of the gate and it pisses me off.

It’s a total turn off to share something with a development community made up of mostly people who don’t actually make things themselves or people who think they know better than people with actual experience in a given discipline.

It’s comments like this and the one below calling languages shit that makes this site a shithole to read sometimes.

ysleepy• 5 years ago

Uses 0-based indexing, if you were wondering like me.

7thaccount• 5 years ago

I'll never understand why this is such a big item of importance for developers :). Both 0 & 1 are pretty natural in my eyes.

rxhernandez• 5 years ago

It can definitely create problems when translating an algorithm from one to the other. I know it was a frustration when I translated algorithms from Matlab to C++.

lonk2• 5 years ago

Because 0 is first natural number and 1 is second :P

jimsimmons• 5 years ago

Off by one errors are one of the most common type of errors. So it's a real gotcha for most programmers

IshKebab4• 5 years ago

I guess it's because there isn't a huge difference but 0 definitely is slightly more elegant than 1. And when you're used to programming with the elegant system it's really jarring to switch to an unusual and slightly worse system.

0-_-02• 5 years ago

Because modulo arithmetic needs to include 0, so if you do modulo arithmetic on indices 0 based indexing is better.

moomin• 5 years ago

Let's see if Dijkstra can explain it. :p

https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E...

epage• 5 years ago

When you casually program in a language, being consistent with what people are familiar with is important to avoid introducing subtle bugs.

A lot of times, languages like Lua get introduced by enthusiasts in a way that others have to touch when things break but not enough to master. Think of shops that have those one off Perl scripts and the challenge with touching them.

andre-la• 5 years ago

Is 0-based like C, but on libraries that reimplements the Lua libraries, it's 1-based as Lua, because the language aims Lua compatibility.

Due to this, the string and "sequence" libraries (which works as a Lua-like vector), and the table library in the future, are 1-based.

duped2• 5 years ago

Something I'd like to see more of are GC and memory allocation guarantees, not just an option to disable it.

Most of the time GC is fine as long as it's low enough latency. Where it matters you don't really want any memory management - which isn't useful, since the memory needs to me managed somewhere in the code. For that reason the pattern isn't to switch to a non-GC'd language because it doesn't have GC but because you can guarantee all the memory is allocated up front and that no freeing or allocation happens in the tight loops.

That's not actually sufficient though. Even in production code bases accidental allocation can slip through. What you'd really like to see is a `no-alloc:` block which forbids operations that may allocate or free memory - GC'd or otherwise - and force the programmer to allocate before entering the block and free outside it.

stephen825• 5 years ago

You are free to manage memory yourself, if that is what you mean [1].

[1] https://nelua.io/overview/#memory-management

duped2• 5 years ago

That's not really what I meant. The example is showing the problem, the transition to manual memory management just makes it a bit easier to write a program without memory operations in critical sections.

What I'm talking about is a hypothetical language that makes memory operations in critical sections forbidden and considered a compilation error.

jasperry• 5 years ago

I've thought about something like this...that if a compiler could tell that code uses only stack-based allocation, it could turn off GC. Of course, that's very limiting, which is why we need more complicated things like Rust's type system to avoid GC.

didibus• 5 years ago

Java does that, both the HotSpot JIT and the AOT compiler (Substrate VM) I believe will do it. Now it can't always tell that data is local to the stack, but when it can, it won't allocate it on the Heap and will automatically switch to stack allocation (and no GC for it).

mrec• 5 years ago

It's not production-ready and isn't a GC'd language, but Zig's approach might be to your taste:

Zig programmers must manage their own memory, and must handle memory allocation failure.
This is true of the Zig Standard Library as well. Any functions that need to allocate memory accept an allocator parameter. As a result, the Zig Standard Library can be used even for the freestanding target.

https://ziglang.org/learn/overview/#manual-memory-management

elcritch2• 5 years ago

Nim's new garbage collector was designed with embedded systems in mind [1]. It uses non-atomic/non-locking reference counting combined with C++11 move semantics. The usage of move semantics enables both performance increases and a method to ensure memory is only "owned" by one thread (which enables non-atomic reference counting). Theres optional cycle collection support but I prefer to keep embedded code acyclical.

On your second point you can use Nim's effect system to ensure no allocations occur in a given function or its callees. Currently no one has done this, and might be tricky with the reference counting, but not too difficult either.

I used Nim with ARC for a latency sensitive embedded project. To avoid allocation on the tight reading loop I pre-allocated the values needed, or made them global variables. A few extra integer ops didn't matter, but allocation is sloooow. However, I'd eventually like to add allocation tracking to the effect system. Rather, make the existing effects more granular for this purpose.

1: https://nim-lang.org/blog/2020/10/15/introduction-to-arc-orc...

irq-1• 5 years ago

FYI there's also this newer document on memory management options: https://nim-lang.org/docs/gc.html

pshirshov5• 5 years ago

Cool. I didn't find in the docs how do I make higher-kinded types and typeclasses there?.. Could you give me a hint?

nixpulvis2• 5 years ago

This language has what looks like a potentially interesting macro system.

pshirshov5• 5 years ago

Good macro system is a must, indeed, that's very nice. Though just macro system is not enough.

In order to be useful a language should support a combo of HKTs, typeclasses (better implemented with implicits) _and_ macros with implicit materialization. Scala has that (and I'm using Scala) but it has some quirks and problems and I would be really happy to see something with these features but with fast compiler and separated from JVM.

edubart10• 5 years ago

how do I make higher-kinded types

In Nelua you can create new specialized types using compile time parameters, they are called "generics", you can use this for example to create a specialized vector type.

and typeclasses there?

Yes, but with some metaprogramming. In Nelua you can create a "concept", that is just a compile time function called to check whether a type matches the concept.

pshirshov5• 5 years ago

Is there a monoid example implemented in Nelua?

6d654• 5 years ago

I will definitely give it a try.

Even after many years of not using terralang I still cannot forget what a good of an idea it is.

Nelua seems like a more pragmatic implementation of similar ideas, but generates C code instead of embedding the llvm. And doesn't generate code at runtime. But still, things like ecotypes should be possible.

It will be interesting to play with the compile time lua scripting. Also, as mentioned in the other comments not sure about the GC. But there seems to be a manual memory management option.

But still, looks great, kudos to the author, keep up the great work.

PS: If I would implemented it, I would deviate a bit from Lua and replace local with let. It's highly subjective but I think it would make code "prettier"(whatever that means)

stephen825• 5 years ago

PS: If I would implemented it, I would deviate a bit from Lua and replace local with let. It's highly subjective but I think it would make code "prettier"(whatever that means)

The idea behind it is to have the lowest syntax barrier possible for Lua developers so they can migrate from Lua to Nelua without a sweat.

mst2• 5 years ago

Could you macro up an alias if you wanted to?

6d654• 5 years ago

Yep, it makes sense.

With the popularity of Roblox with the young people, and it using Lua for scripting, Lua can see a renaissance of some sorts.

scythe• 5 years ago

As long as we're bikeshedding, I've often thought that Lua should warm up to using `my` as a keyword in place of `local`. `let` doesn't convey that it's a scope keyword (LISP heritage notwithstanding), while `local` is long and `loc` is an eyesore.

6d654• 5 years ago

Eyesore is a precise word for the local keyword, from what I see the variable names in scripts are usually short, and the local keyword seems to draw more attention than the variable names themselves.

Of course this can be alleviated with syntax highlighting that would slightly mute the local keyword. And, people using Lua they day probably learn to ignore the keyword automatically.

6d654• 5 years ago

By ecotypes i meant exotypes(see https://cs.stanford.edu/~zdevito/pldi083-devito.pdf)

gautamcgoel• 5 years ago

This looks really fucking cool. I've long said that Lua is a neat language, but hobbled by a few warts/footguns. I think this project corrects many of those issues. Does this project provide a package manager with automated dependency resolution? That was an issue in Lua, IIRC.

stephen825• 5 years ago

About package manager, I don't think it has one yet (at least officially that I know of), but feel free to join discord [1] and ask the core developers about it.

[1] https://discord.gg/7aaGeG7

ubertaco• 5 years ago

There is no interpreter or VM, all of the code is converted directly into native machine code. This means you can expect better efficiency than Lua. However, this also means that Nelua cannot load code generated at runtime. The user is encouraged to generate code at compile-time using the preprocessor.

Sounds like this is less like Typescript (take the "base" language, add typechecking, and then "transpile" back into the base language) and more like Crystal (take the "base" language, and create a separate language that's similar to it but with static types and AOT compilation)

If you're looking for something more in the Typescript "transpiler" vein, there's Teal (https://github.com/teal-language/tl), written by the guy who created LuaRocks (and htop, interestingly). It still seems a little "early" in its life; it supports most everything you'd need, including some support for Typescript-style "type declaration files" for third-party libs, but it lacks the nice distribution mechanism Typescript grew over time for shipping/installing those declaration files (right now just have to "vendor" them yourself).

armchairhacker• 5 years ago

There’s also https://typescripttolua.github.io where you literally write TypeScript and it transpiles to Lua

bsaul• 5 years ago

Is there a way when using those kinds of new languages in a given platform (let's say iOS) to use a modern set of libraries to perform common tasks ( such as http networking, json parsing, websockets, basic multimedia features, etc) ?

Or would i be doomed to rebuild it myself from scraps and random C libs i'd have to gather myself ?

stephen825• 5 years ago

Well, Eduardo has also created this https://github.com/edubart/nelua-decl

Plus, whatever C library you may have used thus far, you can use it with Nelua as well without a fuss [1].

https://nelua.io/overview/#c-interoperability

abraxas• 5 years ago

This would be an amazing language to use with one of those SBC boards like Arduino or STM32.

edubart10• 5 years ago

Actually Nelua have been tested to work with Arduino, AVR, RISC-V and some other embedded devices. You can make some free standing code with the language if you follow some rules (avoid APIs that uses lib C and use a custom allocator).

andrewmcwatters6• 5 years ago

Seems nice. I don't agree with all of it's deviations from Lua, which unfortunately breaks portability, but I get it.

I wish C was scriptable, versus Lua being compliable, but this is really cool.

stefanos82• 5 years ago

Well, you can still use Lua 5.4 from inside Nelua since it's integrated as part of the backend mechanism for the metaprogramming and not only, therefore I don't think it breaks portability...unless I did not fully understand you correctly.

Can you please clarify a bit more your concern about it?

andrewmcwatters6• 5 years ago

It seems like global is a requirement for newindexing on _G (or if _G is even a thing in Nelua) from the documentation unless I'm reading it incorrectly.

newobj• 5 years ago

Well, for starters, the arrays are 0-based, so ...

edubart10• 5 years ago

I wish C was scriptable

C kinda can be used as scripting language with MIR project https://github.com/vnmakarov/mir

It released version 0.1 just a few days ago, and I've successfully used it as an alternative and fast C compiler with Nelua.

haolez• 5 years ago

Looks similar to Terra: https://terralang.org/

cies• 5 years ago

It advertises as "Lua flavour".

I found Lua a rather quirky language, bit like JS or PHP. Non of these have to my taste (since we're talking about flavour) a very nice syntax, nor do they to me demonstrate clear vision in their design. To me Lua flavour tastes like shit.

diego_moita• 5 years ago

To each it's own.

E.g: I felt the same "taste" about your comment. It doesn't add anything objective to the discussion. And it sounds a lot like what my 4 year old son says about brussel sprouts.

pull_my_finger7• 5 years ago

Lua certainly has quirks (as all languages do), but I've not heard people complaining about it lacking vision or consistency. In fact, you'll hear a lot of people mention Lua's very _deliberate_ design choices. Changes happen slowly, and it's not afraid to break backwards compatibility for the betterment of the language. That's in stark contrast to JS and PHP which add whatever feature is popular at the time and can't purge or change APIs for fear of "break the web".

forgotpwd16• 5 years ago

Seems to have some overlap (natively compiled Lua with optional manual memory management) with Terra (https://terralang.org/).

junon• 5 years ago

I'm technically a maintainer of Terra, and yes there's some overlap but still very different approaches.

Nelua looks really really cool. I'm going to have to give it a try tomorrow.

edubart10• 5 years ago

Terra was an inspiration to create Nelua in its metaprogramming aspects. Terra's famous Brainfuck example (on the front page of Terra) is available in Nelua's examples folder for comparison of meta programming.

pie_flavor• 5 years ago

Major negatives:

- Destructors are avoided for reasons, but then a full GC is wedged in. Unless you enable a particular flag, then you have to do all memory management manually, making code non-portable. Why on earth wouldn't you just use reference counting with destructors? Unless I'm missing something, that's better in every case.

- Avoids LLVM because 'C code works everywhere', then doesn't support MSVC.

- 1-indexed in libraries copied from Lua, 0-indexed elsewhere. That's just about the only worse thing you could do than 1-indexing everywhere.

- Preprocessor model instead of the features being a more integrated component of the language. Zig has proved a function-based approach can work well and C's legacy has proved that preprocessors absolutely blow.

- Aforementioned preprocessor directives get seriously wedged. You need them for polymorphism, varargs, etc.

- No closures. This one seems the most baffling to me because Lua has the __call metamethod, which is exactly what you'd use for that, and they're 99% of the point of anonymous or inner functions.

edubart10• 5 years ago

Destructors are avoided

RAII in general is avoided, because supporting it gives many unwanted consequences, increasing the language complexity and simplicity going against the goals.

Unless you enable a particular flag, then you have to do all memory management manually, making code non-portable.

You can make portable code to work with or without the GC, the standard libraries do this. Of course you have more work to support both, but you usually don't need to, choose your memory model depending on your problem requirements (realtime, efficiency, etc) and stick with one.

Why on earth wouldn't you just use reference counting with destructors?

Reference counting is not always ideal because it has its overhead, and the language is not to be slower than C, relying on referencing counting would impact a lot. The user can still do manual reference counting if he needs to, like some do in C. Also referencing counting requires some form of RAII which is out of the goals as already explained.

Avoids LLVM because 'C code works everywhere', then doesn't support MSVC.

MSVC-Clang can be used, naive MSVC is just not really supported running directly from the Nelua compiler, but the user can grab the C file and compile himself in MSVC. Better support is not provided for MSVC just because of lack of time and interest. But Nelua supports many C compilers like GCC, TCC, Clang. Supporting more backends than just LLVM is still better than not officially supporting MSVC.

1-indexed in libraries copied from Lua, 0-indexed elsewhere.

1-indexing is used in just a few standard library functions for compatibility with Lua style APIs. On daily use this usually matters little, also you can either make your code 1-indexed in Lua style, or 0-indexed in systems programming style, it's up to your choice. The language is agnostic to 1/0-indexing, just some libraries providing Lua style APIs use it, you could completely ignore and not use them, you can not even use the standard libraries or bring your own (like in C).

Preprocessor model instead of the features being a more integrated component of the language. Aforementioned preprocessor directives get seriously wedged. You need them for polymorphism, varargs, etc.

The language specification and grammar can remain more minimal, by having a capable preprocessor, instead of having many syntax, semantics and rules. Also Nelua preprocessor is not really just a preprocessor, as it provides the context of the compiler itself while compiling, this gives the language some powerful capabilities that only meta-programming the language to understand better. Calling a preprocessor does not do it justice, but the name is used due the lack of a better name.

No closures. This one seems the most baffling to me because Lua has the __call metamethod, which is exactly what you'd use for that, and they're 99% of the point of anonymous or inner functions.

The language is under development, not officially released yet, and this feature is not available yet but on the roadmap. Nevertheless people can code fine without closures, many code in C without closures for example.

hyperhopper• 5 years ago

Having some very widely used things being 0 indexed, and others 1 indexed, kind of points to a problem in the language, regardless of if it's technically a language syntax issue:

At the end of the day you're still going to have a ton of time wasted by devs having to check, and there will be bugs eventually of things being not converted or double converted between the two index schemas

nextaccountic2• 5 years ago

Hello, are you the language author? I've a question, the page says

Safe
Nelua tries to be safe by default for the user by minimizing undefined behavior and doing both compile-time checks and runtime checks.

And

Optional GC
Nelua uses a garbage collector by default, but it is completely optional and can be replaced by manual memory management for predictable runtime performance and for use in real-time applications, such as game engines and operational systems.

But of course, if one prefers manual memory management, then the code will be unsafe, right? Because use-after-free might occur.

(More specifically, free() is always unsafe in every low level lang, unless you have some static checking like Rust's borrow checker or ZZ and ATS compile-time proofs, which I think nelua doesn't have.)

moonchild• 5 years ago

1-indexed in libraries copied from Lua, 0-indexed elsewhere. That's just about the only worse thing you could do than 1-indexing everywhere

I'll do you one worse: in APL, you can set the index origin to 1 or 0 at will using the special variable ⎕IO. APL also uses dynamic scoping, so if you're in the habit of passing functions around, zaniness will result. (Thankfully this is not common.)

There was even a practice at one point of writing code that would work correctly with any value of ⎕IO.

xiphias22• 5 years ago

Also GC by default and systems programming language just don't mix. Rust tried to have GC in it at the early stage of development, but the developers realized that it must be get rid of to make it compete with C/C++.

pull_my_finger7• 5 years ago

Also GC by default and systems programming...

GC is _not_ the default though. Not sure why you brought that up.

davidthewatson• 5 years ago

I'd suggest you submit a pull request, but then you'd get this response from the PR parser:

"Nelua is open source, but not very open to contributions in the form of pull requests, if you would like something fixed or implemented in the core language try first submitting a bug report or opening a discussion instead of doing a PR. The authors prefer it this way, so that the ideal solution is always provided, without unwanted consequences on the project, thus keeping the quality of the software."

See https://github.com/edubart/nelua-lang/blob/bb5e71784f4065d25...

xedrac• 5 years ago

While I don't begrudge anyone from creating a new language, I'm trying to figure out what this brings to the table that languages like Nim, Zig, Ecl, Crystal, V, Forth, Gambit, etc... lack. The only thing I can really find is "syntax". Lua isn't really my cup of tea, but to each their own. Regardless, looks like a fun project.

corysama• 5 years ago

"Telling a programmer there's already a library to do X is like telling a songwriter there's already a song about love." - Pete Cordell

dbtc• 5 years ago

Ah yes, the principle of DRYO

Definitely Rewrite Your Own.

And some quote from Feynman about not understanding until you do it yourself.

andrewmcwatters6• 5 years ago

It’s funny you mention this because none of those languages appeal to me. This one only sort of begins to catch my attention.

md224• 5 years ago

The "Concept" idea is very cool... seems like it would make it really easy to construct refinement types and build validation into the type system.

no_time• 5 years ago

Although copying Lua syntax and semantics with minor changes is a goal of Nelua, not all Lua features are implemented yet. Most of the dynamic parts, such as tables (...)

Ah I guessed so. The concept of lua tables probably doesn't map to efficient machine code. Real shame because that's what I consider the "killing feature" of Lua as a language.

pull_my_finger7• 5 years ago

Nelua will definitely have tables. They're just not implemented _yet_

slackstation• 5 years ago

It's the Ruby/Lua 'end' that kills me. Why type a word when a character will do. Yes, my IDE can do it but, it's clunky.

Reminds me of when I first started out and would put a comment on every closing bracket of the context of what started that bracket.

cardanome• 5 years ago

It is a matter of taste. You can get used to it.

Both Lua and Ruby are optimized for aesthetically pleasing syntax that is easy to parse for humans, even for people new to programming. I think "end" works better for that goal than curly braces which most people don't even know how to type and that are rarely used in English outside programming.

Personally I vastly prefer keywords to special characters. My brain has more trouble parsing symbols than words. I have real trouble reading mathematical notation but if I see an algorithm written out with words I am able to grok it quite easily. I think lot's of people are the other way round, not sure . Might be because I was a heavy reader in my youth.

That said I switch between C-like and Lua/Ruby style syntaxes back and forth all the time and it is really not an issue.

fithisux2• 5 years ago

How does it compare to

a. Ravi https://github.com/dibyendumajumdar/ravi b. Moonscript https://moonscript.org/ c. Luajit https://luajit.org/ d. Moonjit https://github.com/moonjit/moonjit e. Terra https://terralang.org/

What is the advantage? Can I use lua code verbatim?

pull_my_finger7• 5 years ago

Here's the author's thoughts on Nelua vs Terra[1].

[1] https://github.com/edubart/nelua-lang/discussions/51

fithisux2• 5 years ago

Thank you very much.

RattleyCooper• 5 years ago

Having to use an "end" keyword is enough to make me not want to use the language.

andrewmcwatters6• 5 years ago

This limits your discipline so much. Do you not use Shell because ifs close with fi?

Do you not use HTML because declarations end with the same identifier?

Would you not bother trying Python because it handles whitespace differently than most other programming languages?

The Nelua Programming Language

Related Stories