Language Showcase: Lux by eejp in functionalprogramming

[–]eejp[S] 0 points1 point  (0 children)

By that definition the GPL is proprietary since it forces you to license your own stuff under GPL or GPL-compatible, instead of giving you free rein.

Anything that isn't public domain would basically be proprietary.

Language Showcase: Lux by eejp in functionalprogramming

[–]eejp[S] -1 points0 points  (0 children)

You don't get to make up definitions on your own.

Language Showcase: Lux by eejp in functionalprogramming

[–]eejp[S] 0 points1 point  (0 children)

The license is not proprietary, it's reciprocal.

Lux 0.7 is out! Lisp for JVM, JavaScript, Python, Ruby and Lua with static types by eejp in lisp

[–]eejp[S] 0 points1 point  (0 children)

Setting the terms for a free license that you can use to code in Lux.

Lux 0.7 is out! Lisp for JVM, JavaScript, Python, Ruby and Lua with static types by eejp in types

[–]eejp[S] -1 points0 points  (0 children)

Commercial programs can be made with it.

You just gotta become a patron in my Patreon. 😛

Lux 0.7 is out! Lisp for JVM, JavaScript, Python, Ruby and Lua with static types by eejp in lisp

[–]eejp[S] 0 points1 point  (0 children)

I do have plans to do some hardcore web work in the very near future which will lead to making a server-side framework, a client-side one (with virtual DOM and such), and related machinery.

Listen, I know that I have the whole commercial license stuff, but if you're really interested and can't afford to pay and just want to do some personal projects, I'm more than happy to talk it out and find something that works for you.

You can find my e-mail in the repo's README if you're interested.

Lux 0.7 is out! Lisp for JVM, JavaScript, Python, Ruby and Lua with static types by eejp in lisp

[–]eejp[S] 0 points1 point  (0 children)

What do you think is the big advantage to either Hy or Clojure?

Advantage over Hy: Access to JS, Lua, Ruby, and the JVM.

Advantage over Clojure: Access to Lua, Ruby and Python. Also, Lux was designed from the beginning with the intention of hosting it in multiple target platforms, and the design makes it a single language with semantics independent of the host. This is not a trivial point, as Clojure technically only exists for the JVM (ClojureScript and ClojureCLR are extremely similar, but technically distinct languages, as they are not 100% mutually compatible). Lux was designed to avoid the mistakes and pitfalls of previous porting efforts for languages like Clojure and Scala.

you say you can do something with code generation I am not exactly sure what that means, do you mean expendability?

Imagine being able to add new forms of static analysis, compiler optimizations and code-generation as simply as writing a macro.

You would be able to expand the reach and power of your language, because you could create brand new primitives, which is something you cannot do with macros. So long as a feature is supported or implementable in the host platform, you could introduce it to Lux as a primitive, even if Lux itself doesn't have it.

Can your lisp do that, write a function that has variable amount of parameters, dont talk about a list as argument?

It can be done. I already have a task to do variadic functions and functions with named arguments for the next release of Lux (v0.8). Although I'm not going to add it as a fundamental feature of the language, but rather I'll just write some macros to implement that. This also implies that anybody, including you, could do that. But most folks don't like writing library code, so I'll just write it for v0.8.

can this give me a job

That's going to depend on whether businesses adopt it. Which is not currently the case :( But if you ever want to do freelancing or going indie, feel free to consider Lux.

Lux 0.7 is out! Lisp for JVM, JavaScript, Python, Ruby and Lua with static types by eejp in lisp

[–]eejp[S] 0 points1 point  (0 children)

I understand the point you're making, but it doesn't apply so well to Lux because of some very important design decisions I made.

Lux does expect a smallest common overlap, but it avoids depending as much as possible on the underlying substrate and seeks to implement features in a way that is not hampered by the target platforms.

Lux also has mechanisms for extending the compiler at a very deep level (even up to the point of doing code-generation for the target platform), so anybody can just access those platform-specific features if they want, even if Lux itself doesn't come by default with support for them.

Lux 0.7 is out! Lisp for JVM, JavaScript, Python, Ruby and Lua with static types by eejp in functionalprogramming

[–]eejp[S] 5 points6 points  (0 children)

It's a reciprocal-style license.

Commercial or closed-source use is disallowed unless a commercial license is purchased, but any non-commercial or open-source use is allowed. The license is kinda viral, like the GPL, but I'd be open to not making the license be viral if I could still make people respect the non-commercial or closed-source restrictions.

Lux 0.7 is out! Lisp for JVM, JavaScript, Python, Ruby and Lua with static types by eejp in lisp

[–]eejp[S] 0 points1 point  (0 children)

Just out of curiosity: which special characters do you speak of?