How would you describe Gren to the average programmer?

Gren tries to take the most important ideas from pure functional programming languages and present them in an easy-to-learn language which can be used for pretty much anything.

If you've heard of Elm, Gren is quite similar (in fact, it started as a fork of Elm), but we intend to support back-end development starting with our next release in December 2022.

If you haven't heard of Elm, or pure functional programming in general, it's a way of writing code that has no side effects. Side effects are things like mutations, exceptions, HTTP calls, file IO etc. These things are necessary for any real-world programming, and pure functional programming doesn't remove them from your toolset. Instead, pure functional programming makes you focus on the actions leading up to, and which come after, a particular side effect. In other words, the code you write doesn't contain side effects, even though your application does.

Another common trait of pure functional programming languages is that they have a strict, but flexible, static type system. This type system lets you model exceptional situations as type errors, instead of runtime exceptions. So, NullPointerExceptions don't exist in Gren; they’re a type error instead. Not handling an HTTP timeout is not an exception, but a type error, etc.

Pure functional programming makes for easy-to-follow code execution and have fewer bugs. Gren intends to expose that to as many people and as many platforms as possible.

Which problems is Gren trying to solve?

Haskell demonstrated the benefits of pure functional programming, however many people find it hard to learn and understand. Elm showed that you can take the important concepts of Haskell and distill it into an easy-to-learn programming language. The problem is that Elm only targets the browser. In addition, Elm hasn't had a release in a few years, even though there are bugs to fix and rough edges to smooth out.

---

Gren intends to take all the benefits of Elm and make it available to more platforms, like web servers and command line applications.

---

At the same time, we intend to continue evolving the foundation that Elm has laid down for us, by improving the language and extending the number of available APIs.

What are some of the toughest challenges with building Gren?

Gren compiles to JavaScript, and most JavaScript APIs are not pure, meaning they cause side-effects when used. One of the most tricky aspects of developing Gren is exposing a pure interface over impure APIs which, at the same time, is pleasant to use and easy to understand.

What's next for Gren?

The focus right now is on supporting the NodeJS runtime, so that people can write command line applications and web back-ends. The basic functionality for this will be included in our 0.2.0 release (targeted for December 2022) and more APIs will be made available throughout 2023.

Where can people learn more?

Our website contains enough information to get started. We also have a community on Zulip and curious individuals are encouraged to join the discussion!

Program comparison: arithmetic

Prompt: Implement a program which takes in a single string from stdin containing a basic arithmetic expression, such as “1 + 2 - 5”, evaluate it, and print the result.

How would you describe Lux to the average programmer?

Lux is a purely-functional and statically-typed lisp that pushes the boundaries of what's possible in terms of meta-programming.

A secondary aspect of Lux is that it's meant to be (as closely as it can be) an omni-platform language that you can use to build software for very different projects with very different circumstances, by leveraging the multitude of available platforms (currently the JVM, JavaScript, Python, Ruby and Lua).

What problems is Lux trying to solve?

Honestly, mostly just problems that I've felt I've had. 😅

I wanted to make a typed lisp because I wanted Clojure to have types and core.typed just wasn't doing it for me.

I wanted to make Lux crazy extensible and customizable because I wanted to know that no matter what software development I wanted to do in the future, I could always bend the language to my will, and I wanted to give other people the same freedom.

And I wanted Lux to compile to anything because of a bad experience I had years ago working on a little game, and feeling frustrated that I couldn't compile Clojure to ActionScript in order to run my game on Flash.

What makes Lux unique?

There are so many answers to that question, but I'll try to focus on the most outstanding stuff.

Types are first-class values and they're just data-structures, so you can introspect then and compute with them at will (though most of the useful stuff you might want to do with them will likely happen at compile-time).

---

Macros have access to the state of the compiler, which gives you more power and flexibility than macros in other lisps.

---

And not only can you write macros to manipulate the syntax of Lux, but you can also write extensions for the compiler with regards to semantic analysis (and type-checking) of code, optimizations and even code-generation. These extensions are a bit more complex than macros, but not too much, and you can do with them stuff that even macros cannot accomplish.

There's even an (experimental) meta-compiler architecture that I introduced (and plan to use heavily in the future), that allows creating your own compiler sitting alongside the Lux compiler, and would even let you create polyglot programs from within Lux. It's still very early stage, and I haven't done anything useful with it yet, but I plan on building something important on top in an upcoming release (though I'm keeping what it is a secret for now 😉).

What's the coolest thing that's been built with Lux so far?

Publicly, the Lux compiler itself, and the Lux build tool.

Privately, I'm working on a project for doing financial analysis and it's being written in Lux. But it's closed-source and commercial, so I can't disclose more.

What are some of the toughest challenges with building Lux?

Prioritizing stuff.

---

I've had crazy cool ideas sitting on a TO-DO list for years because of higher priority stuff that I needed to do.

---

It kills me to pick winners and losers in terms of what gets scheduled for an upcoming release. There is just so much stuff that I want to do! 🤩

But most of the heavy-duty stuff that I had pending has now been done, and I feel like the next few iterations are going to grant me the peace of mind I have yearned for the last few years.

So, what’s next?

More platforms!

In particular, I'm hoping to compile to C/C++ in the future; and maybe Perl, PHP, Common Lisp and a few other platforms. WebAssembly is definitely on the hit-list.

A friend of mine also gave me an idea that might help me finally get a juicy niche for Lux to live in, but I'm keeping that a secret for now. 😁

Where can people learn more?

• They should check out Lux's repo

• There's also the book

• And they can also check out the talk I gave at Strange Loop years ago (though it's a bit dated):

Which language would you say yours is closest to?

That's a tough question to answer. Can I split it half-way? 😅

Clojure would definitely be the mother, giving Lux syntax and a lispy orientation towards meta-programming.

Haskell would be the father, instilling a purely functional work ethic and proper mathematical values.

Program comparison: arithmetic

Prompt: Implement a program which takes in a single string from stdin containing a basic arithmetic expression, such as “1 + 2 - 5”, evaluate it, and print the result.

Showing off more code: extensions

Arithmetical operations are defined on a per-type basis. Here, we'll define a "universal" way of adding numbers that works on the default numerical types in Lux, so long as the types of all the parameters line up.

How would you describe Gwion to the average programmer?

It's a programming language meant to be approachable, without leaving advanced concepts aside. More importantly, it's meant to make sound and music.

What problems is Gwion trying to solve?

I always wanted to have a tool allowing me to create new scales/sounds/rhythms either in a purely explorative way or to use in my contemporary music work. I think music is also a great way to teach mathematics. Finally, I wanted to make some research in human (or band, actually) - computer interaction. At one point, I stumbled upon ChucK, which really seemed to fit the bill, but it turned out it was not performance oriented enough for my needs. So I started developing this project.

What makes Gwion unique?

It is very similar in approach to ChucK, in that it's:

• Strongly and statically typed

• Strongly timed (ability to precisely control the flow of time in code)

• Made to make sound

So the key difference here may be performance. But while learning programming in order to complete this project, I eventually came across features I found missing in ChucK, like function pointers and generics. It did go quite a long way and now has some features I did not plan initially, like variadic generics, effect handler and virtual time (a way to handle computation in a timed manner but not synced to the sound card as Gwion usually is).

What's the coolest thing that's been built with Gwion so far?

A company named Amrai that is developing a multi-platform (including arm64) audio software meant to power a hardware audio device contacted me last year and is using Gwion for their project. We have been working together since. This project is very exciting in that it will possibly help people all around the world to make music and that's an achievement that I couldn't probably afford with just my music practice. It is also interesting as a language developer because Gwion is used not only to generate sounds but it also handles the rest of the project, like a general purpose language would.

What are some of the toughest challenges with building Gwion?

I started this project more than six years ago and I had to learn a lot about programming to achieve it. Things like template implementation were very challenging at first. I think the next big challenge will be to implement some fancy memory management strategy, for example, as Lobster does.

What’s next?

I made a simple back-end (dsvm) a while back and I plan to switch to it soon. It has a fast register machine and the ability to run multiple JITs. I'm also working on a SWIG module to help with plugin development.

Where can people learn more?

There are a few sites with short, runnable examples:

• The main documentation

• A tour of the language

• A few, hopefully musical, snippets

Please note that these are pretty WIP and I would love some help here. Other helpful links:

• The Github repository

• The Discord server

Show us some code!

I love this snippet. It makes use of an embedded language and demonstrates both explicit timing and concurrency.

This one is also nice! It shows how easy it can be to react to HIDs.

How would you describe C3 to the average programmer?

C3 is an evolution of C: “what could C look like if backwards compatibility wasn’t a concern?”. The main additions are modules, slices and semantic macros, but otherwise it tries to stay close to the look-and-feel of C. Most importantly, it is ABI compatible with C everywhere, meaning functions in C3 are by default callable from C and vice versa.

---

You don’t have to rewrite everything in C3, you can pick and choose.

---

Which problems is C3 trying to solve?

C has the burden of backwards compatibility and while it’s possible to add features on top, it’s hard to make them nicely integrated in the overall language. Some parts of C (in particular string handling and arrays) aren’t very ergonomic and makes the language seem harder to use than it needs to be. So it’s about making C programming more accessible and less punishing by providing better tools for the pain points in C.

What makes C3 unique?

I don’t know if it is! There are a couple of ”C replacement languages” in development right now: Odin, Jai, Zig and Hare to name a few. What they have in common is that they diverge quite a bit from C syntax and semantics.

---

C3 is different: you can just lift your C code with just a few changes into C3 and have it run as expected.

---

What are some of the toughest challenges with building C3?

I’d love to have more people invested in the project with strong language design sensibilities to bounce ideas off. I love a good argument to be able to narrow down on the essentials of a feature. Luckily there are forums for budding programming language designers to trade ideas which helps. But that’s not quite the same as having someone who really wants to help YOUR language.

The programming is the easy part.

What's next for C3?

Work on expanding the standard library, I’d like to reach the point where people can feel it has all the necessary basics.

Where can people learn more?

The docs can be found at https://www.c3-lang.org and the compiler can be found on Github: https://github.com/c3lang/c3c

Which languages inspired yours the most?

C2, by Bas van den Berg. My first compiler work was actually contributing to the C2 compiler! While Bas wanted a more modest feature set on top of C, I thought more ideas should be tested, and initially C3 was just C2 + some more features. When I decided to write a compiler for my ideas, I picked the name C3 to acknowledge its origins.

Program comparison: arithmetic

Prompt: Implement a program which takes in a single string from stdin containing a basic arithmetic expression, such as “1 + 2 - 5”, evaluate it, and print the result.

How would you describe Fennel to the average programmer?

Fennel is a language a lot like Lua, but it simplifies the syntax and removes some of the most error-prone and troublesome features of Lua while adding modern conveniences like pattern matching and a capable REPL for interactive use. That description omits to mention it's a language in the lisp family, which I think has an undeserved negative association in the mind of the average programmer. Maybe it's better to focus on the concrete benefits like the simplified syntax and lack of operator precedence rules to memorize!

Which problems is Fennel trying to solve?

Like Lua, Fennel's strengths come from its extremely small size. A compiled Fennel standalone program can be distributed in under 300kb, but it can also be embedded inside a larger program. Historically this has been C programs, but nowadays it's possible to put a Lua VM (and thus Fennel) into programs written in Java, C#, Go, Javascript, and other languages. But it's not just small in terms of disk space, it also has a conceptual simplicity that makes it much easier to fit the whole thing in your head.

---

The other thing Fennel is particularly good for is writing games.

---

Fennel’s included out of the box in TIC-80, the fantasy console, and it works great in LÖVE, the classic 2d Lua game framework. Every year we have a game jam for lisp-family games and the winners of the competition are almost always written in Fennel.

I've written up more about the rationale behind Fennel on the web site here.

What makes Fennel unique?

Fennel is unique in that the language design space is severely constrained: this is a language without a runtime, so we can only implement features which can happen at compile time. All the runtime semantics are predetermined by the Lua VM. There is no standard library. The only other language I know of which did this was Mirah, which compiled to JVM bytecode without any of its own runtime. But the JVM is a much, much larger target than the Lua VM.

What's the coolest thing that's been built with Fennel so far?

This has to be a tie because it's impossible to pick just one. Ramsey Nasser has created 8fl, which is environment for live-coding chiptune type music. It's is really expressive and fluid. The other one that comes to mind is Jeremy Penner's Honeylisp, which is an environment for live-coding games for the Apple II platform (yes, really). It's an editor and compiler written in Fennel which targets the 6502 instruction set and lets you stream your code changes live to a real 8-bit Apple II computer over a serial port.

What are some of the toughest challenges with building Fennel?

---

The most difficult thing is holding back on an idea until the time is right.

---

We'll often come up with ideas for new features that would make something a lot more convenient, but the initial idea just doesn't *fit*.

For example, the first implementation of macros brought in all the macros from a given file without naming them. So you could have identifiers introduced into the code but there was no hint in the code where they came from. This was later identified as an antipattern, so it was replaced by import-macros which had you name the macros you wanted. But we have the old way still hanging around with a big old warning in the docs that it's not recommended.

Another example is our map construct. Almost every language (but not Lua) has a construct like map, which iterates over a list of elements with a given function and returns a new list with the results. We really wanted this early on with Fennel. But Fennel has no runtime, and map is a function. So there wasn't any way to do this that fit. We wanted to put it in, but we held off because we hadn't found the right way. Later on someone suggested an approach based on list comprehensions, which are used for the same thing but are a syntactic construct rather than a function. Following this idea, we added icollect as a macro, and it was a much better design than it would have been if we had tried to add map like we originally wanted to.

We still haven't found a way to express custom types which can roundtrip thru serialization and being read back in again. We have some ideas, but they're half-baked, and we know we're better off without that feature until we find the right way to do it.

Program comparison: arithmetic

Which paradigms does Fennel target?

I can't say that Fennel targets functional programming exactly since there is no support for immutable data structures in the language (you need a 3rd-party library), but idiomatic Fennel uses partial application and higher order functions much more than Lua does. It also pushes you in a more functional direction by making rebinding of locals opt-in instead of opt-out. Lack of statements and early returns also contribute to the "imperative-lite" feel, but in the end it is an imperative language.

I don't really know if this counts as a paradigm, but Fennel focuses strongly on *interactive* programming; that is, coding alongside your running program and making changes to it instantaneously without restarting.

---

Even if you aren't working in an editor with first-class Fennel support, the repl has built-in support for reloading modules on the fly.

---

Which language would you say Fennel is closest to?

The runtime semantics are a pure subset of Lua. In particular, the module system is one under-appreciated feature that is very well-designed, and I've come to prefer Lua's modules over Clojure's. However, the syntax is closest to Clojure, with a few improvements to the destructuring syntax and the addition of pattern matching. Many of the syntactic similarities are somewhat superficial, but the macro system in particular uses Clojure's absolutely brilliant solution to Common Lisp's accidental symbol capture issues. It solves all the same problems as Scheme's hygenic macro system in a fraction of the complexity.

Which languages inspired Fennel the most?

When Clojure came out in 2007, it showed us the power of hosted languages; that is, taking a runtime from an existing language and developing on it symbiotically so you don't have to start the whole stack from scratch. At the time this was very novel; the only precursor I'm aware of was Coldfusion, which most people didn't take very seriously. Nowadays hosted languages are perhaps even more common than non-hosted languages, and we're even starting to see them break into the mainstream with Kotlin, F#, TypeScript, and Elixir.

I believe Fennel takes this idea even further than Clojure: since there is no Fennel runtime, compiled Fennel programs are indistinguishable from Lua programs (with maybe a few funny variable names); Fennel functions are Lua functions, and Fennel modules are Lua modules. Of course, the library ecosystem for Lua isn't as rich as that on the JVM, but given its small size and instantaneous startup time, it addresses a niche which Clojure has historically done very poorly.

Show off some cool Fennel code

What's next for Fennel?

We had our 1.0 release less than a year ago, and feature changes have certainly slowed down since then. Right now we're focusing more on tooling. We have a formatter and a lua->fennel reverse compiler to aid porting codebases and example code. We have someone working on a stepping debugger, and someone else just started to implement an LSP server for Fennel.

So upcoming changes to the compiler now are going to be less about changing the language and more about exposing more information like scoping and modules and such from the compiler to third-party tooling through the API.

Where can people learn more?

The main site is https://fennel-lang.org but we've also got a decent wiki that we haven't yet moved off Github at https://github.com/bakpakin/Fennel/wiki

But the main place to learn is the chat which is available both with IRC at #fennel on Libera Chat and via Matrix on #fennel:matrix.org depending on your client preference.

---

The chat is fairly active and very friendly to newcomers.

---

How would you describe jank to the average programmer?

First try: Clojure meets TypeScript meets C++.

The average programmer may not know Clojure, so a second try might be: A functional-first lisp with a standard library built around immutable data structures which allows your code to begin dynamically typed and then become statically typed as you add type annotations. jank is compiled to native code and can interop with C++ directly.

Which problems is jank trying to solve?

Clojure is superb at transforming data in a purely functional way, but its dynamic type system can make some forms of development challenging (type-rich APIs, fearless refactors, excellent in-editor tooling). Furthermore, Clojure is generally hosted in a very dynamic environment, such as the JVM, CLR, or a JS engine, which is prohibitive when it comes to accessing native libraries, minimizing start time, and working on software like games. jank tries to bridge each of these gaps.

What are some of the toughest challenges with building jank?

Firstly, it turns out trying to make a fully dynamic language, including REPL support, work in native code is not easy. LLVM’s JIT support and, in particular, Cling, make this at least possible.

Secondly, jank is trying to be an excellent dynamic language and an excellent static language. Generally building one is hard enough.

Where can people learn more?

The website is here: https://jank-lang.org

You can sponsor development here: https://github.com/sponsors/jeaye

Program comparison

Implement a program which takes in a single string from stdin containing a basic arithmetic expression, such as “1 + 2 - 5”, evaluate it, and print the result.