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 70 responses.
Last year the link to the survey made it to one of the big link-aggregator sites; this year it didn't. So the number of responses isn't as high as last time, but it still shows some growth if you ignore the one outlier year. I have included less commentary this time, because many of the results are the same as previous years.
People jump quickly to the latest version. The oldest version still in use is from a year and a half ago.
PUC 5.1 unfortunately just refuses to die; LuaJIT remains the undisputed king.
Well, yet again, this isn't good. =( I wish I knew what could make it better.
Last year Lua leaped up to beat Python; now it's back in second place. I suspect this is because there were even more NeoVim users last year. Javascript and Typescript both took a significant dive. Rust dropped back to around the rank it was two years ago, meaning last year's jump was probably selection bias.
NeoVim's community continues to be where the most people hear of Fennel, with IRC coming right behind it. XMPP and other chat systems were mentioned as well. Game jams draw in a good number too of course. News aggregator sites were mentioned a handful of times, but not as much as previous years.
I'm sure this is just selection bias too, but it's nice to see that "Nowhere" dropped from first place to third. IRC and Fediverse are strong of course; Matrix is still widely used, but only about half as much as IRC. The loss of the official IRC/Matrix bridge has taken its toll, tho thanks to help from the community we now have an unofficial bridge.
Love2D and NeoVim have always been going back and forth for first place, but this year Love2D's lead was fairly significant. We didn't even have wezterm on the list last year, but now it's right behind TIC-80, probably due to unpopular LLM changes in iTerm this last year.
Finally static analysis tooling is no longer the top of the list; probably because of fennel-ls making great strides. Dynamic tools like debuggers and profilers still definitely have plenty of room for improvement too, and of course the small library ecosystem shared with Lua causes problems when compared to more mainstream languages. Very few people consider the language documentation, compiler error messages, or compilation speed to be problems.
I think we've got to change the wording on this question because a lot of the answers were not really specific enough to be actionable.
A lot of the responses were about third-party tools like a stepping debugger, code coverage tool, and type checker.
A few different people talked about stack traces. I'm not sure how well-understood this is, but Fennel does have source maps that allow traces to be mapped from the Lua lines to the original source; you have to call fennel.traceback instead of debug.traceback. There are two problems: first you have to know that fennel.traceback exists, and secondly that sometimes you don't control the code that calls debug.traceback. For the latter you can use "correlate" that tries to make the Lua line numbers inherently match the Fennel line numbers, but that's not always reliable.
Another thing a couple people mentioned was the tension between macro modules vs inline macros. Currently macros defined in regular modules cannot be called from other modules; you have to make a whole separate macro module if you want to reuse macros. We have a proof-of-concept for extracting macros from normal modules to allow them to be re-used but it still needs work; perhaps you can help us get it across the line: https://wiki.fennel-lang.org/Roadmap#single-file-macroruntime-extract-macros
One person wants "a package manager similar to Cargo" which, I'm sorry to let you down, but is never going to happen. If we build or endorse a package manager, it will be a content-addressable one, not one with lockfiles! Making such a package manager that just works for Fennel and Lua is not that hard, but unfortunately as soon as you touch C code, you encounter nearly insurmountable difficulty due to C library builds being ad-hoc and lacking any consistency.
One person has a wish for "capitalism, racism, and war wiped out either by accident or an intentional push of a new method that proved all things people do which are harmful to others are just plain not worth doing" and I'd just like to say... yes please.
A NeoVim repl using coroutines: https://github.com/gpanders/fennel-repl.nvim
Static site generator: https://codeberg.org/sarna/loving-quest/src/branch/main/ume.fnl
Nine men's Morris in the terminal: https://git.tilde.town/dozens/9mm
Someone has a gradual typing system but didn't share a URL so that will have to be left to your imagination!
It's really heart-warming to hear about how everyone loves and appreciates Fennel.
Fennel has been my introduction to Lisp and I appreciate its consistency and minimalism. I've only been writing both Fennel and Lua for a few months, but I already feel confident that as long as I have Fennel within reach, I'll always pick it over writing Lua directly.
I work with a legacy-ish codebase in Scheme at work and there is a lot about the simplicity of Scheme that I love, but it often drives me nuts with how verbose and archaic it can be. Fennel takes everything I love about the simplicity of Lua's semantics plus the syntactic simplicity of Lisp dialects, and comes in a package that is much lighter weight and more versatile than Clojure.
Fennel + lgi ( https://github.com/lgi-devs/lgi ) is (IMO) a nice low-overhead way to write Gtk desktop apps/utilities for Linux without fighting object-orientation-in-C or having to use Python. I imagine it's sort of like the alternate future where Gnome hadn't dropped Guile as a first-class language back in 199x
We also got to hear about an amazing creative application of Fennel repurposing discarded old hardware:
fennel is one of the tools i use to explore an old smartphone that turned into a super energy efficient server on https://compost.party. i rewrote a service that i started with deno out of habit, and i was super happy to see memory usage drop from > 100MB to 10MB. it's not even a heavily resource-constrained environment, but fennel composts really well!
Thanks for being a great community and see you next year!