Here's what we got! Results are interspersed with commentary. Thanks for participating; see you next year!
Note that all multiple-choice questions allow any number of selections and thus totals do not add up to 100%. There were a total of 50 responses.
No real surprises here; good mix of folks on stable and folks on the latest, plus a few on the previous release.
I'm honestly pretty surprised what a big lead LuaJIT has over PUC here. It's also surprising how high PUC 5.1 rates considering how many important features are missing from that version.
There was one completely wild "other" answer here: "PUC 5.0 with a backported # operator". Wow. I'm shocked this works but I'm afraid to ask for details.
LuaRocks is widely used, but there is still a very large contingent of folks who skip it.
The number for MacOS are lower than I expected, and the number for Windows is much lower. I wonder whether the number of Windows users is low because of problems using Fennel on Windows, or because Windows users are just less likely go looking for obscure new languages?
I expected NeoVim to make a decent showing here, but it turned out to be even stronger than Emacs. Visual Studio Code is very popular among Clojure developers, (especially newer ones) so I figured we'd see more of that, but there wasn't much. Others: a few folks use Lite, a ~4kloc Lua text editor, (which I added Fennel support to) and a few use Sublime Text.
Looks like most people either use readline or some equivalent. I almost didn't include "No, I don't use the repl" as an option because not using the repl is a great tragedy. People who chose this answer: you don't know what you're missing out on!
Not sure what I expected here but nothing too surprising. Cool to see some teens. Welcome, teens!
Some fresh faces here, but it's mostly more seasoned folks. It makes sense that people who haven't programmed much before stick to more conventional languages. There are no books about Fennel yet!
Good mix of old timers and newcomers. Might want to phrase this differently in the future to get more granularity.
Uhhh... okay. There's a lot to unpack here.
First of all, we got someone writing transphobic remarks (deleted) in this field. I want to be extremely clear here when I say this: fuck immediately off and don't come back; you are not welcome here. We have a code of conduct and we take it seriously.
Secondly, I should say a bit about why I included this question. A few people asked me "do you really need to ask about gender?" which is totally fair! I tried to clarify in the survey that every answer is optional, and this one is even more so. But I hoped to find out if we were doing a decent job of being inclusive and if we were better or worse than other similar communities. I love to see the NB representation here, but men are dominating pretty overwhelmingly. =\
If that domination in the numbers is because most women just don't see the point of disclosing their gender here, that's fine and I respect that! If there is a tendency for women not stick around because they don't feel comfortable in our community, we need to take a look into why that is.
Javascript and Python have strong showings just because of their overall popularity. Of course there's a huge overlap with Lua too. Early on while only about half of the responses were in, Clojure was #1, but now it's gone down a few spots.
There aren't many Forth responses, but I was expecting only one, so I'm glad to see more than that! Only in a crowd like this would we see roughly equivalent numbers between Java and Scheme.
Others: Rust, Dart, TypeScript, Groovy, Mathematica, R, rc shell, Limbo, Janet, Factor, Swift, Vimscript. (1 each)
Answers here were all over the place so we'll skip the chart and just summarize the patterns. Hearing about Fennel from NeoVim or its plugin Conjure was the most common answer, with the Fediverse/Mastodon coming in close behind. IRC and blogs were also mentioned a few times. A few people found it because they were specifically searching for a lisp that compiled to Lua. Several people also found it thru various places in the Lua community.
Libera Chat comes out on top here, which isn't too surprising as it's extremely active. It is bridged to Matrix, so if IRC isn't your jam, you can still participate in the same conversations. People who chose "Nowhere": come check it out! It's also great to see the Fediverse come out so far ahead of Twitter.
A few other mentions of Discord, Lobsters, Telegram, and the Tildeverse.
I honestly expected games to take first place here, but it makes sense that personal code that isn't shared would be #1, especially in a language that is often used for dotfiles and config. Web applications remain a niche. It's great to see a brave few using Fennel at work; good luck! Other responses include reference NeoVim and configuration of other programs.
AOT compilation scoring so high is a surprise to me, though it is admittedly the simplest approach. Not having the repl available at your fingertips is a real drag. I wonder if most of the people doing AOT compilation are just doing that when they distribute their programs and end up using the repl during development.
I'm surprised that standalone binaries scored so low; it makes me wonder if people don't know about this, or if it's just too tedious to compile the different binaries for all the different OS and architecture combinations you need.
LÖVE, NeoVim, and TIC-80 are of course the crowd favorites, and for good reason. Others: two mentions of Hammerspoon, (a Mac window automation tool) which I should have added as an option but forgot. One for LOVR, a 3D variant of LÖVE which looks very promising.
When people talk about lisp languages, macros are often the first thing that gets brought up, because macros are what make lisp languages truly unique. No other languages do macros as well as lisps, because if they did, they would be a lisp. However, my own opinion is that the consistency of the syntax is actually a bigger advantage of lisps in the day-to-day, even if macros are a more exciting feature. These results seem to back that up.
Of course the repl is absolutely indispensable, so it's no surprise to see it scoring highly. The simple semantics of the language are inherited from Lua, (with a few further simplifications) and it's great to see that people appreciate that so much as I think it's a big part of what sets Fennel apart from other lisps. I think no language is complete without pattern matching, so seeing it score so highly was very validating.
Finally, access to the Lua ecosystem is what makes Fennel actually useful, and thus it's a big part of its success. Building a library, runtime, and tooling ecosystem from scratch is exhausting, and having it readily available for us helps us focus our time developing Fennel solely on the compiler.
OK, time to face the facts: Fennel isn't perfect.
With the lack of immutable data structures ranking so high, you can put the pieces together pretty easily and guess that this is the Clojure crowd speaking. Fennel doesn't have any concurrency, so immutable data structures aren't quite as important as they are on the JVM, but yeah, it still helps you organize your thoughts in a functional way. Luckily there are great 3rd-party libraries for this; luafun ( https://luafun.github.io ) is one that's been around forever, and itable ( https://gitlab.com/andreyorst/itable ) is a newer entry which is itself written in Fennel.
The relative dearth of libraries in Lua's own ecosystem simply comes with the territory, but it is interesting that access to Lua's ecosystem scored so highly on the previous question. Perhaps it's because when people say they like the Lua ecosystem, they're talking about applications which have Lua built-in, and when they say Lua's ecosystem is a problem, they're talking about libraries?
The lack of runtime functions is similar—on the one hand people love Fennel's simplicity and consistency, but on the other hand, it forces some difficult trade-offs. Fennel is just a compiler, and nothing else! That's why it's so simple and predictable. But it also means that things you might expect to be built-in sometimes need a little 3rd-party help. But lume and luafun are excellent libraries! They're also single files with no dependencies, so you can just drop them into your codebase. It's not 100% seamless, but it's very easy. I think a lot of people coming from other languages don't understand this; they think of adding a library as something which comes with an ongoing cost.
The one about better editor/tooling support probably needs more clarity in the wording. Is it certain editors which are lacking? Are folks really jonesing for an interactive line-stepping debugger? Join the chat or mailing list and let us know!
The one about confusing error messages is again not a sufficiently clear question. I would like to think that the compile-time error messages (which we actually do control and have spent a lot of time improving) are good and that people are complaining about the runtime errors. But I'm not sure; we will have to split those out into separate options next time.
I was shocked that "reluctance to introduce new languages to projects with teammates" scored so low. It seems like with a relatively low uptake at work, this would be a big thing preventing people from using Fennel, because you don't want to impose a new language on other people who might not be keen to learn it. Am I wrong, or was this worded badly?
Only one person thinks that the runtime performance is too slow (maybe they haven't tried LuaJIT yet?) and zero people think the compile time is too slow. Another great thing to note is that zero people indicated unpleasant community interactions. Let's keep that up!
I just have to say I love the honesty here. Compilers can be intimidating! That's OK. I think you'd be surprised at how accessible certain parts are, like the parser, the repl, the macro system, and the error messages, but there are definitely certain parts which can make my own head spin. (The destructuring implementation; yikes!) So there's certainly room to improve documentation and explain how everything fits together.
The free-form answers here mostly reflect the "biggest problems" answers, which I guess shouldn't come as much of a surprise. Better debugging tools was a common refrain. There's one quirk of the compiler a few people mentioned where it emits inline functions where it's not strictly required because of implementation details regarding how it works around Lua's statement/expression gap. And several people want more detailed examples to learn from. That's something I hope to do more of going forward.
I love to see people share what they've made. Here are some projects:
I shared my fireverk task manager at FennelConf and appreciated the friendly audience. Haven't worked on it much since. https://hg.sr.ht/~incidentist/fireverk
Sure! I write (almost) all of my Neovim dot files in Fennel using a custom plugin I developed. They’re available at https://git.sr.ht/~gpanders/dotfiles/tree/master/item/.config/nvim
Y’all know about Honeylisp 😎 https://bitbucket.org/SpindleyQ/honeylisp I’m very pleased with my single pass compiler targeting the 65816 https://bitbucket.org/SpindleyQ/honeylisp/src/gs/ssc/
It's written *in* fennel, but it's written for fennel. https://github.com/travonted/tree-sitter-fennel
I already shared but here it is again: https://treebrolly.com/projects/awe/
Sure, but it's not very good. https://github.com/LJNIC/Escape
My neovim configuration: https://github.com/datwaft/nvim
This one was basically a love-fest where everyone talks about how much they enjoy using Fennel. Awww <3 yall are the best! Some highlights:
It’s kind of unreasonable how much I enjoy working in Fennel compared to any other language right now.
I'd like to do another project in Fennel. Maybe another TIC-80 game, maybe stretch myself with a LÖVE game.
Love this form; it's very 1996.
Huge thanks for your work on Fennel, and to everyone in the community!
Thank you for continuing to improve fennel! It's one of my favorite languages at this point, and I just want to express my appreciation ^^
I love Fennel!
I'm mainly a Lua dev with interest in Clojure, and I really wish the best to Fennel project. Lua as a platform is incredibly powerful and performant way to use computing resources, and so much more lightweight than JVM and most of JS interpreters. Fennel is in great position to take advantage of this.