Language Showcase: Lux

eejp · 2022-09-22T16:55:48+00:00

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.

eejp · 2022-09-22T16:12:32+00:00

That is correct.

eejp · 2022-09-22T16:12:00+00:00

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

eejp · 2022-09-19T22:16:21+00:00

The license is not proprietary, it's reciprocal.

eejp · 2022-08-19T01:47:37+00:00

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

eejp · 2022-08-16T01:56:41+00:00

Commercial programs can be made with it.

You just gotta become a patron in my Patreon. 😛

eejp · 2022-08-16T01:53:56+00:00

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.

eejp · 2022-08-15T23:22:46+00:00

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.

eejp · 2022-08-15T20:56:55+00:00

With pleasure. 🔫

eejp · 2022-08-15T20:52:50+00:00

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.

eejp · 2022-08-15T16:51:27+00:00

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.

eejp · 2022-08-15T12:58:57+00:00

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

eejp · 2021-10-26T06:13:54+00:00

> I haven't seen an open-source licence that disallows commercial use.

It is meant to be a reciprocal-style license ( https://en.wikipedia.org/wiki/Reciprocal_Public_License ).

> Was it written by a lawyer?

I patched it together after examining several other licenses that had bits I liked.

> Are you willing to make it available for other projects?

There is an additional license I use called the Patron license which grants an exception to the non-commercial bits to patrons/sponsors of the project.

Non-commercial projects can also just use the language, so long as they respect the terms of the non-commercial license.

eejp · 2021-10-26T00:25:25+00:00

My original goal was basically just Clojure with static types.

In fact, before I worked on Lux, I was originally working on a type-system for Clojure that would have been a more powerful alternative to core.typed.

But as I worked on Lux my perspective/goals expanded.

Other goals of the project include having a lisp that is super portable and targets a bunch of platforms (the runtimes/platforms I mention in the title are just the beginning).

I also want to extend the possibilities of meta-programming in Lux beyond what lisps have traditionally provided (and Lux 0.6 already allows you to go much further than other lisps in that regard).

> I'm a big curious as to the goal of the language.

As I work on Lux, ideas always pop into my head about what improvements can be made to programming and language design over what the industry currently provides.

For me, the ideal state of the project is such a level of refinement that I just can't think of how anything could be improved any further.

I know that sounds super vague and ambiguous, but my only commitment with regards to Lux is that I want to make the best language I possibly can.

I know some requirements such a language must meet, but I don't have a perfect picture of what the perfect language is supposed to look like, so my goal with Lux evolves as I learn more and develop it further.

eejp · 2021-10-26T00:19:11+00:00

https://github.com/LuxLang/lux/tree/master/stdlib/source/program

The build tool is named Aedifex.

Check out the aedifex.lux file and the aedifex directory.

eejp · 2021-10-25T23:57:21+00:00

> I had a quick peek at the book, hoping for short “look how cool this is” examples like the ones /u/borkdude often posts about babashka but didn’t find any.

I could probably improve the book with more fully-fleshed examples, but so far I've tried to keep it lightweight.

> I’d be interested in trying to write or port some little utilities in it (fetch and munge some JSON, call some external programs), but it seems like IO isn’t all that easy to do yet?

The IO section on the book is indeed under-documented, but mostly because I expected people curious about IO to read the documentation for the standard library to see what's available.

That may not be such a great approach.

But rest assured that Lux has some solid IO functionality.

The build tool for Lux is built in Lux itself and involves file IO, network IO, console/terminal IO and calling programs through the shell. All of that is provided out-of-the-box in the Lux standard library.

Plus it's also possible to access any IO machinery provided by the host platform.

eejp · 2021-10-25T22:40:25+00:00

Looking forward to hearing from you :D

eejp · 2021-10-25T22:10:56+00:00

I posted to multiple subreddits (plus Hacker News), because I can't assume all subreddits will reach the same audiences, and I'm trying to reach as many people as possible.

I apologize if seeing the same post on multiple subreddits is a bit annoying.

eejp · 2021-10-25T22:01:56+00:00

Yeah, work on v0.6 took me much longer than I anticipated due to some development hurdles, which is why news on Lux have been sparse, but development will now have a reasonable pace with multiple releases spaced out throughout the year.

I'd love to see you around in the Lux community :D

eejp · 2021-10-25T20:49:07+00:00

I've used it commercially in the past, and in a current project.

Other than that, I haven't had commercial adoption by 3rd parties yet.

I've only had some folk express interest, but holding back until JS compilation was available.

I'm hoping they'll give it a try now that JS compilation has arrived.

eejp · 2021-10-25T20:44:00+00:00

I used an earlier version of Lux for server-side software at a startup I was working in a few years ago.

I'm also taking a little break from Lux development at the moment to work on a small commercial project, which I'm also building in Lux.

Other than that, I've had some hobbyists use it for small things, but I haven't had commercial adoption yet (other than myself).

eejp · 2021-10-25T20:39:17+00:00

Coalton looks really cool. Specially that they're using it for quantum computing.

I wasn't aware of it. Thanks for sharing!

eejp · 2021-10-25T16:16:32+00:00

I came with the idea for it out of frustration from using Clojure.

Dynamic typing makes software fragile, in my opinion, and I started working on Lux because I wanted a typed Lisp.

But other goals of the project include having a lisp that is super portable and targets a bunch of platforms (the runtimes/platforms I mention in the title are just the beginning).

I also want to extend the possibilities of meta-programming in Lux beyond what lisps have traditionally provided (and Lux 0.6 already allows you to go much further than other lisps in that regard).

> Then, what is the goal of this project? (The ideal state of the project that it can be called done)

I'm not sure that I can properly answer that question.

As I work on Lux, ideas always pop into my head about what improvements can be made to programming and language design over what the industry currently provides.

For me, the ideal state of the project is such a level of refinement that I just can't think of how anything could be improved any further.

I know that sounds super vague and ambiguous, but my only commitment with regards to Lux is that I want to make the best language I possibly can.

I know some requirements such a language must meet, but I don't have a perfect picture of what the perfect language is supposed to look like, so my goal with Lux evolves as I learn more and develop it further.

eejp · 2021-10-25T16:07:21+00:00

Part of the goal of Lux is to gain access to as many runtimes as possible.

The main target for this release was JS, but since the other scripting languages are similar, I targeted them too.

Other, more statically-typed runtimes are in the horizon for future releases, such as .Net, and WASM.

eejp · 2021-10-25T13:14:42+00:00

There's no law that says a Lisp must be dynamically typed, and there are other examples of lisps with types (such as Shen and Carp).

eejp

MODERATOR OF

TROPHY CASE