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 62 responses.
This is one question where I expect things to have changed substantially since last year! Only one person is using a version of Fennel which even existed last year.
Almost identical results here from last time, except PUC 5.1 has gone down a bit, which is good news as far as I'm concerned.
Still a good chunk of people using LuaRocks, but the percentage has gone down a bit since last year.
Last year we didn't have WSL broken out from other Windows; you can't tell it from this graph because it doesn't show who selected both options, but slightly over half the Windows users (5/9) do use WSL. Meanwhile MacOS gained a little bit of ground.
Visual Studio Code leaps up to third place (it only had 3 users last time) but it has a very long way to go to beat Emacs, and NeoVim remains #1, but Emacs is catching up! Helix was mentioned a couple time in "other".
Not much change here; glad to see a strong showing but might retire this question next year since it feels like we learned what we wanted to know from it.
Roughly the same breakdown as last year, but this year we have our first users in the single-digit age bracket with a pair of 5-year old twins; I love to see this! Coding Fennel as a family activity is so wholesome.
Roughly the same distribution as last year, except shifted up by one, with plenty of fresh-faced new arrivals, which is great to see.
As imbalanced as these results are, they're at least shifting in the right direction from last year. It's great to see more diversity, but we still have a long way to go.
Python has jumped up to beat out Javascript, which has fallen to a position tied with Lua. I forgot to add Rust on last year's survey, but it got a couple mentions in "others", and now it's tied with C. Clojure remains strong which is unsurprising given the connection with Fennel's roots.
Again the answers here are all over the place, but the most common answer was from the Fediverse/Mastodon. Second place was from the NeoVim community, which continues to be very active in its Fennel usage. Link aggregator sites like Lobsters, Hacker News, and Reddit were also a common theme. Unlike last time, no one mentioned coming from any Lua-specific communities other than TIC-80.
Great to see Libera IRC still at the top of this list. Matrix has jumped up and is now pretty close to IRC. (These are bridged together so it really feels like one place with two different ways to access it.) The Fediverse jumped up higher as well. If you picked "nowhere", check out one of these options; the community is active and lively! The "other" responses included a few different discords but not really any overlap between them.
The config/dotfiles option is new this year, and it sure got a lot of responses.
Other than that, we've got a few more people using it at work, which I'm super curious to know more about, but most people are doing so secretly, so I guess we won't be hearing too much about them. But it's still a very small percent of the overall responses.
Programs which have first-class Fennel support has leaped up here from near the bottom to second place, so that's an exciting development. Interesting that AOT-compiling is still in first place. This could be because for a proper release, this approach gives you the fastest startup time, or it could be because people run into difficulties trying to embed the compiler. Maybe these can be split into different options next time.
NeoVim has unseated the long-time champion of LÖVE; very impressive!
Everybody loves simplicity, consistency, and regularity; real crowd-pleasers here! The repl has jumped up to second place, which is great.
Last year we had "access to Lua ecosystem" which was a little vague; this year it was split out into one option for Lua libraries and one for applications that have Lua support in them. It turns out that the libraries one is a little higher than the applications, but applications still score quite high.
I also love that people value community so much that it's tied here with macros. It really is one of the highlights of working with Fennel.
Overall what I'm seeing here is a strong showing of appreciation for features we inherit directly from Lua, but an even stronger appreciation of the features Lua lacks that Fennel adds on top, such as simpler syntax, a powerful repl, and pattern matching.
Whew; OK here we go.
The #1 problem is better editor support, and only two votes behind we have better tooling support. Does this mean people using NeoVim and Emacs (the top-scoring editors) want better support, or does it mean that people want support for a wider variety of editors? The good news here is that the past few months have seen a flurry of development on fennel-ls, an implementation of the Language Server Protocol for Fennel: https://git.sr.ht/~xerool/fennel-ls This actually should help address both of the above: it improves the features available in Emacs and NeoVim, and it also makes those features usable from a broader variety of editors. Give it a try!
It's interesting that the Lua library ecosystem comes out as #3 here when lots of people count the Lua library ecosystem as one of their favorite features of Fennel. I'm guessing this means Fennel has a big lead over small lisps which aren't hosted on an existing platform, but still lags far behind Clojure when it comes to libraries.
We split out confusing errors from last year into runtime vs compile-time. The good news is the compile-time errors (the ones we can actually control) came in last, so those seem to be working great!
Unclear documentation scored very low too, which is encouraging. It looks like the main documentation thing people are having trouble with is Lua itself firstly, and then how to build applications and libraries secondly. So that's useful direction when it comes to improving the docs.
Reluctance to introduce a new language to teammates shot way up this year, which tells me that a lot more people are thinking about using Fennel at work, but can't quite get to the point of justifying it yet. We'll see how this develops over time but I think we'll probably start to see the number of people using it work rise substantially in future years.
One person wrote about getting tripped up from differences with other lisps. Fennel is closest to Clojure, so there's a guide for those with a Clojure background at https://fennel-lang.org/from-clojure but perhaps we'd benefit from a similar guide for folks coming from Scheme or CL?
Looking forward to getting these compiler contributions!
Answers in the free-form section were all over the place, but the top recurring theme was LSP support, so as mentioned above, we're on the right track with that!
The next thing was to improve the compiler output. There are two different classes of problems here. The biggest one is to change how functions are compiled; right now they can never be compiled to an anonymous value but always get bound to a local before they can be used. This is due to a specific assumption about how the compiler output is stored which is baked in pretty deep, and it would be a lot of work to change: https://github.com/bakpakin/Fennel/issues/384
The other problem is easier to address; there are several places in the code where we assume whatever code is being compiled could do basically anything, so we have to take somewhat extreme measures. For instance, naively compiling (= (x) (y) (z)) into Lua where operators are all binary would be something like (x() == y()) and (y() == z()) which calls y twice; this is real bad! So we use an inline function to avoid this. But the compiler could detect that in other cases like (= a b c) that there's no need; the naive expansion is fine in that case. We just don't do enough analysis at this point to tell the difference, and we err on the side of caution. If you're interested in contributing to the compiler, this would be a great place to start.
Some people really want Fennel to have a standard library. I get where this is coming from; I really do. But it's really hard to imagine how we could do a better job than existing libraries like Lume or LuaFun. The whole point of Fennel is that the interop with Lua is completely seamless. Different situations call for different things, and making everyone pay the runtime cost of bringing along a bunch of functions they don't need really doesn't feel like the right answer here, especially when the alternative of "cp ../lume/lume.lua lib" doesn't really have any downsides.
Reinforcing the above, another common thread here was that Fennel's simplicity is its greatest strength, and people don't want it to change in a way that makes it more complex. "Fennel is a lang that fits in my head. I hope it stays that way." I hope so too.
Finally we had a couple people who were on Windows and wished for a smoother install process on there. I'm afraid that's not something we can do with the expertise we have among the current Fennel contributors, but if some Windows users want to step up and help with that, it would be appreciated.
Here are a few of the neat things shared!
A small repl for neovim: https://git.sr.ht/~szgy/dotfiles/tree/main/item/.config/nvim/fnl/repl.fnl , an IRC client library: https://git.sr.ht/~szgy/fnlirc , A terminal IRC client: https://git.sr.ht/~szgy/maguey
The most recent thing I wrote in Fennel was a web server that sends SMS (text messages). https://gti.telent.net/dan/grafana-sms-alert
https://git.sr.ht/~nasser/8fl [a music tracker composition tool]
I used this to generate my homepage for the longest time: https://git.m455.casa/wg :)
This is about the only thing I've published https://github.com/harrygallagher4/nvim-parinfer-rust/
I have a bunch of private tools, but I do have one public project in Fennel which might be interesting to others: https://git.madhouse-project.org/algernon/synodic-period It's a monitoring system. Quite opinionated, and closely tailored to my own needs. It's main purpose is to feed data into Riemann, upon which I can build a personal, private dashboard
We got an outpouring of support and good vibes here.
I tried to give helpful feedback here but I'm extremely satisfied with Fennel and very rarely run into an actual problem. Thanks for the great project!
Keep up the awesome community and welcoming environment :)
This project is great and already delivers a great deal, so thank you!
stay cozy, fennel community <3
Keep up the great work! Fennel is tons of fun to write, and has consistently been an enjoyable language to build with. The community is filled with wonderfully kind and talented folks who deserve as much praise as possible!
This puts into words something I've felt for a while:
fennel is what I wished to find in scheme: a language that uses few data structures (like clojure), with simple & powerful semantics and not much magic under the hood (unlike clojure). thank you for making it real :) hope it can be what clojure became: a power amplifier for small teams and individuals.
This is also something that comes up every so often:
Prefix < is still somewhat counterintuitive sometimes. Would be nice to have built-in positive?, zero?, negative? like Racket
I used to have this problem too! When you think of < as "greater than" it's confusing because you're accustomed to infix notation where the big end points to the bigger number. In prefix notation, there can be any number of arguments! So rather than calling it "greater than", it's more intuitive to call it "increasing?"; that is, are all the arguments to this in increasing order, or not? Once I started thinking this way, I found it to be a lot less error-prone.
Thanks to everyone for their input, and see you next time! Drop by the chat and/or mailing list if you'd like to discuss anything here further.