A vaguely curated rendering of the free text answer in the State of Clojure 2022 survey. Answers are ordered by length and their title contains the original timestamp and a summary sentence which I added to make it easier to find them later. The rest of the text is the original with some formatting fixes.
- What can we as a community do to increase Clojure adoption?
- Who do you appreciate in the Clojure community and why?
- Who do you appreciate frequencies
I think removing the word "Lisp" from the homepage and introductory material on the Clojure website would really help get people on the first step to learning Clojure. The Clojure homepage should show code before ever mentioning "Lisp". I love lisp personally, but I really feel marketing Clojure as a lisp has go to be harmful to adoption. Everyone in the lisp community already knows it's a lisp. So the word "lisp" isn't there to market it to them, because that would be redundant. And the people in the lisp community are the ones who are already sold on Lisp. It's there to market it to people who don't know anything about Clojure. But the thing is, for those who don't know anything it, it being a lisp is probably not a good thing to them at first. Most people's first reaction to Lisp is absolutely not "ohhh it's a lisp, that means I can have macros and homoiconicity, that's a real selling point!". Because if it was a big selling point, Clojure would probably already be a lot more popular. Most people's reaction is that they don't want to touch "Lisp". It's a relic. It's ugly. It's confusing. It's hard to read. It's full of parentheses. The reality is that this is most people's first impressions upon reading the word "Lisp". So as soon as most people hit that word when reading the Clojure home page, it's an uphill battle to keep their attention. Now, my reasoning here is purely annecdotal, but I'm a university TA and tutor, and I've had hundreds of students come to me for help and I've interacted with hundreds more students in online communities. Across the board, people think Lisp is a joke before they've ever even written a line of it. Very few walk out of their programming languages class having had a positive experience with it. I can only assume that students at other universities have had a similar experience. I think using that word on the home page is a serious detractor for a lot of people. I think Clojure would be way better off showing samples of code that specifically don't look like lisp. Something manipulating a vector or a hashmap and using threading so people aren't thrown back to college and remembering reading their common lisp code backwards because of deeply nested function calls. Show let and cond using their vectors so people don't think back to all the times that they missed some parentheses around their let binding or cond case. These are all negative associations that come along with lisp and the first thing we want to do is dispel those or lots of people will walk away without ever giving Clojure a chance or even a second though. I also think startup time needs serious improvement. I understand that there's things that are just fundamentally going to be slow because of the way the JVM works and the number of classes Clojure produces, but this is people's first experience in the language. They're not going to start with the REPL right away, they're not going to start with babashka or something else. They're probably going to make a Clojure file and try to evaluate it and see that their "Hello World!" program took 2 seconds to run instead of the milliseconds like every other language they've touched. People who are familiar with the JVM are probably going to be a little more forgiving of that, but that's not the majority of developers anymore. People are going to see that 2 seconds and say "wow, that was pretty slow for hello world". And we can use the excuse "oh, but you'll never run Clojure like that, it's all in a REPL, and when you do it's in a long-running service so you don't have to restart it anyways, and also there's this thing called GraalVM and there's babashka too and blah blah blah". It's slow. It's the first thing people experience. It needs to be faster or people will think this is a painfully slow language and that'll turn people off of it. Clojure is an awesome language, it's my go-to for everything these days, and I would use it for work in a heart beat if I didn't work for a government agency that has strict rules on what's allowed in production. But other people need to be sold on it, and Clojure's marketing isn't great, and neither is people's first experience with it. It's a lot of, just trust me, it gets better. And that needs to change.
It’s been a long time since I was adopting Clojure. I haven’t read the intro guides or been in the newcomer forums much in a long time. So take all of this with a gain of salt. There are two pieces: getting someone on the path and then keeping them on it. The first is harder but more important. Clojure could do more to market itself. The overview and guides on the Clojure website are really lacking in examples: small programs that can be elegantly expressed in Clojure, things that would be hard to do in other languages (eg the ants demo), comparison of SQL-style to datalog-style queries, comparisons of equivalent code in other languages, etc. Or in other words, the Clojure website could spend more time explaining why a programmer might fall in love with Clojure and less rationalizing why an architect might make a business decision to use Clojure. Keeping someone on the path is also tricky. For me, I think the hardest problem for newcomers is figuring out ONE way to create a program that does whatever it is they want to do. Not THE way, just a way. That’s why I appreciate all the project templates and example projects out there, even though I often disagree with their library selections, or lament how out of date they are. At least they offer SOME way to write a web app, or a server, or to make art or music, or to analyze data. I particularly appreciate two projects for this aspect—pedestal and re-frame. Both are fairly prescriptive about how to structure a project and how to manage data in that project. (Nowadays I disagree strongly with parts of those prescriptions, but I needed those training wheels before I could formulate my own criticisms.) I love that Clojure encourages you to bring your own tools. But in a world like that, you need great resources that can help you learn about, pick, configure and get to building with those tools. Newcomers in particular need help with those first two—what are the problem spaces and what are popular solutions? Maybe this takes the form of a version of Clojure Toolbox or Clojars that focuses on advice and comparisons rather than being just a catalogue, I’m not sure. IMO the second most confusing thing is how to run your code, locally and in production. There are just so many tools and it’s hard to know which ones are most important to learn. It’s good that the community is centralizing around deps.edn and things built from it. But I worry that newcomers still feel intimidated or dumb for not knowing how to use clj and shadow-cljs and lein and bb and java and boot. And then how do you do a production compile ? And how do you get that into the hands of your users? I’m not suggesting that the Clojure team provide definitive answers for those questions, but I think the guides should acknowledge up front that this area is challenging and that there is a community that can offer guidance.
For beginners: Make the setup of a development environment a lot quicker/ easier to grasp. Do programmer beginner tutorials in Clojure/ ClojureScript, for people that never programmed at all. Something like the Automate The Boring Stuff book for Python, but in Clojure(Script). To sysadmins, the threading macro is like a pipeline - that is just awesome. But most scripts for sysadmins need to start very quickly (e.g. in monitoring), so Babashka/ nbb are perhaps better suited here. For advanced/ professional users: Show more debugging/ performance profiling with Java Flight Recorder/ VisualVM or even from underneath using eBPF. Show the same things for ClojureScript in browser/ Node.js. Explain more jlink/ jpackage etc. Assume, people skipped Java/ JavaScript and went to Clojure/ ClojureScript directly, pointers to "platform" resources and how they apply to Clojure/ ClojureScript (even ClojureCLR) would be really great. Both: Show Good code vs bad code comparisons/ reasoning like what e.g. Raymond Hettinger does with Python sometimes. Write guides/ do videos about some common use cases, like parsing various crazy CSVs that are out there, converting images, sending SNMP requests (that's the case in many on-premise sysadmin jobs), using libpython-clj, Datomic, XTDB and more guides about various aspects and use cases would just be huge. ClojureCLR could use some love and capture some of the Windows/ C#/ F#/ PowerShell crowd. It would be really nice, if one could somehow run a difference between what is running in a REPL and what the project has for basically live-patch deploy of code of sort (across files). If one could print out the diff between, what is running vs what my code is would help a lot too. It could optionally require a confirmation to apply these changes - something like configuring a network switch and then hitting "apply". Finally, stoppable execution of the last "command" written in a REPL would greatly reduce the fallout of a session gone awry. I know the REPL isn't a shell but there must be some way the interactive session can be friendlier in this regard.
A great place to start would be a solid tutorial. The "Learn Clojure" guide on clojure.org (https://clojure.org/guides/learn/syntax) is pretty sparse; it's mostly text, and covers surface-level stuff like syntax, defining functions, and the common data structures. It mentions the REPL before even saying how to run the REPL, and common conventions aren't covered (covering loop first is an antipattern imo - people coming from OOP will use loop as a crutch rather than embracing map, reduce, filter, etc.) Additionally, splitting the documentation between "Reference" and "Guides" is a little annoying, since I never know if the info I need is in a guide, a reference, or if it's undocumented. My gold standard for programming language tutorials is the Rust "Book" (https://doc.rust-lang.org/book/title-page.html). It takes you through the exact process of creating a project, compiling it, then running it straight out of the gate - there's no confusion on "how do I run the program". Also, it introduces topics didactically. Chapters usually start with a "here's this problem/topic" type premise, then the rest of the chapter delves into the proper Rust way to do things. Most importantly, though, it's a complete tour of every language feature. It doesn't just show off the basics, then leave you to hunt down the rest in blog posts or third-party tutorials. I also think Rust is a good example because it's a similarly "weird" language living outside the object-oriented status quo, much like Clojure. It should also be noted that the Rust "Book" is an honest to God book (No Starch Press sells physical copies, it's a couple hundred pages!). It's quite the tall order to write an entire book on a programming language, but I feel like it would be worthwhile for the community to fund an official book that serves as a canonical tutorial/reference to the language.
Make it more intuitive and user-friendly to go from 'zero to working'. Integrate it with other popular 'easy' languages -- Python, Powershell, Kotlin (for example). Make commonly done stuff (like reading/writing CSVs, navigating/manipulating directory structures, etc) really easy (like it is in Powershell). Come up with answers for some of the things other languages are known for -- ML and data science in Python, coroutines in Kotlin. Make moving to the Cloud with Clojure so easy that it entices people to experiment in the cloud just for that experience. Have a registry of popular libraries that are linked to functionality people might search for. Code snippets that are easily accessible from the tooling. Better error handling and error messages. Have Rich Hickey visit large stodgy corporations and give one of his classic presentations. How have other languages gained adoption quickly? Python: ML & DS, and general ease of use (annoying as space-based syntax is). PowerShell: You can do a lot of system utility stuff really really quickly. Kotlin: A much better Java, and Android didn't hurt. Ruby: UIs. So what's the next thing? Cloud and serverless. Our company is thinking of switching from Java/Kotlin to Python b/c of the JVM startup issues with lambdas; does Clojure have an answer to that? If so you'd get a seat at the table. We've found that it takes forever to get a developer up in AWS (for example) and productive -- a lot due to security but also unfamiliarity, information overload, etc. Figure out a niche to make people super-productive super-fast in the cloud. Like transferring, cleansing, transforming, synchronizing data, it's still 70% of what developers do in large corporate companies. Just a thought.
Tried to get company to use ClojureScript over TypeScript as it feels like we're tripping over ourselves constantly and everything comes out more complex than it should be. The main opposition came in the form of "how big is the hiring pool" and "I talked to some companies in Silicon Valley and they said TypeScript is what's good" even as we waste hours, and hours per project wrestling with it. I used to think it was important for Clojure(Script) to become the most popular language and loved sharing it. But then I started thinking about it and that may not really be the goal. A metal band shouldn't be considered a failed pop band right? Therefore a language that decidedly is anything but typical shouldn't be thought of as unsuccessful if it doesn't reach the status of what's popular because it's more important that it's "good" and the people who do get it, get a lot out of it. That said, if we can make it fit into more pockets of a stack to "try out" I think it may get easier adoption or feel like less of a big up front decision. One language we tried was ReScript formerly Bucklescript. What makes its tooling story cool is that you write .res and .resi files then transpile it during development time to .js and .ts files. This made it really easy to add to an existing stack and work with any pre-configured bundling solution or create-react-app or whatever framework. If we could build some tools possibly leveraging scittle and node-babashka that compile into js that fits into existing projects, then I think it would be an easier sell. I know there are some published tutorials about using external bundlers but the setup for that is definitely not as out-of-the-box as other languages in that front.
3 things. 1. better answer to typing, in particular, an easier way to specify the shape of data at function boundaries. Specifically: (defn something [x] {:pre [(assert-shape-is MyInputSpecification x)] :post [#(assert-shape-is MyOutputSpecification)]} ) I think this information really helps adoption. It tells someone interfacing with "something" basically everything they need to know. I have tried most methods until 2019 or so, including spec, and IIRC this is the most in-your-face way to do it. but it's frictionful, and tooling support is poor. I haven't seen a really stable answer. 2. "stable answer" includes good tooling. Clojure codebases are smaller, but Typescript codebases are much easier to resume after putting them down for a long time, because the "shape hinting" for vanilla tools (= vscode) is so much better. I use Emacs+nrepl and there are so many different ways to make the toolchain stop working: nrepl version in project.clj, in profile.clj, in deps, in environment, in emacs. This is not specifically a clojure problem but the out-of-the-box experience is really not for beginners. For someone as forgetful as me, after 3 months, I'm basically a beginner again... for Clojure I mentally expect several hours to debug tooling before picking up a project again. 3. add more syntax sugar. Enough languages have learned from clojure sugar, that many amazing things are now regular in other languages: destructuring, for example. The one thing I miss the most from TypeScript when I'm writing CLJS: let thing = 'asdf'; let objectThing = { thing } // { thing: thing } I'm sure there are good reasons to require { thing thing } in clojure but after several years of TS, that's my favorite sugar.
- More Rich Hickey talks (maybe not likely but I will ask anyways)
- Better integration with Java. as Java is evolving, Clojure must keep up with it and not feel like it was designed for java 1.5 or whatever it was. Make interop between Clojure functions and Java functional interfaces and Functions smooth like butter.
- startup time ;-)
- invest in VS Code support
- invest in well put together bread and butter web tools like Luminus/Kit
- Keep an eye on the innovations coming out of other ecosystems, the Clojure world is too insular for its own good. It is genius, but too dismissive of what other people are doing.
- Python/JS-style generators (ability to code iterators in a continuation/coroutine-based style, sort of like goroutines in core.async). This can radically simplify a lot of collections code.
- Shake the attitude of looking down on devs of other communities. I even see sometimes this sentiment of "do we really want to attract lowly JS Devs to our sacred community?"
- Do not get defensive or dismissive when discussing how to increase adoption. I see so much attitude of like "clojure doesn't need adoption actually! It is good how it is!" and "Clojure's adoption is actually great (it isn't)". This attitude is transparently a defense mechanism but derails productive conversations.
- More big name companies on display in the "who uses clojure?" section. Get some FAANG's!
- Better documentation. I still cannot figure out what a function does in the stdlib just by reading the docs (or looking at the implementation)
- Everyone get behind ClojuristsTogether so we can actually fund Clojure investment!
Make the documentation more approachable to newcomers. I think most devs are OOP devs, and with Clojure you not only have to adopt the FP mentality, but also a very unusual-looking syntax. The documentation is thorough on the surface, but terribly worded. I said this in another question, but Clojure is like a very smart professor with a heavy research background who is a terrible (at times verging on incompetent) instructor. I think more people would adopt Clojure if its documentation was overhauled to appeal to a newcomer, with a lot of additional greatness that more experienced devs can access. It should be like those classic kid/family moves from the 00s: Shrek is hilarious when you're a kid, but it's also hilarious when you're an adult. The examples also need a major culture shift. When I'm learning a language, I look to documentation examples for practical examples that I might use. Clojure docs have way too many examples that are "look at this very niche coding logic puzzle type problem I can solve with clojure!", too much of a show-off section. Overall I think Clojure would benefit from some more humility to appeal to potential new Clojurians. For context, at my company basically no new hires are expected to have any experience with Clojure, but there's also an explicit assumption it will take that new hire several months to ramp up to being a confident individual contributor -- scaled a bit if they've got a lot of YoE. As one of these new hires who talks a lot to other new hires, a lot of the confusion comes from documentation.
Overwhelmingly, the most common barrier to commercial adoption which I have heard is that it's too risky due to the small talent pool of and difficulty hiring Clojure programmers. Chicken and egg problems are like this are hard to solve, but this one has an achilles heel: programmers of all experience levels can pick up Clojure, functional programming principles, and even interactive development quickly, if given the right conditions. So I believe that it's absolutely critical to make the onboarding process for developers who are new to Clojure as FAST and EASY as possible. I'm guessing NuBank has materials and people with solid experience here to provide a solid base. And the work the community has done on notebooks/literate programming tools is stellar and just begging to be applied on some world-class tutorials on clojure.org! Imagine if quick onboarding of programmers became a strong part of Clojure's brand, something that's bragged about on the front page. This would make the process of hiring programmers to work on Clojure projects much less painful, which I believe would increase commercial adoption. And it would have the added benefit of making learning Clojure more appealing and feasible to programmers in non-Clojure shops, which further increases the hiring pool.
- Focus clojure.org and clojurescript.org even more on brand new (or curious) users. The sites already have a lot of good content, but it's buried and can be hard to find. Much of it focuses on being technically detailed and accurate as opposed to providing just enough detail to get someone going. Check out ruby-lang.org for a great example, but to be more specific - Lead with some small code examples just so people can see the language. - Allow people to try out code in their browser. - Quickly lead them to walk-throughs on setting up a specific development environment, especially editor integration! - Highlight and surface the most popular resources for learning the language - Highlight and surface the most active communities for help. Eg. "We recommend the Clojurians Slack" for brand new users.)
- Make using Javascript libraries in ClojureScript as simple as it is to use Java libraries in Clojure. Most of the pain in that, right now, is related to build difficulties: fetching and including dependencies, modules/namespaces, and externs inference. The work on externs inference and foreign libs has been a huge step getting there, but it would be extremely helpful if tools.deps (or plugins) could help with the download, including/linking, and bundling. Using NPM
3/2/2022 2:02 AM - Better onboarding experience on website, newcomers-friendly docs, blessed libraries
UX, designers and a huge attention to incoming developers and their unforeseeable nuances. It was horribly hard to get started with Clojure coming from no programming background, and the terse, dry official documentation still angers me to this day. It has always disrespected my lack of background knowledge and just assumed that if I'm interested in Clojure I for sure can handle Java and programming language design abstractions. No, I'm a beginner. I need a beautiful website (to show my friends and to feel empowered that whatever I'm investing on is heading towards the future, and not stuck somewhere), with rich, well explained, step by step guides and instructions. Most of ALL, I need solid opinions on what to do with all the libraries and how to achieve stuff that is pre-packaged in other languages. The book that unlocked me was Clojure Applied exactly because for the first time someone told me what to do before I could actually understand all the implications for all the parts. I still carry it around with me just for the emotional support it gives me.
In a power-law environment like software ecosystem, it's hard to change the tails. But two things come to mind, one obvious and one more speculative. The obvious one is to continue increasing resources for people wanting to try Clojure. Documentation and tutorials, yes, but also concrete examples (e.g., highlighted projects, use cases) beyond the beginner level that demonstrate the power. For instance, while we lispers love REPL-driven development, even experienced folks in other spheres are not quite hearing the key distinctions ("Python has a repl..."). Similarly with immutability and functional thinking. More speculatively, I see Clojure left out of the kind of default list of languages supported by tools or platforms. (Recent example just yesterday: Tabnine.) While we can't fully control that, it seems that it would be good, as a strategic move, to encourage people to provide Clojure/ClojureScript clients/implementations/etc. for such things that put Clojure "on the list".
Generally I think just continue doing what we're doing - i.e. being a friendly and welcoming community, producing good principled outputs. We have a number of developers who learned clojure after joining our team; all have been surprised at how engaging and friendly and respectful everyone in the community has been. A number of these developers are also female which is only notable because their negative experiences of other online communities were not felt here. In all cases that I know of they were delighted to find their feedback and contributions positively received. One other small point, I have found a few old but well used libraries have been neglected recently, so generally ensuring that in cases like this they can be maintained, under e.g. clj-commons or a dedicated maintainer. If more people can step up to do this that is helpful; I have in a few cases tried to facilitate this myself.
I would say, increasing the appeal of Functional Programing compared to Imperative Programing. I like how Rust have a "Learn" section on it's website and provides "The Book" online. "The Book" greatly introduce you to Rust, incrementally introducing more advanced elements. It helps selling the upsides of the Rust language compared to other languages. The Clojure official reference have technical reference for it's features, but feel disconnected. It doesn't provide a good progressive read, incrementally adding to the reader knowledge and understanding of the language. The Clojure official reference focus on the REPL, and seems to miss basic stuff like creating a project, adding dependencies, building and exporting an executable. I dislike that it redirect to 3rd party tools like Leiningen for project management, which seems basic tooling intrinsically connected to the language.
Lower the barrier to entry by creating better "one-click installers" for all operating systems, which also install missing Clojure dependencies, e.g., Java, PowerrShell and .NET for Windows. Create more complete "frameworks" for web development à la Phoenix for Elixir, Nerves (IoT) for Elixir, etc. Write better guides and tutorials for beginners and intermediate programmers to transition to Clojure. Encourage the community to gather in one place; at present communication is rather fragmented. Rebrand Clojure to get rid of the common trope "Clojure is a programming language for "grumpy old programmers." Dispel the idea that Clojure is more difficult to learn than other programming languages. Distance Clojure from Java (the language) by emphasizing that the JVM is "just" one of many implementations, in addition to CLR, JavaScript, BEAM
Get big companies to use it and advertise it, and a lot of startups. It is a really good technology. I think alot of companies have doubts because many of the popular libraries have few stars on github and many times only one maintainer. I think I'll start contributing more to important libraries. Having open source libraries with some companies behind them and not just taoensso or thheller (who are fantastic maintainers) would be healthy for the adoption of those libraries and technologies and not making the developer feel like they are taking a risk on libraries that risk being deprecated or risks loosing its only maintainer. Clojure is however the best language I've ever developed in. With the best internal and external libraries I've seen. I've tried multiple technologies I keep coming back to it.
I think there has to be a definitive tutorial to getting started with repl driven development straight from the text editor/ide (all the main ones) and using the cli tools. It should include setting up clojure-lsp and clj-kondo as well. The tutorial should run users through building from the ground up a real life, fun app that hits on things that make Clojure joyful and practical. Making the cli commands easier (not just simpler) to understand will be needed too I think. After the tutorial, link them to Chapter 3 of Clojure for the Brave and True and direct them to the Clojure Slack for further progress. Also continued and increased support of clojure-lsp and clj-kondo and absolutely everything else necessary for better static analysis to mirror the direction of the rest of the development community.
This impression may be incorrect but my initial impression is that it is comparatively harder to find answers to Clojure-related questions in StackOverflow than for Ruby and Python. Perhaps the number of Clojure-related questions and answers on StackOverflow relative to the size of the community is the same but I also get the sense that the #beginners channel in the Clojurians Slack is much more active. I think for some beginners, being able to ask in Slack lowers the barrier to entry for some but others who are hesitant to ask questions (it's something I'm working on but I know I'm not the only one) and prefer to try to see if a similar question has already been asked and answered, it might increase the barrier to entry since it is harder to search in the Clojurians Slack archives.
I'm not sure I see that as a primary focus. People who "get" Clojure and enjoy coding in it will, people who don't, won't. It would be lovely to have a larger community but I'm pretty happy with the community we've got. However, it seems like the primary thing that is attracting people to a language is how many "cookie cutter" solutions are already implemented in that language. "I want to run a topic model and Python has a plug-and-play library so I use that." That is somewhat antithetical to the Clojure philosophy, but given that Clojure is such an efficient language to code in this is something we as a community might be able to provide more of. There is also a dearth of really good resources for beginners, which makes that initial learning curve steeper than it has to be.
Increase the number of packages and their accessibility. Examples: For science applications, the lack of a standard solution for plotting (like matplotlib) is a huge problem. Oz etc is cool, but the time to first plot is high compared to similar libs in other languages. Clojure would be a compelling language for simple game dev, but there aren't obvious rendering libraries. Something like Love2D in clojure that allowed you to leverage the full power of asyncio and the clojure state model would be a game-changer. All clojure is missing to do that is a good UI/graphics lib - lots of hunting and all I can personally find is a choice of lots of ugly tradeoffs. Perhaps all these libraries are out there and easy to use - if so then discoverability is the real problem.
It may not be compatible with RH/Cognitect's avowed position on open source ('I gave you this gift; you are not thereby entitled to anything else'), but if there are ways to help people feel warmer and squishier about the core team, I think it'd help a lot. Alex by himself accomplishes a lot of that, but more would be useful. Is the core team obligated to do that? Certainly not. Does this matter to the usefulness of Clojure as a tool? Not in the least. Would it help adoption? Probably :) Personally I would really love to see some more talks from Rich; his talks drew me and a ton of other people to Clojure, and have given me a great deal of insight, and having new ones more often would be lovely. Again: not an obligation, just something I'd love to see happen.
2/23/2022 3:12 AM - More modern command line and docs, startup time, embedded blessed formatting, IDE support
Simplify the clojure command line interface and documentation. It feels archaic. Improve startup time (including when using tooling, ie nrepl). Heavy investment in clojure-lsp, clj-kondo. The next thing the community needs IMO is a tool like gofmt for clojure. It will be more effective if it gets an official blessing and ships with clojure. If it does not then we will just have what exists now, which is a couple formatters (cljfmt, zprint) and 2 main editors (Cider and Cursive) which do not ship with the same indentation/formatting rules. Considering how successful Go as a language is: some aspects are controversial (lack of real error handling, no generics until recently, no sum types), but the one thing everyone loves about it is gofmt.
Start thinking top-to-bottom rather than bottom-to-top (provide off-the-shelf tools/libraries that perform higher level tasks such as having the ability to run 4 CLI commands and get a running GraphQL HTTP server up rather than having a bunch of libraries out there that still need to be assembled somewhat manually). But don't get me wrong: I wish we never do that. The Unix philosophy where each project/library does one thing and does it well is something that differentiates the Clojure community from the NodeJS one for instance and this is why I think it's easier to pick Node.js at first but then may well get you a mess while Clojure and its community has a steeper learning curve but infinitely more rewarding in the long run.
Produce and circulate more tutorials and examples of idiomatic/intended use of language features. For example, Rich has talked about intending Clojure applications to "flow" values around in queues (maybe now he'd instead say core.async channels), but I haven't ever seen this demonstrated or explained in detail as an application architecture. Similarly, I've never seen an application that relies more than occasionally on the ability to commingle namespaced keys and ignore unfamiliar or irrelevant ones. Without examples to draw from, these are hidden potentials in the language that are hard to unlock and derive value from. Bringing these front-and-center in first-party learning materials may make the value proposition clearer.
Highlight how you are successfully using clojure at Nubank. It's probably the company with the largest amount of clojure developers working on the same project in the world, so it would be interesting to know how clojure is working at that scale. I think there are many people who are sold on clojure as a solo founder / hacker's language who don't think it would not be practical to use as a language in a bigger company. Highlight recent startup success roam research. Case studies that seek to prove that the clojure/JVM story in data science is capable and removes some deficiencies in python workflows. More videos about people's clojure repl workflows. Speed challenges that show how great the repl is for fast feedback loops.
Education and filling out some missing tooling from other languages. I'm not thinking that we need a web framework, but rather it would be good to show that the things another language ecosystem supports is easily accessible or there is a better clojure equivalent. For example, much time in CLJS is spent trying to get npm modules to work (think storybook) but this kind of program could be created in Clojure/Script. But even then, I think most of the time the barrier is more about education. Teaching a stronger mental model, because this was lost on me initially and then once I saw how things were working, everything became much more straightforward. Apologies if this is abstract. This is a challenging question in general.
- Provide useful documentation, lots of libs are plain frustrating if you ever want to do something more complicated as a beginner. - the interesting parts are hard to find, often times they give only trivial examples or way too complex but anything else in between is omitted. Scares beginners away - most documentation and library documentation can only be learned via reading the code which also scares beginners away - most libs require extensive experience in different fields to use it to your advantage. - show people how they can leverage the data-driven part of Clojure to really get going - Clojure and its ecosystem target highly experienced professionals and good learning resources are sparsely and hard to spot
A language lives and dies by its usefulness. Clojure as a language is incredibly good and useful. But the main issues are I can't use it where and when I want. For example, it's a bit shocking to me that I don't seem to be able to use Clojure libraries in my Android app. Clojure on Android seemed to be progressing 5 or 6 years ago, but now seems to have stalled altogether. Is it possible at all to use Clojure in an Android app today? ( https://stackoverflow.com/questions/71362352/compiling-clojure-library-for-android-in-2022 ) Making sure people can use Clojure where they want to, on the platforms they want to be on, and with the tools they want to use, seems to me to be the best way to make sure people use it.
Keep as many as possible of those who try Clojure out. Find out why we lose people and identify the areas where we could/want to change things to not lose them. Improve the Get Started with Clojure experience. Write a lot of How To Do X with Clojure material. Make a lot of material demonstrating the REPL in action. Improve the IDE:s to be more beginner friendly. Evangelise the Clojure REPL in non-Clojure settings/conferences/podcasts etc. Get Rich Hickey on the stage of many non-Clojure conferences. Have Rich Hickey visiting many non-Clojure podcasts and video channels. (Drawn from my experience with suggesting RH material to people and they always come back with their minds blown and eager to try Clojure out.)
Complex question. Maybe one thought is we should support someone who does user testing for a "new" clojure developer. Whatever issues occur for them in setup are things that we should prioritize by setting up sensible defaults for them. I guess I am talking about a "new clojure developer" advocate, who could recommend projects that might improve clojure onboarding experience for new users. I want to keep the "libs, not frameworks" philosophy. But libs are intimidating when you don't know where to start. Problem with "starting" someone with a framework is that it almost always ends up blessing that framework as the "correct" way to do something, despite it being meant as a training wheel. It is a hard problem.
Dramatically improve error messages: Rust and Elm prove that error messages can not only be helpful (point to the error) but also increase developer skill and understanding of the language overall. I also think that given how generous Clojure is with its core abstractions, a lot of work could be done to tighten the places where those abstractions don’t work (such as set functions accepting non-sets or keyword doing literally no checking that the provided string is a valid keyword). I understand the compatibility and stability guarantees that the team wants to provide but I guess I don’t agree that those are worth more than removing core library footguns which are a constant source of new developer pain.
More Clojure conferences, but that maybe just a Covid thing. Bit more support for ClojureScript maybe, in the space now dominated by TypeScript that would help. I think supporting the companies using Clojure to build excellent software—they are doing quite a bit to promote Clojure. I would love to see more synergy between Clojure and Datomic. I do realise that those are somewhat separate entities but it's a "hidden" superpower available to Clojure developers. Some of those things are gaining a bit more traction with other open source efforts in the field like XTDB (nee Crux). There were some interesting ideas around this like Ions—but the current situations could've been a bit more transparent maybe.
Increase interop and hosting within other ecosystems, so that people don't have to leave their favorite tools behind. Downplay dogmatism about how functional programming is better and focus on how it helps reduce software's tendency toward over complication and actually leads to a more enjoyable development experience. Further reduce macro usage, so that newcomers can understand code that they see without needing to remember new syntax. Perhaps rename "REPL-driven development" to something that better reflects how unique it is among developer tooling. I too often hear it dismissed as "oh yeah, my language has a REPL too." There have been several alternatives suggested over the years.
Spread the word about Clojure and Datomic to other communities. Build demos of interactive development in the REPL, of finding difficult bugs with test.check, of how data-centric libraries such as aws-api allow for a different kind of discoverability. Give talks at non-clojure conferences, spreading the word of what's different about Clojure. Avoid engaging directly in comparisons with other languages, but do more to get people to grok that clojure is not just a "dynamic language" or "a lisp on the jvm". Rich's message about situated programs was great, but I don't see it making inroads in the discourse (like, e.g. the simple made easy talk did), and it should, IMO.
Clojure on Rails? I kid, but not really… The scicloj efforts might bear fruit here, bringing ML and Apache Big Data stack users into Clojure. Hrmm, a Clojure Commons-like initiative to wrap all those Apache things in nice REPL-y clients and to make for easier interop could be pretty epic. Likewise for public cloud; I am aware of the Cognitect AWS library, but similar facilities for the other clouds might give their users an easier on-ramp. There are probably other academic communities that could be better served with Clojure than what they have now. Working on a commerical project that touches on semantic web space I suspect that field might be among them.
When it comes to Mainstream it consulting Developers like want to build microservices. They don't want loads of library choices they want two or three choices that are well documented and easy to use. Take Python for example it has Flask or Django for web development, and anything else is not so relevant. Until there are popular names that the community recognise as mainstream Clojure will be the odd commercial choice or the hobbyist weekend project. There was a time about 6years ago Id say where Clojure was gaining some traction, but the momentum has gone. Languages like Kotlin or Golang have risen far quicker and clearly positioned to solve some problems
I've been wondering that for a while, I think that new runtime targets might help somewhat (like C++ maybe?). I also think some people would love to see somewhere a side-by-side comparison to other languages. I also think that because Clojure tends to be used by more experienced developers, if there were more learning resources targeting new developers (that specifically identified advantages that beginners will understand) that might help. I sometimes feel that will surveys like these the people asking the questions are only looking for evidence of things they are doing well, I think a second look is sometimes in order.
- Improve the tools to make beginners start paying with a project and its REPL within minutes or hours. - Develop and push standard tools to edit and execute Clojure/Lisp code. Four actions are necessary in my opinion : automatic parenthesis management, slurp, barf and execute an expression. - Develop a reference library for online code editing. - Develop a reference tool to bootstrap projects. On my side I'm used to select my libraries around a DI library (integrant or clip) but it took me years before fluently using it. There should be an answer to the "no framework, select and compose your libraries" approach.
Begin moving toward static typing like, e.g., as in Scala or, better yet, F#. The mess that a project becomes when changes need to be made and a few new devs are staring at tens of thousands of lines of dynamically typed code is the reason we no longer use Clojure. Spec is not even close to a replacement for static typing and Spec is a huge time sync that our devs resisted using. We came from Scala to Clojure and we left Clojure for F#. F# is hugely more maintainable and nobody misses Clojure. We have never come across a requirement where dynamic typing was required. It only creates problems and solves none.
Clojure is a little cult-y. The people who use it are often blindly in love with everything about the language & dev tools or at the very least demonstrate that. Some more guides on how to get started with other IDEs and how to build out workflows for daily development would be a huge step forward ( I'm working on this for Neovim ). Some more docs for a good starting place for web dev would also be good. Something like the Django docs but with a bunch of Clojure libraries mashed together. Wouldn't be a simple thing to do since most of those libraries are open source but the idea is something that I like
Since I got convinced pretty quickly you do not need to do better for people like me ;-) I have no clue how to reach people not like me. For me, I was looking at learning to code and looked at w3.school for php and jquery to get started. Someone I know personally said: that might not be the way to go, take a look at what this Nolen guy is doing with om. I immediately stopped learning php and jquery and was hooked. So from where I stand it is about catching the people who want to learn to code because they want to solve something and telling them that "they are doing it wrong" without putting them off.
By far the biggest thing would be to come out with a high quality set of tutorial videos on going from nothing to a working dev environment. Assume your users don’t know Java and don’t use any clojure-specific jargon unless you explain what it means with motivating examples. It took me 4 years to find a tutorial on how to properly set up a dev environment with a working IDE-integrated REPL. This should be introduced in the first hour of the videos. Also please don’t assume people know emacs or vim. Focus on either VSCode or IntelliJ as an IDE because that’s what most of the rest of the world uses.
Increase the pool of available jobs that use Clojure, so I suppose find out why companies don't choose Clojure and solve those problems. I think Clojure is never going to be as popular as e.g. Django/Python because it takes being more experienced to be able to appreciate what Clojure has to offer. Many, many companies do not value experience, and would rather throw junior engineers using Django at a problem until it more or less works. I appreciate that Clojure, its ecosystem, and its community are more geared towards people with a little more experience, and I wouldn't want that to change.
Be less emacs-centric. There's a pervasive message that one "isn't doing it properly / seriously" unless using this antediluvian terminal, and I feel that's a huge barrier to adoption. There exist alternatives that aren't nearly so arcane, don't require such significant investment in setup, don't require perpetual tinkering in order to remain in working order and don't break with such depressing regularity. Clojure requires a substantial shift in outlook for many, and insisting upon emacs seems akin to demanding "now try it whilst hot irons are applied to the soles of your feet".
More interaction with the Java community. More content at general purpose conferences, more advocacy from Clojure creators. I saw Rich Hickey speak at QCon London in 2012 and this inspired a lot of Java teams. Clojure community doesn't seem to engage much with the Java community any more, but this is where there's huge potential to grow the community. I do think shipping spec2 would bring a lot of confidence back to the Clojure community and show big things are still being improved. clojure.math is a really nice step forward for convenience (would like to see more of this).
Particularly on Twitter advanced Clojure users can be quite condescending towards both new users and other advanced users who lack the context they do (not everyone has every problem loaded into their minds at any given time). This makes for unpleasant interactions. I wish people were more patient and understanding that everyone's really busy and dealing with many things in their lives so may not "get it" immediately not because they're stupid but because they have other things on their mind. I've seen new users put off due to the hauty attitude of advanced users.
For me it was cool presentations like: https://www.youtube.com/watch?v=i-ZUN4rmbKI They show how simple the language is to use. Looking for this video I found a ton of others that look interesting. Also anything like Figwheel on the CLJS side but with Expo out this isn't as awesome, it will impress anyone who hasn't worked with Expo. The dynamic nature of the setup is what got me onboard with CLJS as my front end was going to be modern Angular (was even partially implemented!) but seeing Figwheel made me a believer and I'm thrilled with the results so far.
- Support any effort to have proper Parinfer support in Calva (which seems to be a very hard problem). :-)
- Be less dogmatic about REPL-driven development and Paredit (and Emacs) as the only true way; fine to keep promoting the philosophy and show the way, but the tone gets a bit too condescending at times, which definitely puts people of. (Clojure is still a great language without those; after three years I still can't remember paredit keystrokes and it never seems worth taking days off to learn them, when I feel so much more productive with parinfer).
I'm always wanting to swap over to use tools.deps and spec/malli and feel like there is a big on ramp to choosing and navigating them. If we could have easier ways to immediately use tools like these that differentiate Clojure, it could help demo what it can do over other languages. Similarly I love using Datomjc, am sad not to see Datomic questions in the survey, and think having it open source and a first class citizen in the Clojure environment would really help make a use case for how amazing Clojure + data modeling + a great database can be.
Get Rich out of the ivory tower. Get him back at evangelizing Clojure, attending conferences or normal events. He doesn't always need to prepare a keynote. This was the reason for the initial success. Create official learning material, an official path to learn the language, official courses etc. (similar to Scala coursera). Fix Jira issues faster. Get a more open process to discuss design and fixes (like Python Peps, or Java JEPs). Create a Clojure port in Clojure, so people are happier to contribute in their favorite language instead of Java.
Promoting and/or investing in education materials like that of Jacek Schae's, which go beyond the fundamentals of the language are very important in my opinion. Improving the documentation could also help in this regard. Elixir is one of my favorite examples of a community that has a great onboarding experience. One can learn a lot by just reading the guides on their main website. Pointing newcomers to a particular "stack" or set of tools could also help reduce the confusion/paralysis that occurs when trying to navigate the Clojure ecosystem.
In my environment I get the feeling that adoption is limited by employers' fears that Clojure programmers are not fungible and their other/future employees would be reluctant (or unable) to learn the language. So I thinkg, in addition to advertising all of Clojure's selling points, like homiconicity, the power of macros etc., we should also stress that Clojure is "not so fundamentally different from anything else, unless you choose it to be", and that mere mortals are indeed able to pick it up, and do so quite fast with a little tutoring.
On clojure.org, in the getting started guide and possibly the rationale, introduce the user to actual Clojure code sooner. As it stands now, the guides provide many options in terms of build tools as well as different ways of running a repl. This is great, but for a beginner it's quite hard to figure out what to use when just trying things out. I think it would make sense to include a small example of launching a repl or a piece of code using clj in the very first getting started guide (https://clojure.org/guides/getting_started).
Finally get rid of these fancy parenthesis and lispy syntax. Just joking, sorry, could not resist :)
- Invest more in people who contribute to open-source Clojure projects through sponsorship and grants
- I am happy Clojure community sticks to its guns and I hope it will pay in long term, especially: - focus on stability, backward compatibility and long-term view (no is temporary, yes is forever) - prefer solving problems over adding features - think, learn and study; do not be coding ninja - keyboard is overrated
Bring Clojure effortlessly to native compilers. GraalVM is a good opportunity, but doesn't work effortlessly. Piggybacking an incredibly fast language like Rust / C++ or similar would bring an enormous reach in terms of prototyping and and language adoption. Coupling Rust and Clojure in the long term would also mean to give Clojure a seemless effort to bring Clojure better containerization and couple two of the most frictionless languages, Clojure being a fast prototyper and Rust being a hypermaintainable Eco-System
Speaking solely from my perspective as someone trying to learn Clojure as a programming noob. - improve error messages to make it easier for beginners. Error messages are extremely detailed and confusing. - Have more code examples. Getting Clojure is a great book because Russ goes into examples from the core library, to illustrate the use cases and principles. - if there can be a structured approach to building apps that are frequently the “gateway projects” for most languages eg a to do list, that would be great.
Literature that helps newcomers to understand the LISP way of thinking, then showcasing how Clojure builds on that. I found "The Little Schemer" to be indispensable. From there, I was really able to grasp the LISP/Scheme way of thinking, and then it became all the more easier to utilize Clojure. As I see it, there's the LISP aspect of Clojure and the JVM component. Incremental books may be useful here. One handling the LISP aspect, then the second book building on that while incorporating JVM components.
When starting out, I needed something that would show me how to do things that I could easily do in other languages, such as debugging, breakpoints, the repl, running code while paused on a breakpoint, etc. This was very hard to find at the time, and a simple guide of "how to get started and do X" if you come from a variety of other languages I think would be invaluable. Clojure is in a niche position in that it is very rarely someone's first programming language, and it should strategise around that.
Have clearly defined example tutorials for standard projects like:
- How to create a basic rest server
- How to create a basic SPA
- How to create a cli client It was very hard to find “the best” way to do things when I first got into Clojure.
I know it goes against the principles but when you first start with the language, you want to just see it in action with a reliable setup. For example, when starting with react, it takes 2 minutes to have a basic project, with Clojure it takes at least 2 days
I mainly develop with clojurescript, and switching to clojure has been hard because the tutorials /stackoverflow answers assume that I know Java, but I don't know anything about Java. This makes sense given that most of the community probably developed java apps before coming to clojure, but for someone who has never used Java it can be difficult. Same goes for clojurescript, but javascript is much easier (has better tutorials) than java so it was less of a problem.
Hold regular events with talks published to YouTube. Produce something beginner-friendly, at the level of Clojure for the Brave and True which shows a couple different ways to set up editors (Emacs with CIDER, Emacs with Prelude, IntelliJ with Cursive) and covers up-to-date idiomatic approaches (transducers, etc.). Build / fund a Web3 client library in Clojure. Emphasize Clojure's performance — the core data structures are incredibly fast, and the style they enable leads to some crazy results!
Get Clojure and Lisp in to academic institutions as a nice alternative to OOP languages for real world business use cases! I believe a lot of people go out of universities believing Lisp to be a more academic language and that OOP languages are the way to go in businesses. Microsoft and other companies spend a lot of dollars advocating for their development platforms, spreading the idea that their OOP domain driven, onion architecture stuff is the holy grail of business domain development.
Build compelling projects. While the job market for senior Clojure devs seems pretty good, junior and mid-level developers don't seem to have the variety of opportunities. This can be improved by helping developers advocate for the use of Clojure in their current workplaces. It can also be improved by helping more junior devs "level up". I'm not sure how to go about this except to provide guidance/examples that illustrate the differences between "junior" and "senior" approaches/solutions.
- keep making Clojure easier (tooling, error messages, tutorials) - support projects such as ClojureBridge that actively address newcomers of diverse backgrounds - reach out to non-programmer groups (geographers, musicians, various kinds of analysts) and teach Clojure as a friendly tool of dynamic exploration - keep exploring fields where Clojure could shine and make complex things simple (e.g., distributed computing and big data) - improve interop with popular runtimes (e.g., Python)
- Ease of tooling for newcomers. Atom is a good example. Its a free editor and has a good parinfer implementation, but not many use the editor. If VScode were to have good parinfer implementation, I think it would lower the learning curve significantly. - Another good option would be more content for beginners. Very basic learning and how to get things setup quickly. - maybe a package script where it downloads all necessary technology to get clojure up and running. (more tooling ease)
Clojurescript docs in particular are very patchy. the Clojurescript site github has major issues untouched for years, pr's that go uncommented for similar time. The site also focuses on clojurescript cli too much. I would imagine focusing on a typical js web developer who has heard clojure is worth a look. so probably an official tutorial that uses shadow+reagent on the site would be ideal. those tools/libs may be transient, but they seem far the most common use case for some time.
Try and write stuff in "plain English"... I care more about it being understandable than 100% theoretical/academical correct. If you want adoption then you need to speak to the average developer (which by the way haven't studies all 100 dialects of lisp and read "Structure and Interpretation of Computer Programs" or one of the other "holy grails" of books for "real programmers". TBH this might not be something the community can lift alone (without the organisation behind Clojure).
As a newcomer it feels very confusing understanding how to get started. Leiningen vs. deps.edn/tools etc totally didn't make sense to me. I had no idea what the difference was between these. Leiningen seemed much more straightforward to use. It also seems to be (maybe I'm wrong) the old build tool used in VS Code which is the only IDE that seemed straightforward enough and free. I did try setting up emacs but that was a disaster to try to get going on windows for me.
More visibility into roadmap for Clojure and Datomic. Keep nurturing the vibe and values of the community. It's special. Communicate the side-effects of learning/using Clojure. It has changed how I design and write software in a big way and I don't think Muggles understand how powerful that perspective is for creating high quality systems. A good example is that immutable data is very easy to cache since it's never invalid - this is much harder in other languages.
Advocate Clojure adoption in the enterprise environment where criteria such as ease of maintenance, and thus maintenance costs, matter in particular in contrast to the Java world for instance in the financial industry where those systems have completely gotten out of hand since the nineties. Clojure can shine here via its terseness, i.e. less code to write, less code to bugfix and, most importantly, less code to read and understand for the future programmer.
The hardest thing for me in Clojure was to figure out whats the best way to do something, since there are so many. And that's a good thing but it's very confusing for beginners. So there is many ways to start a web app, many ways to build your applications, run your tests etc... Also I believe there should be more content of Clojure on youtube, people learn a lot with youtube tutorials and the ones that exist are very good, but I think quantity matters.
I think it's hard to demonstrate interactive development to people who have never done it, but an emphasis should be placed on it since it's so valuable. I also think more could be done to publicize some of the neat projects we have in Clojure that never seem to reach the outside world. Datalog is extremely nice, but only XTDB seems to be prioritizing an HTTP interface and even then it uses EDN which will be foreign to people not familiar with Clojure
Perhaps easier materials that everyone can understand, even people who are just starting to know what programming is. I feel like all stuff expects you to know what bash, terminal, runtime, and stuff like that are. This is terrible for someone who doesn't even know how to open a terminal, and those are the majority that will learn some OOP language at the same time they learn about other aspects of computer science. And they rarely will switch.
For beginner programmers, setting up DEV environment should be easy. - Node.js bundles 'npm' package manager. - Flutter/Dart also bundles CLI tool to manage flutter itself and package manage. So beginners can easily start learning Node.js/Flutter by setting up their first project. Clojure also has lots of great package managers, interpreters, linter, test runners, but there is not bundled package(installers) all these batteries are included.
Improve accessibility for young developers. It seems nearly impossible to me for a starter on its own, to be effective in Clojure, in the full stack. There are some tools/templates, ... But I spent a lot of time to set up things up at the beginning, while I needed only an easy-going technical stack. I feel that a luminus ++ could do that, if more promoted and if it was more complete (like tooling on backend also + ready to use deployment)...
There's debate on whether to use clojure.tools.namespace.repl/refresh or not. Would be good to have a standard way that everyone uses and practically never need to shutdown the JVM. So then there's no more debate. Like libraries could be tested and 'pass' as being workable with the reloaded workflow. Java/IntelliJ was very different. I never had to wait and I didn't have to watch videos of experts like Sean Corfield showing us how to do it.
-Support making Android apps -Basically make an Emacs clone but in Clojure. Everyone loves emacs but no one likes elisp and no one wants to write ELisp. (And no one likes learning the Emacs troglodyte key bindings) Emacs that could be imbedded in any JVM app, with modern key bindings that could access the whole java library collection and could be also run in the browser. Clojure whole take over the world haha. But it'd be a big project
The entrylevel in the development must be as low as possible. A Lisp is always scaring the people when they see it, and when you then go on with "yes, you need an editor, maybe intellij with Cursive, but you need a license and it won't work quite well with it. Also there is emacs, which is great, but nothing for people new to programming. Calva and VS Code is pretty good actually, but you have to keep on". That's quite hard I think :D
More best practice documentation. I think the current attitude is to describe the tools and actively avoid "here's a good way to use them". Django does a better job of establishing common needs/challenges and demonstrating how the tools can be applied. This would give new users some concrete flags to swim between while building their understanding & developing opinions. Best practices also helps avoid unnecessary pain points later.
Promote clear and official ways to getting started / project management. New users don't want to spend multiple days figuring out when and how to use boot/lein/clj. Make things work for Windows users out-of-the-box, ideally using a simple installer. (not running obscure scripts in PowerShell, it feels hacky) Get clj on Windows out of an alpha state. Also, despite my criticism, I really appreciate Clojure. Keep up the good work!
Advertise it. My tipping point was the concise & expressive reagent syntax compared to React's verbosity. If I could implement the same thing in twice the lines of code and time, it made no sense not to do it. And I'm quite sure such attractive examples of Clojure application can be found everywhere. Just pick the most prominent/interesting aspects for average devs from the CLJ/S ecosystem and advertise them to infinity.
I find tooling quality and "least surprise" aspects, and just the general friction of Clojure development versus alternatives that are out there the main barrier to me using ClojureScript for new projects. I routinely see things that in my opinion aren't as good as ClojureScript gain popularity and I'm pretty sure it's because of corporate backing, branding, presentation and the quality of tools and quickstarts, etc.
- More frequent releases (even if just bugfix patch versions) to imply a sense of speed and healthy growth * No -alpha16-rc12 like "definitely not production ready" releases all the time * Stop maintaining silly legacy undocumented internal implementation details because "what if someone depended on it" at the cost of improving performance * Stop deifying Rich Hickey as he's not a friendly face to front the community
Clojure would be a awesome fit for machine learning and data science. Python sucks for this and Clojure could take over the world by implementing high quality bindings to well known ML libraries and backends. Then later on, create their own. Neanderthal etc are a great start for all of this but they need to be got easier to approach, they need help. If we manage to conquer this side then rest comes with it.
Clojure is self-selecting. People with experience choose it because they see value that Clojure brings. Junior developers choose Clojure after seeing amazing devs with experience using it. I believe that many junior developers are not choosing Clojure because they are overwhelmed with many libraries to choose from. If Clojure had some framework like Rails that allows newcomers to skip evaluating many libs.
Lower the language barrier to entry with respect to IDEs, text editors, and other tools. I think this is one of the reasons why JS/TS is so widely adopted, just install VSCode, a runtime like Node.js, and a Browser and the entire stack is at the developer's disposal, Frontend, Backend and Mobile. Clojure reaches the entire stack too, but I guess the gap in ease of getting started in JS/TS is noticeable.
As clojure with clojurescript is very oriented towards web developement. It's not that cliché to say that it needs its "Rails". A framework that a complete beginner (with no programming or no web development knowledge) could use to makes and a website in no times. We already have good and innovative libraries for that, but we lack the right abstraction to bring them all and in the darkness bind them.
Not sure. I think the first steps with Clojure could be a bit daunting but mainly because of the many options for development tooling and the multiple layers involved (Editor/IDE, REPL, JVM, JavaScript). Not a fair comparison, but I recently got started with Rust and the tooling is much more unified and "just works" for beginners. This is obviously more difficult in the JVM and JavaScript ecosystems.
Develop self-learning quality materials. Many of the singular effort are poor and the quality of docs vs. code are miles apart. The examples do not execute/faulty most of the time. Provide comprehensive doc/examples so anyone can follow. Provide more material in regards to the concepts and approached in clojure - there is an assumption that everyone has learnt LISP - not true! Give context.
Beginner-friendly documentation and tools are something that would have made the transition from JS to Clojure easier for me. If you haven't been programming for very long and aren't conversant in the paradigms and ideas that Clojure is built upon, you can get lost and frustrated quickly. This kind of stuff is out there of course, but I found it trickier than expected to find sometimes.
Build out ergonomic contribution channels (see Rust ecosystem for inspiration); Continue reporting publicly on core/internal progress (alleviates impressions of distance and stagnation); Move small improvements along quicker and in general don‘t veer in the direction that Ruby/DHH have been (we need leadership for the language, but I think there’s enough dictators in the world for now)
Showcase success in terms of performance and programmer productivity and explain clearly, that the power of Lisp is finally unleashed thanks to the development of persistent data structures. People heard that Lisp is slow, memory hungry, and that it's only used by academics, NASA engineers, and the likes. A counter negative should be presented concisely and, dare I say, emphatically.
Stop praising it for having a REPL. The REPL is not clojure's killer feature. The REPL is more for playing but not serious development. Focus more on features like fast feedback, TDD, modularity. Thanks that more professional developers care about. Also be more FOSS friendly. Missing a huge demographic by having official channels on non-free platforms (Slack, Github, for example).
Make it easier to create runnable projects for people without Clojure already installed Really utilize clojure spec to make IDEs do some magical things with errors--but also maybe associate that spec with a more human-readable message so people don't get confused when a bunch of spec gets dumped on them for not having the right number of arguments or similar common human errors
More documentation and examples of how to build non-trivial systems - Domain modeling using clojure is still somewhat challenging, how do we properly define a "Ubiquitous Language" using clojure keywords? - Code structure recommendations for larger systems like, for instance, the Polylith recommendations. - Examples of how the Clojure gurus approach building real-world systems.
For more adoption I feel like batteries and "opinions" included frameworks need to emerge. I like how many things are unopinionated and you can pick & choose how you do things. However for mass adoption something working out of the box with detailed step-by-step documentation is needed. For example I remember making test runner work with clj gave me great pain as a beginner.
More evangelism around the benefits of dynamism and REPL driven development. Flipside, provide more comfort/tools/techniques to help people coming from static languages. Show that with a live repl environment, plus the great work of clj-kondo and clj-lsp, we can get many of the same benefits, plus some other things the usual static analysis and non-dependant types cant do.
There needs to be more resources/support for Front end developers to enable the ability for them to be more creative. I think thats what is holding Clojure/Clojurescript back from getting widespread adoption. There are many examples of how Clojure can handle data, etc... but not very many examples of how CLJS can be used by UI/Frontend devs to develop creative UIs or apps.
A "Clojure in Production" company listing to show how many places use Clojure to show it is not as fringe as people think it is, so we don't get the "we won't use Clojure as we can't hire Clojure". Another option might be Clojure Training templates, for helping companies bring people up to speed well; something similar to a ClojureBridge but run internally by companies.
We can be more public, show which companies use it and what benefits do they have by Clojure. It's always the hardest when you first introduce Clojure to someone. Once they try it for a couple weeks on a project, they start to see the value. However, it's super hard to convince them at the beginning. Developers are thought the wrong things, it's hard to erase those.
Celebrate commercial successes with Clojure. Clojure's biggest weakness is still that it is a small language. Celebrating success lowers the fear of companies not being able to hire developers, and will make devs more confident they will be able to make a career out of it. Roam research is a recent example. Why did they choose Clojure and how is it helping them win?
I don't know how much "advertising" is done on behalf of Clojure. Maybe it's a lot. But I'm still surprised at the volume of developers I meet who haven't heard of Clojure, and sometimes us engineers aren't the most articulate at selling it as a product. It becomes a talking point for a little bit but mostly just a curiosity. Maybe Clojure can buy a sports stadium.
Provide sensible defaults. Sensible defaults are a way of making things easy without giving up simplicity. I find starting new projects in clojure to be a bit of a pain with deps.edn. Improve the error messages and/or provide better help for working out what they mean. I often burn time on finding libraries; perhaps a place for people to document their stacks?
Promote productive workflow of delivering significant functionality much faster. Clojure suffers from the "curse of Lisp", too many clever variations, it's hard for beginners or even the intermediates to get more significant functionality done much faster. The power of Clojure is not fully manifested. It needs more training for Clojure programming at large
Invest in big data analytics frameworks for Clojure. Spark has driven adoption of Scala, despite Clojure being a far superior fit for data-oriented work in my opinion. Invest more in static code analysis for faster feedback. This is the one area where typed languages have an advantage. The REPL is fast feedback, but not requiring any runtime is faster!
Better docs, more tutorials, more "best practices". I also think that having some opinionated frameworks (like Luminus, but easier to follow) would be nice, because web development in Clojure could be overwhelming after something like Python/Django. And (obviously) we need more success stories with Clojure, that helps in convincing coworkers to try it.
From what I read on twitter/reddit it can be hard to get started with Clojure. While I was very determined and experienced before starting with clojure I can see where that's coming from. It's kind of an attitude shift towards programming to start with clojure, so a little bit of handholding to get over the first few hurdles should be a good thing.
Brave and true site is great, I think he needs to update his emacs dot files. There isn't a great default emacs setup for clojure AFAIK. Not that emacs is great for new developers anyway but the default keyboard shortcuts for Calva will tangle up the fingers of even a veteran emacs user. Maybe they should add a REPL toolbar or right click dialogs.
One on one mentoring events, guiding people through their first interactions with emacs/whatever clojure IDE. Learning a new editor, new programming paradigm, multiple plugins, tens of shortctus plus the REPL all at the same time can be daunting. I still don't develop in emacs (I use cursive), because when I'm stuck I'm usually really stuck.
In my case: make it easier to apply and build in closed private corporate environments. For example - we have a lot of problems with getting desp on a machine without write access to user home dir (where is no .m2 directory and we cant create it). Its a lot of depends on -DEFAULT- maven environment, and there is no normal ways to change it.
Make more Conferences. Clojure need a mascot. Need more workshops with comparison with other languages. To convey interactive development workflow and other development methods applicable to clojure. (Like Build small app in Clojure and then in other lang.) Also need fast-path for Clojure porting. For now is hot topic - flutter with Dart.
Please support borkdude and all his innovative efforts in bringing sci (clojure like) to: - CLIs and devops with https://github.com/babashka/babashka - nodejs with https://github.com/babashka/nbb - osx automation with https://github.com/babashka/obb Perhaps office hours could go a long ways to helping him solve thorny issues he deals with
Put interactivity front and center on the home page. Get users into REPLs with interactive guides and video demonstrations as quickly as possible. The home page feels static and boring in comparison to the interactive and fun REPL experience. Also tease editor integrated REPL experiences, they're a huge selling factor when shown properly.
I find deployment of Clojure (java) application most challenging, and have in the past turned to some other language because of this. From this experience, I'm guessing that improving documentation, examples and perhaps tooling around deployment to make the whole flow of development to deployment easier should increase Clojure adoption.
Work on performance variants via port to Rust (for example). Clojure has to be faster than Java / C# and not just a better concurrent solution to gain attention from people otherwise not interested and using those langs. Commercial adoption is key, so people can work in Clojure vs the ubiquity of enterprise langs in faang type firms.
- make it easier to set up an editor and get started evaluating code - demonstrate complete clojure apps with dependencies. for ex, say I want to code a web server. what libs do I use? the space is huge and daunting. - promote understanding of 'data-oriented' programming (which includes, but it is not equal to functional programming).
Honestly, I think it’s growing at about the right pace. Better case studies of success and/or targeted talks about performance (dev and runtime) will continue to help, but my perception is trying to dramatically speed up adoption runs the risk of becoming noisy blowhards and natural (still exponential) growth might be the best path.
Information that is simple to understand is one thing. Comprehensible information with fun and jazzy presentation and a face behind the ideas are stratospheric Active core/lib contributors who publish their notebooks of struggles and progress, for readers to learn alongside, provide among the most accessible resources in any domain
It doesn't seem like people are too willing to just listen someone talk about Clojure when they aren't already interested in it. Perhaps the most effective way to make someone interested in it is to create more tools that are both useful and have that "wow" effect. Something that's incomparably harder to achieve in other languages.
- Anything to help decrease the "time to productivity" for new users. 2. Improve performance and error messages so that there's less to argue about in corporate environments. The parentheses issue is always going to be there and I'm a Lisper so I've never found that to really be a problem once you have an editor that's not crap.
I would like to emphasize more: - The benefits of amazing Lisp syntax (it's an initial resistance among some developers around me) - simplicity of development / platform (eg against JS world) - backward compatibility - learning Clojure also improve common programmer skills (maybe courious developer will fall in love with Clojure)
I think getting CLR version in sync with 1.11 would expand Clojure in Windows side. As well as some good examples of doing a Windows app with it. I also think a more detailed tutorial of using the clj cli tools would be really useful. I myself had some issues of clarity when working thru it for the first time a month or so ago.
Show people how you can do more with less using Clojure. I certainly felt like the complexity of other languages and ecosystems was intimidating, and Clojure's expressiveness and simplicity helped me avoid picking up pseudo-knowledge like OO design patterns that exists only to deal with the deficits of other programming models.
Invest more in Datomic Cloud Ion features, tools, devops and training. Some of us don't seem to grasp how great a DB this is and ache to get back to regular SQL tooling. What did we do wrong that we miss SQL, is it that we develop our app's DB model like we would develop a SQL DB model, and then we don't grasp as many benefits?
Finish spec2. That it exists is fine, I understand the rationale, but how do I explain to someone "there's spec, but there's also spec2, but that is still in alpha"? They just interpret that as "I should avoid spec". It's a shame that a great idea like spec can actually make it harder to evangelise Clojure (in my experience).
The major hurdle is finding people with Clojure experience. In Brisbane (Australia) most candidates haven't even heard of Clojure so we need to train people in house. How we improve this I'm not sure but raising the profile of Clojure in the developer community and making it seem as a worthwhile skill to learn would be good.
Catch up with React (ClojureScript) Several companies I've interviewed recently use Clojure on the backend, but non-ClojureScript React on the frontend. Seems that CLJS wrappers around React aren't providing enough power in a post-hooks world(?). ClojureScript apps apparently (?) can't make use of React component libraries.
keep up with what other languages are doing, it does feel a little like clojure has fallen behind, 3-4 years ago I would have picked cljs over js every time but now I would almost never think of using cljs because the js world has taken all the good ideas and moved way ahead. Same for the backend though not nearly as much
I wish I had the answer to that. I don't think this will ever be a mainstream language, but it needs to maintain a healthy niche to survive. I suppose I'd focus on the onboarding experience. Clojure is not really a suitable beginner language, but even to the more seasoned programmer it can be really rough to get started.
Clearly communicate that there is an initial effort to understand the concepts, necessity and advantages of Clojure and functional programming (FP). FP languages are not as intuitive as imperative languages, the reasons for this need to be openly expressed to not create repulsion when asked for something for a beginner.
The spec(2) process has been a debacle, it's been so slow to develop, broke so many things (errors got worse), they're obtuse and hard to understand/write. My team has migrated away from spec back to schema, and in my personal projects I no longer use Clojure. Feels like the language has stagnated in the past few years.
Tutorials where you introduce a newer developer to building something with clojure, preferably slightly more complex than a crud web app but not so complex as to be for a overly specific use-case. How do I know if a library is "done" or just unmaintained? Are there community preferences that are used more frequently?
As I mentioned before, providing real-world cases where dynamic typing has a clear and objective benefit compared to a statically typed language (not talking about OO-languages, I mean statically typed FP-languages like Haskell or F#), but also the other way around, when and why should static typing be preferred.
Make everything needed accesible from the homepage. Enhance the docs there published. You need to recreate the reference section so somebody thinking in how to do something specific in Clojure can navigate quickly there: How to do an cond ind Clojure? The navigation should be evident beginning at clojure.org.
I think the Clojure CLI and deps.edn have been a huge step backwards in usability. It has been extremely difficult to onboard newer engineers as there are few blessed paths, at least the last time I tried to switch. Please consider promoting Leiningen and focusing on more important issues for the community.
Better understand /specifically/ what's good / bad with other serious contenders. Go and Rust on the backend, Javascript/Typescript on the frontend. Learn what we can. When Clojure is better for specific workflows, we can share that. Compare two real workflows - one with mainstream tools, one with Clojure.
Whatever is low-hanging fruit to ease getting started for beginners. I've been programming for too long to really know, but error messages could be improved a lot all over the clojure eco system. I have some hopes that spec might help here but it's also a cultural thing/design choice that's harder to fix.
I wish I had an answer. Writing for the web with just a few libs with small api vocabularies is such a relief after the stew of JS "technologies" with verbose code and verbose API surfaces. But I think if you wanted Clojure to be used in this building your best bet would be to level the building first.
I come from The Czech Republic and almost nobody around me is using Clojure. - good online interpreters with suggestions, syntax highlighting and the option to use libraries to try it out - Clojure coding competitions - Clojure certificate - Clojure "tour" - talks in more countries than NA from 99 % :D
Show more real world examples. Clojure to wasm e.g. Babashka to wasm. Clojure to Rust, more tutorials libpython-clj. Better tutorials about Pedestal, Vase. Improve performance on certain libraries. Reagent is to tied to react. There could be agnostic libraries focus on performance. Check pedestal web.
Add a clear and straightforward command line interface to the clj tool. It's really weird and I have trouble imagining how it ended up like this. Improve Windows support, "clj for Windows" has been an "early release version" for far too long; this note itself may be off-putting to many developers.
Maybe put an open call out to the community to get some modern tutorials written on particular topics, topics that rotate every couple of weeks could easily ask social media for new or old topic ideas The best curated tutorials submitted would then become part of clojure.org or cljs official website
Clojure could really benefit from something like the Rust book: https://doc.rust-lang.org/stable/book/ It's a guide first, reference second. This is essential for getting people up to speed sanely. I think Clojure focuses more on references right now, but that's not nearly as friendly to beginners.
Find a way to convince companies that they'll be able to hire clojure developers - my experience has been getting shoved into python b/c the business fears they won't be able to hire clojure engineers. I think they exist, companies just don't get the nuance and look only at the biggest data points.
Hard question. Could look at more around JS replacement language. Getting started with cljs is still hard, and there aren’t a lot of resources in the beginner space there. Shadowcljs does a lot towards that, but some more official tooling and guides for node/react/electron/react-native could help.
Better support for editors other than emacs. Better linting and refactoring tools, debugging and visualization plugins. Improved error messages for newbies or even experienced devs, spec made things way better but still lags other languages. Spec 1.0 as non-alpha release maybe to improve adoption.
More beginner friendly resources for people not entrenched in either the JVM or functional languages would be great. I've found it to be very difficult to find learning resources that aren't targeted primarily at more advanced Clojure developers or that were made more recently than 5-7 years ago.
An effort towards more presence on common developer platforms (dev.to, medium). More introductory tutorials targeted at total beginners that go beyond setting up a REPL, with less 'illustrative' examples and more 'real world' ones, with the standard, boring examples that people are familiar with.
More interactive https://clojure.org/ home page. I think most existing Clojure devs rarely land on that page, however newcomers probably do. It's dull, not interactive, and hard to see the benefits of the language at first glance. Maybe throw in an interactive REPL and tutorial and do a redesign.
In Javascript world I can type: npx create-react-app my_app Frontend or new express app - basic REST api and I’m ready There isn’t really a GO TO starting place for developers first discovering clojure. I had to buy Jacek Schae’s Learn Reitit Course to get started building a basic REST API
The main hindrance to clojure for me at least was the lack of a cohesive web framework like Rails or Django. Even js has things like next. It took me longer than it has in other languages to get acclimated because I had to figure things out from scratch, even when using something like luminus.
Continue making it easy for new folks to get started. A comprehensive tutorial on making a new project from scratch with the CLI and tools.deps would help a lot, I've basically had to crib from GitHub and blog posts to figure out what a project based on deps.edn is "supposed" to look like.
Provide more insight in the future of the language and its core ecosystem, in the form of roadmaps, a more open process for dealing with issues (e.g. bugs in the standard library)... Now it feels very much as if we are all at the mercy of a benevolent dictator whose plans are unknown to us.
Clojure needs a flagship "killer app", the way javascript has the browser, python has data and machine learning. People will pick up clojure when there's an overwhelming and compelling use case. We've just about exhausted the intellectual curiosity angle that's been fueling growth thus far.
Support development of non-JVM hosts, in order to widen the pool of potential users. More "advertizing" of the awesome stuff that happens in the Clojure community, outside of the Clojure community. E.g. we see some new developments make it onto HackerNews, but more exposure would be better.
Ruby on Rails exploded when DHH's "Blog in 10 minutes" video came out. It took a known problem and provided a new solution that blew everyone away. I wonder if showing Clojure solutions to known (and applicable) problems would help to open people's eyes to the power and benefit of Clojure?
I’m an outlier and understand that since I only use cljs, but for me it would be support for host features. Maybe async await, but mainly all the things that are required to support libs like lit html, etc. I’d prefer more of a story around interop rather than the reagent react path only.
Clojure is seen as a language of senior Devs. We are just starting to see entry level jobs for Clojure. If we want clojure to be popular we need more entry level jobs. The reason python and JS are the first language new comers learn is because of how easy it is to find an entry level job.
Have a highly promoted default web backend stack that has a large supporting base or everyone will point you to to learn how to set semi-enterprise grade apps without having reinvent the wheel. Preferably with datomic database to be able to build something meaningful in this new language.
Bootstrapping tutorials is where the FrontEnd JavaScript ecosystem shines, being able to target beginners despite the current complexity of things (which let's face it, is crazy). IMHO, Clojure is at the other end of the spectrum, almost always taking for granted you being experienced.
I am now confused about the extra tooling, not just leiningen now, all this other stuff must confuse beginners. I use emacs, probably a bit too old school for most, need to try Intellij Cursive, but yes better more accessable editor would be good. Emacs repl can be very choppy at times
I've found several people to be skeptical about spec and tools.deps because of their alpha status. The fact that clojure.core itself depends on something that's considered alpha doesn't increase confidence. Expediting the release of spec and tools.deps would make such concerns go away.
Make it easy, as in "install & run" to get a REPL going, as opposed to the current cryptic puzzle of "so what should I install? what even is leiningen? how do you use this? what is all this about choosing an editor? how do I escape the command line & connect a REPL to my editor?..."
Official site is missing easily accessible andtutorials aimed at Java developers on how to get started e.g. build a small REST application or web app using most popular tools and libraries like VScode just to get them hooked. Less bashing on types, which is polarising some people.
Keep the current channels, Clojurians Slack has been an awesome help. I think more tutorials and more exposure to the language and it's strength can really help boost the reputation of the language and help people understand that it's worth the minor syntax hassle at the beginning
Just keep building stuff. Using very selfish definitions of "we" and "community", I'd love to see some new Rich Hickey talks, but obviously this is his choice when/if he's ready to. But they were definitely essential in my personal clojure adoption story, and I can't get enough!
- Some community way of knowing "is this library done and safe, or is it abandoned / out of date" - Easier adoption path for full stack CL(JS) dev - Even more communication out of the core team - this has been improving so please keep up these efforts, they are very appreciated!
Standardize on best practices involving spec. core.spec has been in alpha for years now which has lead to third-party libraries filling the gap. A new Clojure user has to decide between the first-party alpha library or an unknown third-party library which isn't a good situation
tools.deps has made getting a Clojure project off the ground much easier than it used to be, but in comparison to other popular languages, there's still significant complexity if you're trying to set up a project (versus just getting a REPL up and running to execute some code).
I would be more confident in Clojure's future if libraries were more actively maintained. Even active libraries often have dependencies on abandoned libraries, which often leads to transitive dependencies on old versions of upstream deps, even when newer versions are available.
Ensure there is tooling for repl driven development and paredit that is well supported for all editors. Keep making it easier to build and deploy applications. Reach out to teachers of programming languages courses to ensure Lisp (preferably in the form of Clojure) is covered.
I think the lisp prejudices are too ingrained on the wider world. I do not know how to solve that. To be explicit, last time someone saw me using Clojure I was called a "wanky academicist". After some explaining the caller decided Clojure might be different from other lisps.
Stop being so freakin geeky all the time. Show people that writing business code in Clojure is pure pleasure. I have the same feeling here as I had in Scala that many people instead of giving real-life examples show "the most weird way to parse JSON" and feel proud about it.
- A rock solid, beginner friendly, batteries included Web Framework to develop websites / REST APIs (e.g. Rails for RoR or Play for Scala). 2. Many more ClojureScript tutorials, resources and examples on how to share code between JVM / JS worlds. 3. Maybe, WASM as a target.
More/Better tutorials for back-end and front-end web dev. People I talk to in the field typically aren't aware of clojure/clojurescript as an option due to the more popular stacks. They usually are surprised when I show them our work and show them the size of our code base.
Pages that show how to translate common operations in other languages to Clojure would help. For example, here's a page that is very useful for evangelizing Python to Matlab users; do the same thing for Clojure: https://numpy.org/doc/stable/user/numpy-for-matlab-users.html
Broadcast out a bit. I get most of my industry news from Hacker News, and you'd think Clojure was dead. I had to go on the Clojurians Slack to realize there are tons of new releases of libs and a very active community. It's like the entire Clojure community is underground.
More good examples of host interop and more accessible, annotated examples of good architectures. Unlike eg. Rails you're kind of on your own to make architectural mistakes that are hard to back out. More examples of the joys of REPL development, esp when editor-connected.
- Work on an opinionated initial easy setup - comparable to "web development with clojure" for web applications. 2. Work on spec next gen in combination with an type interefernce tool validating spec-out against spec-in & finding breaking changes on a fine grained level.
adoption is a process. Wait and pray for it...or... According to the technology life cycle of Geofrey More, when big companies start adoption and succeed, the rest imitate them. Probably that is a good point to start to look at it and start to motivate Moore's innovators.
Unfortunately: nothing. But that's not a problem. Just stay on track and ignore all the noise around. It takes time for people to see the merit in Clojure but they'll come around eventually. People are slow to change so it's not a race -- it's more like an Ultratriathlon.
Give more talks at non-Clojure-specific conferences on the power of Clojure and the reasons for choosing it over other languages. Getting Clojure into more academic environments would also help a lot - such as having it taught in high schools and higher education courses.
Promote more content on the use of REPL driven development. I feel like a lot of the tutorials are focused on the syntax whereas that's not really the selling point. If I had to write Clojure in a way where I had to start and stop the JVM, I wouldn't really see a benefit.
Improve startup times. It's the first thing people see when coming to Clojure, and they see it before they learn about this weird "repl-driven development" thing. Their first impression is "holy crap, it takes 3 seconds to run 'hello world', and I thought Python was slow"
- Make Clojure tooling (editor support, testing, building, dependency management) simpler. It has so many moving parts that something breaks all the time. - Make utilizing external dependencies simpler. See what Go does: paste a URL into a source code and you are done.
We need to find someone who still remembers what it was like to program in #{:java :scala :haskell :javascript} and who also knows how to write technical documentation and get them to write (map #(str "Clojure for " % " developers" #{:java :scala :haskell :javascript})
It would be neat if there was a consolidated learning path somewhere that takes a beginner through all the things that they might need to learn in order to understand the language. There are a lot of scattered materials out there, so it's tough to know where to start.
I think we are on a roll. Great talks and success stories are helping. The strong move to recognize and fund library developers is a master stroke - I think more of this will motivate the community, lead to improved tools, and further strengthen the Clojure community.
Evangelize outside of the Clojure world. In my experience very few people have even heard of Clojure. Provide examples of “this is how this looks in e.g. Python, now here’s how this would look in idiomatic Clojure, here are the benefits of doing it the Clojure way.”
I think onboarding for new developers could be better, especially if they don't have much development experience. It took me quite some time to settle into a decent development workflow using cursive and reveal. It's fantastic once you're there but it was not easy.
There's a derth of what I would call cognitive models about how Clojure itself, and various libs work. One must usually read the code, and/or example programs, and glean what the code can do. This is inefficient compared to the ecosystems of some other languages.
Continue to invest in evangelization, tutorials, open source, and otherwise lowering the bar for entry and language accessibility. This includes making the "getting started" process easier (starting your first REPL, cold start time, dep management via lein, etc).
It's really great that the community has found ways to fund productive open source developers. We should keep doing that and try to further increase it, as tooling like Calva, shadow-cljs, Babashka, Firefox custom formatters, etc are very important to adoption.
I feel like my dotnet dominated enterprise would appreciate a more approachable CLR clojure. I also struggle with data science flows and integration, I have been leaning on nextjournal/clerk rather than hanami and oz due to the complexities that come with them.
Fix the clojurescript tool situation. It is a pain to integrate clojure with existing code and vice versa. The failure modes are opaque. There is no chance for supporting more modern js patterns like what nextjs enables because of the complicated build setup.
Clojure is still optimized for correctness and - to some degree - experienced developers / people with some lisp background. I don't think the beginner learning resources are there yet. There are some good ones out there, but we are still lacking a great one.
Better getting started guides. Sort out lein vs deps.edn. Clearer repl setup, too many options. Having a full e2e example on vscode people can start with. Both clj and cljs in one example. With tests. Have a good out of the box for cljs on node as a platform.
I don't think clojure can have a wider adoption. This is mainly because of the syntax and the burden of functional thinking which is more suitable to a small portion of population and the rest would prefer more everyday approaches to thinking about programs
Do a better documentation such as Hackage to search functions not only in core libs like clojuredocs do or in third party like cljdoc do but in both at the same time. Also provide some useful tool by finding functions by spec like re-find and speculative.
The community aversion to frameworks compared with libraries will hinder Clojure adoption when compared against the ease of use of Spring Boot. We need something just as easy to create server/side applications with common dependencies already integrated.
I think to increase language adoption, you HAVE to think about new user experience. How easy is to get started with an IDE, how to run a program and friendly error messages go SUCH a long way. Second priority would be to have good examples to learn from.
Be friendly to newcomers, blog and write about use of Clojure in projects. As new tools arise from the host platforms, embrace them in the way that makes most sense to use with Clojure, and advocate those approaches (e.g. Graal/native-image -> babashka).
Sample projects(including best practices) for Web applications, Middleware(REST api implementation), how quickly adapt any backend DB or other Services(SOAP). Cloud specific sample project including(do's and dont's) best practices using clojure tools.
Useful, clean public applications that can be used for a showcase. I decided to overcome my dislike of lispy parens when I saw a very small project that accomplished so very much. IIRC, it was a server-side web dashboard or some sort of visualization.
I don't mind if adoption increases or decreases. A lisp is unlikely to ever be the next big dominant language. And that's ok. It's not for everyone. I want a great language, not a popular one. If it stays technically excellent, I will keep using it.
Document common patterns and best practices to give beginners some default path to follow. (This is a tough balance to strike between centralized dogma and community-driven advice, but right now I think we're too weak on the centralized dogma side!)
Maybe workshops, showcase of some medium sized applications? As in - Clojure is great for big applications, but in my circle we make small to medium sized applications and then Clojure appears like an oversized hammer, to my colleagues at least.
For better or worse we have a massive number of JavaScript devs whose first option after plain JS would be TypeScript. I guess it would be wise to tap into that stream with a great story about using ClojureScript for both front-end and backend
Please, do more marketing. Edit Clojure TV youtube videos in more watchable format instead of dumping the whole 4 hours long uncut edition. Allow subtitles to be displayed in various languages. Foster more educational programs regarding Clojure.
easy tutorial? and for devops tools~ like nix. (I hope that the compatibility of deps.edn and nix will be perfectly transformed so that it can be wrapped in declarative nix. (clojure clojurescript is too long and complicated to learn templates)
Create more documentation about clojure. If you don't work with or are not a functional programming enthusiast, at first glance clojure can scary new programmers and the lack of content online will keep people from starting using the language.
Create resources about real-world code and good practices since there aren't any batteries-included framework with specified project structure (which isn't bad in itself). Promote REPL driven development and make it easier to get started with.
Make some things easier for newer Clojure developers: better error reporting, various quality of life improvements. Something out of the box that makes scripting/cli applications easier without JVM startup time (is this what babashka is for?)
I wish I knew. Write blog posts and give talks on Clojure? The lack of static typing is an issue that always comes up, so compelling resources on what tools Clojure offers to make up for the lack of static types would be very useful, I think.
It's not clear to me how Clojure has benefited from the Nubank acquisition of Cognitect, or how Clojure's stability and long-term prospects have improved. If they have improved, better communication and demonstration of same could be helpful.
From a beginners perspective, I think there are two many steps to getting started. Having done it many times, I still always manage to install clojure or java incorrectly , but I think this is due to having to use different versions of each
Pathom, Fulcro good libraries solve very hard problems should be promoted more. If you want more adoption from scientific community need better story for C/C++ communication, clojure can't handle HPC/GPU computing (and probably will never)
Just making getting started much easier. Currently, it requires a lot of effort to install an editor, REPL integration, etc. I tried to help with https://orgpad.com/s/clojure-tutorial, hopefully we can create more materials down the road.
Best pay in the industry did not motivate devs to adopt it. We need a huge clojure company to promote its use. Like Google go, Facebook react. But actually I am happy not many adopt it bc clojure stays a hidden super power in my business.
Trying to sell Clojure for a customer hits a certain snag point when they look up the ecosystem that is highly fragmented with libraries that are not maintained, so they'll choose a language that has de facto libraries for specific tasks.
Provide some tips or hints for people getting started navigating the library ecosystem. Find key projects that seem unmaintained of that have poor documentation and work to improve them (I’m thinking of the buddy libraries specifically).
Said it earlier, but most Clojure developers are coming from Java. You're making it very hard for developers to introduce Clojure at work without a quality Maven solution. You will lose many shops if you're insisting on clj or leiningen.
I first heard about Clojure at the company where I currently work. I believe that presenting to the community real cases where Clojure is applied and the problems that were solved using this technology I believe contributes to adoption.
Engineer a ray or field that makes every software developer it encounters 15-25% more curious, thoughtful, and willing to take a moment to learn a beautiful way to churn out the widgets, instead of just churning out the widgets all day.
- Allow more autonomy in the community - Allow people to contribute code. - Not everything should go through a single person - Some breaking changes are OK. - Very slow pace of development . Things like spec are forever in development
We should advocate outside of our comfort zone. I think the academic world, the scientific and data analysis community would profit of lot of the tools we have in Clojure, especially if we can leverage the work in python, R and Julia.
Tutorials for more advanced features. Instead of leaving it to random bloggers to write them, it would be great to see those closest to the core team to at least review for accuracy a few tutorials for core and cutting edge features.
Do more local meetups, do more PR events, implement Clojure more often in companies, tell more about Clojure to coworkers, write more articles in social media, write more learning materials about how to use Clojure in real projects
Make working with promises in ClojureScript better. (Something akin to Promesa should be in the stdlib imo. But with somehow the explicitness of async/await. Core.async is flexible and powerful but the cognitive load is too high.)
Explain the lisp philosophy better. We keep seeing complex web-frameworks pop up, while a simple hoplon+chord+figwheel-main solution scales much better and puts less cognitive load on the programmer. Again; components vs mount.
Deprecate clojurescript and stop preferring clojure wrappers for existing Java libraries. CLJS quirks and needing backend devs to work on the frontend have burned whatever goodwill clojure had with managers in orgs that use it.
My biggest struggle has been figure out how to structure bigger/more complicated projects. We don't have good guidance in this area. There's no Martin Fowler -type for clojure. I want to see books like PoEAA, Clean Code, etc.
I don't have good ideas here, but I think the first step is to talk more about it. In my opinion, it is important for known name companies to step up and talk about their adoption and use of Clojure and how it has helped them
Clojure tools were sorely needed, but now that they are released I still cannot figure out how to use them. Documentation needs to excel in this area above any other imho. I'd also like to see a core.async v2 that is simpler
Killer apps are often what drives adoption of non-mainstream languages. Think about what Rails was to Ruby's rise, or data science toolkits for Python. I'd love to see Datomic, or something like it, become freely available.
Have a central place where all the libraries are listed and where libraries that serve the same/similar purpose get a matrix of their strengths and weaknesses, so it becomes easier to see, what I need for my requirements.
A simple (RAD) full-stack web framework that gets out of the way. With integrated linting support (clj-kondo) for any macros it uses and a default path for provisioning and deploying it on simple infrastructure (VPS etc.)
More tutorials, less "opinionated" decisions, less pushing of a specific "core" solution like Spec instead of Malli, or Core.Async instead of Promesa (specially for ClojureScript). Also, stop bashing on other technologies
Talk more about Clojure in Functional programming communities and other developer communities. And show that it is a general purpose language that is not that hard to learn after getting past the parentheses aversion.
Many projects haven't been updated for a long time, like the various authorization libraries, and it's difficult to tell whether there's a new alternative available. Not really sure how to best deal with this though.
Not sure how, but I wish more companies would use Clojure, and hopefully more worldwide. Is there something we could do around helping companies hire remotely, in terms of managing the legal stuff and benefits, etc?
I think we are getting much better at flattening the learning curve with good introductory content, but we can always improve on that. I also think we could improve the I've-done-a-tutorial-now-what level resources.
Make it easier for people who don't know Clojure (or Lisp in general) to figure out how to set everything up, with a repl, a nice debugger, etc. Telling new people to just man up and learn emacs is not a good idea.
Make it simple to start a new application (e.g. Leiningen's lein new app operation). Right now, I copy/paste deps.edn and each time I start a project, and the directory setup is all manual. Improve error reports.
Please improve error messages and especially stack traces. I do not need or want to see clojure compiler files in my stack trace. Please stop the trace in my code rather than continuing it into the compiler layer.
Clojure requires a good understanding of the host platform. This is a big ask for folks that come into it outside Java or JS. Clojure under Windows is hard--need Clojure CLR as a full member of the language family
I think Lisps will always be a marginal language, but lowering the barrier for beginners helps. Leiningen is pretty straightforward, but tools.deps seems complicated by comparison. I’ve actively avoided it so far.
- Visibility and communication. Recent efforts to improve this (e.g. Clojure Deref) are welcome and very appreciated. 2. Squash longstanding bugs. People see unaddressed issues as signs of health in a language.
Redesign of official websites(clojure.org and clojurescript.org) by highlighting (perhaps on the homepage) an example of code + interactivity (REPL, etc) and/or a short video presentation of the REPL workflow.
Advocate for functional programming in all languages. Target existing developers. Start them moving on a path from typical Javascript or Python or Java to a functional style. Then let Clojure speak for itself.
More tutorial-style materials on how to achieve: effective information modeling with plain data common operational needs of applications (deploying to lambda/container runtimes, instrumentation, AOT compiling)
A unified tooling system akin to Rust's Cargo would go a LONG WAY. The available tools are so scattered apart that ecosystem richness and growth is impaired, which is visually apparent to would-be clojurists.
I think people still fear parens, not so much aesthetically but in it's implication for editing code, there are already amazing tools for editing lisp likes, but maybe there is more we can do in this regard
My impression is that the current direction is good. Keep building a healthy community, keep funding open source developers, keep funding language development, events, etc., keep expanding into new niches.
The more success stories the better, I think - I recently found out that two tools we use at my tiny startup are written at least partly in Clojure(Script). Making these things more visible could be good.
It's not very friendly to new programmers. And I think most people "settle" for a programming language after a few years of coding. So, in my opinios just making it more begginer friendly will help a lot
To focus on tutorials that focus on functional thinking and composing functions. Always have easy examples. Mentality-wise to avoid giving the impression that "we are better" or "the others do it wrong".
Let go of ego and be more beginner friendly in our attitudes. Have more beginner friendly resources. Show that we are an accepting community by having people of all colors and genders in the spot light.
Online resources with cookbooks in how to tackle common problems in programming, I think would help people have a better feel for the language and what is good and different about it compared to others
We can focus on being welcoming and inclusive to newcomers. We can avoid falling into the stereotype of being a bunch of experienced programmers who believe Clojure is only for experienced programmers.
Publishing high quality tutorial for beginners showing Clojure capabilities and the sets of tools available. Create learning path for beginners to drive them about what to use depending on their goals.
Survey businesses (not developers!) which use Clojure about the biggest language-related challenges they face. Then, bring the community together to build quality libraries which address those issues.
Domain modeling and project directory structure need more clarity. People get functions and REPLs but get scared when making a big project because there is not enough hand holding for these two things
Pay better attention to the little things and make things as effortless as possible. For example, the CLJS site, last I checked, still suggested workflows that have long been obsoleted by newer tools
promote cljs and reframe to web developers (especially react devs who already understand and appreciate functional programming, unidirectional data flow, etc) as a "gateway drug" to the clojure world
I don't know. Clojure is great and solves a lot of my problems. I came to it a long time ago, and I'm still here. Maybe release spec and publish a "so you think you want static types" type of guide?
Haven't used Clojure much. The syntax ->>, ->, #, ... other things keep throwing curve balls. The tooling interop with IDE, or emacs and leiningen is great and easy to use. Syntax is my main gripe.
Continue the effort on standardizing the tooling (deps is great !) for easier onboarding and support the clj-commons projects so we don't scare away users with the amount of unmaintained libraries.
integration between experimenting and prototyping at the REPL vs loading from / saving to / running existing code in an IDE is disconnected. most likely my own problem that I need to research more
Perhaps more info on developing tradition app with modern tooling so db sql backed working with those libraries a lot of focus on datomic style databases which you may not have the option to use.
Keep libraries alive. Funding of libs. Make quality libs from the ground up, don’t always depend on some Java lib. Be nice and responsive to people suggesting fixes/patches to the core language.
I don't have specific ideas. Clojure adoption has been growing steadily if not very quickly, and I attribute it to the quality of the language, ecosystem, and community. Let's keep it that way.
Continue being awesome! Potentially work to provide more context on project landing pages/GitHub READMEs for folks who aren't already familiar with the domain that a tool is meant to help with.
Open source Datomic. Somehow Clojure needs to get more of a critical mass of developers to embrace it. Its kind of in its own Ghetto now. No one at my new company has it on their radar at all.
Providing a good starting point for new Clojure developers of varying experience levels. In my opinion the paid courses and books are still the best way to learn Clojure, which is unfortunate.
I think Alex's engagement has been excellent. Combined with Fogus's recent efforts to actually clear out ancient tickets and progress the language forward a bit; get more Millers and Foguses.
Work on textbooks for teaching functional programming and design concepts using Clojure as the language. Connect with university professors to try and adopt these textbooks for their classes.
Maintain and improve library ecosystem for common scenarios, specifically for core.async + CSP style. HTTP, MongoDB, RabbitMQ, BigQuery, BigTable - all focus on synchronous or callback style.
More content - YouTube, hacker news, blogs etc anything which will help make Clojure feel like it’s not a niche language. Resources for getting started, both for tooling and app development.
Dynamic dependency injection (into repl), Ease of use on windows 10, running both clj and cljs repl in calva easily, having resources with answers instead of having to ask (I'm shy on slack)
Visibility of exciting or interesting projects. I remember people being very excited about projects like storm or overtone, we need to continue seeing more new examples to sustain interest.
Installing and using Clojure should be better integrated into standard tools, e.g. using curl to run a bash script to install Clojure is bonkers. Use, apt, dnf, etc. And open source Datomic
Clojure has the potential to be the bridge to the sql world. We missed that boat. The potential there. Javascript has library culture and framework culture. Clojure needs framework culture.
Build an interactive Repl into clojure.org. Build tutorials into it. The website feels static and boring to read and to use, which is inappropriate considering Clojure is dynamic and fun.
We need to make documentation more friendly than it is, especially for junior/new programmers. Most READMEs for popular libraries assume knowledge of similar libraries in other languages.
Mentorship especially around tooling which is hard to learn by oneself without seeing how other people work. Maybe experienced Clojure developers should be sponsored to mentor newcomers.
A 'default' application framework, similar to Spring for Java or Rails for Ruby. Building your own framework by composing libraries get olds fast as does not scale well to larger teams.
Definitely facilitating beginner developers. The language, tooling and library ecosystem feels more geared towards experienced devs, either with the language or the underlying platform.
There is less and less "Clojure is fun" contents being worked on and/or advertised. The community is more mature, which is good, but maybe less attractive for a younger/casual audience.
Improvements to beginner IDE/REPL documentation. I didn't want to learn emacs-proper even though I had previously used Portacle for Common Lisp and felt constrained by available guides.
it's not the community's responsibility to increase adoption. Cognitect can apply well studied growth techniques – law of focus, investment in brand, better dev rel, talk to your users
I think Clojure's biggest hurdle is the software rot in libraries that don't have organization sponsorship or dedication. I plan on creating new libs myself soon to help address this.
Improving the Data Science ecosystem. Keeping existing libraries and frameworks maintained and improved over a long time -- many are dying a slow death without an obvious replacement.
Lower the entry barrier. There is an analysis paralysis problem on choosing the first tools. I mean only for a web server one have to make 3 decisions, on server, router, interop lib!
- More articles/examples targeting new users. 2. Better story with types. 3. Better handling of errors. 4. Clojurian slack is very useful but probably feels intimating for new users.
Make hello world simple. Provice common toolbox so people dont have to google which editor to pick, which dependency tool to use... Make one set of recommendations as best practices.
Offer a Tutorial in the official documentation teaching how to build something from start to end, covering best practices and advantages when approaching the problem the Clojure way.
Write a book on how to design and build a full-scale enterprise application thinking in Clojure. This book should show how to approach management of complexity of solution in action.
Re-iterating why using a simple language matters and why complex languages with complex type systems are not the answer to writing software that is easy to understand and maintain.
I don't feel qualified to answer this question. I view myself more as a "follower" than a "member" as I haven't contributed much yet, just a couple of doc-fixes in some libraries.
More resources for intermediate-level users. Less explaining how cleverly clojure and various libraries work internally. More practical examples of how they are used in real life.
Some more beginner friendly tutorials and guides would be great.. it can feel a bit intimidating coming into the Clojure world since most developers are very good and experienced.
Improve "getting started" literature to target non-expert developpers (ala FrontEnd Javascript ecosystem where it's readily available for each and every framework and type of app)
No idea. The language is great but people are afraid to learn it because it’s different, they don’t get the benefits, and are more confortable repeating the same daily struggle :)
There's FUD centered around Clojure being unmaintainable, lack of typing and difficult to hire for. More case studies of larger enterprises would be helpful targeted at this FUD.
Make it easier for newcomers to set up their editors. Use more stackoverflow and less google groups and Slack. Finish libraries instead of abandoning when you are half way done.
Actually write documentation and guides for the things you build. We tried the new dependency/build tool, but it's basically worthless since you have to do everything yourself.
I think of the docs at first. Because https://clojuredocs.org/ is more samples than docs giving explanations. There's sometimes too much guessing before confirming in the REPL.
Maybe it could be more obvious how we would deploy these applications. To someone who does not know the ecosystem well, it is not clear how to pick between the various options.
Promote functional programming; provide training targeted to potential new groups; maybe implement another target runtimes (for example, LLVM for high performance, or the BEAM
Relevant parts of the Clojure resources are from seniors for seniors. People have to know a lot to get into Clojure and a lot more to even achieve small but meaningful things.
Many libraries are unmaintained, which is becoming a problem when using them in long-term production projects. This impacts the suitability of Clojure for mature applications.
Be more transparent as to what is happening with the core language. It's especially exasperating about spec. Wanting to use it but the production version never seems to arrive
1)Improve focus on popularising clojurescript and libraries to attract JS Developers. 2) More full-stack tutorials/frameworks to promote 1language on client/server advantage.
Show more development? My struggle is using a getting a dev workflow. Like I use just vim, no plugin. All of them seem complicated and I haven't been able to utilize them yet
Documentation. - Clojure, not bad, but could do better. - ClojureScript - a lot of movement in recent times, the documention has not kept up to have authoritative references.
Get big companies (like Cisco and Apple) to make their Clojure support more public. We need more perception of how much more widespread the language is than people realize.
I'm not sure how, but I would love to try to eliminate what seems to be a persistent stigma against LISPs from programmers unwilling to expand beyond C-style syntax languages
Not sure, those that want what it offers I suspect generally find their way to it - if they, like me, think LISP is how programming should be, then you'll have another user.
The js community is a great audience, in that they are plentiful, and much of clojure's appeal is something they are primed for with the popularity of functional programming
Provide friendlier defaults without needing to figure out so many things just to get a project off the ground, namely friendlier CLJ project set-up, less clunky IDE support.
Don't know.. I think Clojure lacks the killer-app that really drives adoption. Whether that's a bad thing or not is up for debate (look at ruby's decline as rails declined).
A ground up rewrite of clojure.org with a fresh design and a focus on getting started. Links to get Java, a platform specific terminal command to run, a hello world program.
Market it better. Show benefits that would attract executive management like ROI, reduced bugs, maintainability metrics etc. so that devs can pitch that to their management
1 - Provide open source templates for applications (microservices, web app, mobile app, etc) 2 - Promote applications such as generative arts, command line tools and so on.
Make some kind of tutorial project with articles/youtube videos and code hosted on github. That could show and explain, basic concepts and good habits while using clojure.
Provide more help with getting apps running on a server. Lots of resources exist for local development, but I've stopped using clojure as I struggled to get my work online
The official Clojure website is not great, it does not have enough information to actually start being productive with the language. Even if the language is very powerful.
More tutorials and reference material. What comes to mind is to adopt tests soon enough. Also a primer in spec. More testimony on how to run Clojure systems in production.
Create more introductory materials (tutorials, reference docs, etc) around state of the art tools and libraries. I still don't really know how to use tools.deps very well.
Find a way to get in contact with the kids that learn Racket/Scheme at school for programming and get them to learn Clojure. Find a way to get more CIO's to adopt Clojure
More tutorials on using multiple libraries together to solve non-trivial problems, such as authorization filters that not only check for roles, but also for data access.
Push Datomic and Spec. Datomic is impossible to get into, but is a killer app. Spec is game changing. Clojure is not a good first language. It's something you arrive at.
Improve interop with other stacks/languages: Python interop is very important. Working easily and well in the JS environment (devtools, modules, etc) also very important
Provide "standard" ways of doing things, Ruby on Rails style. It is not helpful for beginners to chose their own libraries, while at the same time learning the language.
Better on-ramp to fully experience the power of REPL in a serious context (e.g. not on toy environments). I think Calva right now does an amazing job with it's tutorial.
A robust, unbreakable newbie experience with full acknowledgment of the possible problems encountered by many combos of OS, IDE, nrepl config, middleware, build tooling.
Get standardized tutorials on how to do build things with options that you can swap later. Example luminus. You can build web app but choose which libraries to include.
- Make it a smooth transition to vanilla Clojure code to full-fledged spec-ed code - I know, I know, but a subset of Clojure with a newbie-friendlier non-S-expr syntax?
Simplify the way concepts are brought to new audiences. Most of the time the feeling that I get from the community is that the more complicated and complex the better.
I'm not in marketing so anything I could offer would be no help. The development environments available make onboarding much easier than a decade ago. So keep that up.
The marketing still sucks, I rarely hear about it in the tech news like HN or Reddit. https://www.tryclojure.com/ is the first thing I've seen in tech news in months
Try to attract other Lisp users. The Lisp community is already small. I think we need one default Lisp that anyone can feel good about using/deploying professionally.
I'm not particularly concerned about increasing Clojure adoption. Continued support of the existing community through communication forums and conferences is helpful.
Creating more tutorials explaining real cases where use the core functions and maybe implement some problems with the imperative way and change to the functional way.
Lobbying for adoption of Clojure in University programming courses, e.g. SICP style uni course, programming 101, influencing the use of functional programming at uni
Talk more to complete newcomers to programming about their problems and suggest solutions that overlap at least partially with the paths taken by other technologies.
I'm interested in distributed applications (not crypto-blockchain), and hope that Clojure comes to excel in these areas through tools like datahike and replikative
Maintain the friendly atmosphere / culture, deepen the diversity in the community and build more stuff that makes adoption easy / attractive to the casual observer.
Invest into omakatse like brary choices for common problems. Reduce the cognitive load for a new person who tries to implement more complex project than hello world
Get rid of early hurdles, especially by improving error messages. Make the website more flashy, have (interactive) examples there that showcase Clojure's strengths.
Strive to equal the Elixir community's standards on: documentation (including thoroughness and consistency), library discoverability, and out-of-the-box experience.
Honestly. I don't know. Reduce the hurdle of entrance as far as possible, but even then I think Clojure is already in a good spot. Maybe show that it is not a risk?
The community stopped to be as present on the media I follow. It looked like the job market is also slowing down. So probably, build great things and talk about it.
More general purpose Clojure content online, because the language is great but everyone thinks that it is only suitable for multithreaded, computing intensive apps
continue producing/hosting good content/conferences. The OOP brainwashing, reality distortion field keeps people in the dark, please continue providing the light.
Figure out how to get Clojure into schools and universities. Youngsters have the energy, time and are naive enough to not know or care how long the journey is :)
Finish things. Aggregate tooling/libraries for new users. Intentionally train more junior Clojure devs when hiring, instead of taking on more experienced people.
Have Rich Hickey give a few more talks to remind the world of his brilliance. Meanwhile I continue to grow it organically one project at a time in my large bank.
I’m not actually sure. I encounter such closed mindedness about lisps, I’m sometimes not even sure it’s worth it to try and convince other devs, esp senior ones.
show off interactive development; advanced workflows, not just REPL. Think "cider-eval-last-sexp-and-replace" interaction with host env while solving a problem.
- Make better error messages/stack traces 2. Make tools/editors to support specs better (especially functions speccing) to make refactoring easier (spec based)
Keep the positive spirit. Take care of the commons (libraries etc.) and not just code but documentation. Keep up with the React ecosystem and show how we do it.
Use YouTube as a platform to gain more exposure. Have some highly followed YouTube channels review/overview Clojure. Such as Fireship's "in 100 seconds" videos.
Help setup editor with REPL integration, without any "jack-in" magic. Please make it uncomplicated - CLI based REPL server is fine that editors can connect to.
Improve the tooling. People talk about type safety when they say they want static typing, but all they really want is their IDE to give them more information.
More videos and visual materials! Demoing how we use REPL in action can impress people who have no experience of Lisp or skeptic about dynamic type languages.
Share more blog posts and video tutorials for beginners. And not explaining things like: That is same as this in Java. That does not help if don't know Java.
Not sure. Continue promoting Rich's videos, they drew me in! Continue sharing commercial successes. Continue being an awesome community, that has me staying.
Better tutorials that help a beginner knows the language to understand the development ecosystem such as deps, projects, and use of plugins for various IDEs
The community can create a Fediverse/ActivityPub server using Clojure and ClojureScript for showing the world what Clojure and ClojureScript are capable of.
More curation, documentation and polish around blessed integrations and frameworks. Make the happy path explicit, rather than just available and implicit.
Just keep going, we can increase clojure adoption by increasing the amount of visibility of the language, keep working on meetups/conferences, and so on.
Show more examples to do common things (e.g. web development, big data applications, machine learning, systems programming, etc.) in a centralized place.
IDE, REPL just working, tutorials, a good framework that helps people understand the ecosystem and start building quickly i.e. Ruby on Rails, Phoenix...
Let it stand alone and not be tied to the jvm, there are enough langs that do that already. Doubt it will happen which is why I eventually abandoned it.
CLJS up to date tutorials with re-frame reagent and all the new cool stuff. Maybe alternative for native clojure would be how to create proper library.
Project templates, Rapid application development with clojure, You need to provide all-decisions-made defacto web framework mimicking Rais, Django etc.
Continue making Clojure great: simplicity + power. I hope it does NOT become a Frankenstein like C and now Python that starts to grow a new arm or leg.
I loved the video of "Clojure 1.11.0-alpha4 chat" — not sure it will increase adoption, but I think it can foster fantastic engagement from community.
Create a series of tutorials for curious tinkerers and absolute beginners (basic concepts and WHYs), give it prominent place on clojure.org frontpage.
More successful companies built on Clojure that achieve scale. The Clojure community isn't particularly business oriented, which could be problematic
Please bet hard on Clojurescript. I think clojure+clojurescript can be huge. I did some react work here and there and clojure's story is much better.
Be more opinionated about which libraries to use to spin up a webapp, an API, database access, etc. and the tradeoffs other using one over the other.
Try to be more compatible with the other conventions used in the ecosystem (source code paths - maven style ?!, cli app arguments - gnu style ?! ) .
Better tooling (IDE integration) and error messages. It's hard to convince team members that are used to Java/Kotin about the advantages of clojure
Focus on building a friendly developer experience. Make tools that are delightful for users, not hostile. Make the error messages helpful and kind.
Emphasize more on Why Clojure and its Rationale than the language itself and the influence it has on the thought process when developing anything.
An idea could be to try to reach out to other communities spreading the values of Clojure but without talking too much about the language itself.
People still don't get how Clojure REPL is different from other languages. There are many talks about this, but I haven't seen a great "one-pager
Create more content on how to debug software in Clojure and how to start new projects (mainly used deps, I feel people who are starting get lost)
More and frequent rich hickey talks. Open source datomic, best db and still hardly anyone knows of it. Feel it would bring so many new people in.
Shout about it everywhere we can in order to push its adoption in enterprise further. From France, clojure still seems to be a 'niche' language.
We need to be more approachable for absolute beginners. It would be cool if people would learn programming with Clojure as there first language.
Improve start up time on JVM. Finalize Spec2 (to avoid the confusion of malli vs spec1). Maybe roadmap for leveraging Project Loom in Clojure.
More and better tutorials for beginners showing repl development, but NOT using Emacs or Vim. Simple set-up with a socket repl or local repl.
Some guides of how to pick libraries, and what are the options (Clojure.garden is doing something like this, i think). Invest in ClojureDart
Keep preaching immutability, composability, simplicity, testability. Visible and easily-understood examples of Clojure benefits are helpful.
Better documentation/examples on how to include external files and structure Clojure projects. Hard learning curve when coming from python.
More documentation for those that don't initially reach out to the wider community. More avenues to encourage joining the wider community.
Show some interest in non-expert users. Better tutorials. Less laconic documentation. Focus on errors; make exceptions less overwhelming.
Improve beginner documentation, especially in video formats and targeting new programmers, not just old programmers with other languages.
Clojure and Lisp idioms are somewhat inaccessible to beginners--tutorials walking through some of the more common ones would be helpful!
More talks like "Simple made easy" going not necessary into Clojure specific things, but highlighting principles that Clojure shines in.
Encourage 20-year-vet programmers how to teach a young programmer Empower tech leaders who are more competent than just good programmers
More setup tutorial for different use cases (e.g. simple web server development, React web development, React Native development, etc)
Make it easier to get up and running with REPL and development environment. Tooling was hardest to get started, esp. in ClojureScript.
Communicate how little effort it is to get “over the hump” initially and how much value a functional, immutable jam language provides
Simpler editor setup with the repl. Why would a beginner know what nrepl is vs a repl? Why have a different repl between clj and cljs
Teach Clojure(Script) to more and more youngsters! And, probably, figure out a better unified approach to building GUIs for web apps.
best-practice full-stack frameworks that enable newcomers to become productive quickly and learn along the way of getting things done
Add easy to use and fast gradual typing. Most people that I've seen dismiss clojure out of hand do so because it's dynamically typed.
More open resources like tutorials, study cases, show different scenarios where using clojure is a good election vs others languages
For me the most compelling stories are just highlighting real world production uses of Clojure that people can relate to their work.
Documentation: See https://jacobian.org/series/great-documentation/ Having popular tools that are used beyond the clojure community.
Emphasize host interop ecosystem availability and its ease of use. Demonstrate the power of REPL especially in non-trivial programs.
Ensure that contact with other Clojure developers isn't abrasive, and actually write good, useful documentation for libraries/tools.
- Constant improvements of language, tools and documentation. * Continuing the enlightening talks * A killer framework/application?
Explain to big players that Clojure is not one of these dynamic and unsafe languages out there and they should invest in it more ;)
Have more open development through jira/tickets. Let us report bugs and patches. Using forum for reporting issues, in 2022, really?
better visibility through webinars/videos.... and simple tutorial programs for removing the fear of functional programming concepts
More marketing from the core team. Ask Rich to interact with the community more. He has a wide reach and people really respect him.
Investment in beginner tooling (calva probably) and uptodate starter guides that use major community tools (nrepl, Calva, cider...)
More, better paths into Clojure. Video tutorials that relate popular languages and their tools/concepts to equivalents in Clojure.
Hire Tony Kay and add Cognitec brainpower behind fulcro. Fuclro RAD, Datomic and Pathom are so mindblowing tech as clojure itself.
Documentation quality. Accessibility of Clojure idioms. Interoperability between libraries. And let's focus on one build tool, ye?
realworld app starter-kits. Like in js, you can find close production-grade boilerplates to get started and learn while building.
More documentation, improve the Clojure using on VSCode(I think that IntelliJ, Emacs, spacemacs, vim restrict too much the tools)
Adopt borkdude :-) Seriously Babashka is a perfect Trojan horse to gently introduce Clojure on a lot of IT tasks then brains !!!!
Be visible and promote Clojure. Remove alpha from the package name of spec to earn trust. Show that Clojure is Enterprise ready.
Some people have a religious/puritanical view of Clojure and will condemn any idea or technique that was not thought of by Rich.
Go the shadow-cljs route of integrating yarn/npm directly (make tooling work as expected to someone coming from a JS background)
associate with Paul Graham (Y Combinator) more formally persuade computing science schools to use Clojure as a learning language
Be more welcoming to newcomers, providing easier bootstrapped projects, sane defaults to editors—fewer things to learn upfront.
Make onboarding easier (including Windows support), evangelize Clojure to persuade people that all its "weirdness" is worth it.
Good documentation. Defragmenting the setup and templates - still many lein templates but clj cli is the future, and my choice.
Help expand ClojureCLR into .net ecosystem (.net 6 and beyond) because the cross-platform JVM/CLR/JS synergy would be amazing.
Address programming in the large as well as Clojure has historically addressed programming in the small. Datomic, Spec II, EDN
On-ramps - e.g. editor config incl sensible config, tutorials to get productive in a certain editor incl REPL integration etc.
Probably using Clojure in more Open Source Projects, providing more documentation and having more visibility in success cases
I don't know what it is, but having some sort of killer application, like Rails was for Ruby, or data science was for Python.
Writing Clojure well is vastly more challenging than learning the language. More well-written complete apps would help many.
Have a killer, out-of-the-box web framework. I am going to work full time on one during the next 3 months, its name is Vrac.
Marketing, I think - the language is great, the tooling is great, the community is great, more people need to know about it.
Improve good examples for real life uses. Encourage people to post and talk in forums that are read also by non-clojurians.
Improving tutorial on full projects so that one can grasp real use cases of Clojure inside an infrastructure (i.e. Datomic)
Make it easier to deploy cross-compiling frontend/backend applications. Standardize the instrumentation+validation library.
Help with Java generics interoperability. Help maintain clojure libraries for larger frameworks like spark or Kafka streams
More screencasts for beginners, promote Clojure in the large. More talks at other language conferences to raise awareness.
Support the smart and innovative open source creators, and spread their breakthroughs with the wider developper community.
Create a Clojure Foundation and share the long term vision. Better support the exciting new JVM features as they roll out.
Create examples of how Clojure is used in real life, create content to help beginners in Clojure or functional programming
More videos and examples on YouTube is great. Target clojurescript more than clojure as the javascript community is huge.
More onboarding documentation. There are many tools (clj, lein, figwheel, ...) and its hard to understand where to start.
Promote it more on Twitter. Also Java conferences, JVM websites like www.baeldung.com, software architecture conferences.
The learning curve of clojure is too difficult. There are no good resources to learn it. The libs is hard to learn, too.
Write some cool blog posts and share with the community. Show some example of Clojure used in the wild for "real" work.
Continue making it work with tools people already know. Continue to ensure Clojure appears as a viable long-term option
More public success stories, blog posts/talks about the strengths of Clojure and how they made hard things simple/easy.
I think the better way is to create more reference open source tools so people are interested in learning the language.
Probably create recipes for java programmers to follow in order to get things done. Lots of "from zero" type examples.
provide better tutorials for beginners. promote use in schools. - i think python docs provide a good example for this.
Join tech conferences outside the functional and/or clojure community, to talk about and demo the language & features.
Build more sophisticated debugging tools. Write and make video/audio to teach people about Clojure and its libraries.
This is becoming difficult. The advantages that Clojure once had are gradually becoming available in other languages.
Cut some of the edges off of developing a web app from scratch and being productive. Borrow from JS's successes here.
Increase open source involvement in Clojure, make it more open and easy for beginners to join and start contributing.
Reach "down the tech tree" with tools like nbb that let non-Clojure people quickly and easily try out ClojureScript.
Sexier landing page with embedded editor (possibly using sci) to let new comers play with the language immediately.
Making more beginner tutorials at the clojure's main page, centralizing clojure resources around the web in a page.
Keep looking at how to make Clojure more awesome, spec & deps were fantastic solutions to very frustrating problems
We need a better lib for frontend (like nextjs). Some kind of laravel that helps starting super quick on a project.
More blogs & marketing in general. Specifically target heavy users of current Java users such as traditional banks.
More tutorials esp on frameworks like Duct, Integrant and building common patterns - Web App stack, DB stack, etc.
Improve documentation - between a simple 'hello world' and a full blown web application with component system etc.
Convince more Python folks to try Clojure, maybe some more small catchy YouTube videos on cool aspects of Clojure.
Show more of how Rich and Cognitect steward Clojure. Curious to see the design decision of the language laid out.
build open-source efficient alternatives to mainstream projects to promote functional programming and lisp syntax
Don’t know. Our industry doesn’t choose tech based off of any objective measure other than “it’s built by FAANG”.
Easier setup of projects. In my experience, starting a Python project (or just a one-off session) is much easier.
Make web programming easier for beginners, which will then get hooked and move to Clojure on the backend as well.
improve tooling to make it less confusing, having to use -M, -X, -A for various aliases is confusing to new users
Keep on getting developed excited with inspiring videos: maybe boring case studies to get buy in from managers?
Beginner Friendly materials. It was challenging to teach and mentor junior people at my work regarding Clojure.
Make it easier to discover and learn. Share more success story. Talk more about the superbe community we have.
Better guides, explanation why things work like they do. I see junior developers struggle getting up to speed.
Easier environment setup - coming into the system relatively new to development can be a steep learning curve.
Document more about successful cases, like companies that use it and how agile/productive/efficient they are.
open comprehensive learning resources are not available. Need to develop some interactive learning resources.
Make the startup/beginner path for Clojure much much more standard and transparent. Make it fun and friendly.
standard answers to common "frameworks". make very clear how to make a web app with a database from day one.
I think lack of static typing is probably preventing adoption. We need to have proven success of using spec.
Clojure reached escape velocity a long time ago; focus on building great things, not in increasing adoption.
Release a stable version of spec. Publish a freely-available, high quality guide to REPL-driven development.
Emphasise the separation of data and code. Show these capabilities to senior data (information) architects.
Support initiatives like Clojurists together which support development of high-quality libraries and tools.
Improve official docs with more examples, videos and tutorials. Clojure beginners lacks learning materials.
Maybe more promotion of the advantages in increased development velocity that may appeal to big enterprises
would be cool if there were some batteries included app frameworks similar to rails but with clojure flavor
Targeted marking campaigns at specific groups of programmers (like js devs, or java devs, python devs etc).
To have production grade templates for Clojure applications More beginner friendly DI/Components libraries
Keep on demonstrating to our employers how great it is by - shipping killer features - making simpler apps
create programs solving real-world problems and speak about that highlight the benefits from using Clojure
Improve branding, increase dev advocacy, improve DX in terms of ease of getting started and error messages
easier onramps. More clear guidance on questions like "I want to build a web app, what stack should I use"
We should somehow get more students and junior developers interested in it, but that's obviously not easy.
A lot of the community activity is locked down in videos. Bad for SEO. Also not enough hype or killer apps
create more examples for any situation similar to python...we need to show the equivalent code in clojure
More visibility and awareness exposure in general publications is needed - not just within the community.
Somehow make it less scary to business owners, maybe through marketing by sponsoring talks at events etc.
Mentioned before, but I'd like to see a dialect of Clojure that compiles to C (kind of like ferret-lang).
Keep in the news. More examples of companies using Clojure. It still feels like I'm using a secret weapon
Better and more concise error messages. Something similar to elms error messages. More updated libraries
Likely spend money on marketing in developing economies where they aren't entrenched in current systems.
Continue to be friendly and open. Welcome questions from all sources. Create and share broadly examples
Have a tutorial showing how to start a web app in a few minutes and the same for building a web server.
one discussion forum -> sunset ask clojure and use clojureverse. adopt malli everywhere. faster startup
A good collection of resources that Clojure advocates can dip into for making a good case for Clojure.
Demonstrate the value Clojure can bring to the Data Science community. IMO that is an untapped market.
I think a good web framework would help a lot, which is why I'm working on Biff (https://biffweb.com).
More conferences for developers by developers. Similar to Strange Loop but maybe in different cities.
try to avoid fragmentation ie. get behind de facto libraries vs implementing a slightly different one
Improve clj cli tools so that is immediately straightforward and familiar for someone to get started.
Actively sell it to decision makers in organizations. Evangelizing amongst devs can only do so much.
The barrier to entry seems quite high. There are lots of tools to choose from when getting started.
Help building clj->dart. It will allow making mobile apps with clojure with native like performance
• Be open to new ideas and better ways of doing things. • Be careful not to get smug or complacent.
Not having a style guide that promotes 1-space indentation. (Kind of joking here, bur.not totally).
Talking about its benefits on other forums, such as conferences of different programming langauges.
Continue creating and innovating and proving the effectiveness of Clojure. Running more workshops.
Continue innovating; e.g. gradual typing Better docs and examples for stdlib Pick an autoformatter
Cloujure is DIY solution. I think we need frameworks like Nextjs or Laravel to attract new people.
Please provide more community (accessible, free or not too expensive) documentations or tutorials.
Say more about how nice it is. There is a reason it's one of the most loved programming languages.
Improve developer experience (documentation, tutorials, IDE integration, error message, AOT, etc)
Great question! I wish I had a good answer, but happy to help in what every way you come up with!
Better tutorials - e.g. getting started with React Native (non-Expo) using shadow-cljs was tough.
Make a nice tutorial for a sensible and safe web stack (with https and a production grade server)
Make installing on Windows easier. I is the number one issue I have in teaching a Clojure class.
Improving runtime performance and resource usage efficiency. Make it more friendly to new comer.
A default framework for web (backend) development that "just works". Like spring, rails, django
Create a better editor / ide. Without live debugging I am forever sad. Rip of F# where possible
Work on diversifing the community and lower the voices of show offs out for just bread and ego!
Spread the good word about Clojure and show that there are great success stories using Clojure.
Better opinionated tech stacks for particular deployment modes (eg web app, ML, DB, serverless)
Make more use cases public and start evangelizing so there are more companies adopting Clojure.
Persistent file-based collections (maps especially) with caching. Similar to SqlLite & Access.
More opinionated talks/discussions in video format. Especially talks coming out of left field.
Continue to innovate - initiatives like babashka are extending reach and support be supported.
better documentation and meaningful examples not some semantically correct meaningless example
Figure out Lein vs tools.deps/cli/build split - looking from the outside, it's quite confusing
New talks – Clojure TV doesn't need to be constrained to recordings of in-person conferences.
Make Java leak less from the seams of Clojure. CL-like condition handling would be very nice.
Get better docs, more tutorials and a better "getting started" story with easy tooling setup.
We need more success stories like Nu out there. I'm working on it with https://legalmate.co !
Keep up the good work and keep talking about it, one day people will realize how great it is.
Hard to say. But Clojure game engines/engine integrations could definitely do with some love!
Improve error messages, do not advertise the language as a "language for advanced developers"
Make some of the discussion in the API docs less terse. An actual example can go a long way.
I’m not sure, some people are set in their ways or not interested in learning something new.
Syntax is super hard. Don't know if there is something to do about that, but would be great.
Show clearly that calling clojure programs from the host env is something that is plausible.
The official documentation should explain things in very simple terms with lots of examples.
Make available more materials of clojure in other languages (Portuguese and Spanish mainly)
I think the biggest impact for me might be to evolve and release spec2 (without the alpha).
Publicise the benefits of Clojure more. Provide more/better tutorials in all Clojure topics
Keep promoting open source (or commercial) creations, it's through Storm I came to Clojure.
Be open and helpful to newcomers. Don't get bogged down in conversations about parentheses.
I think we need more sponsors in IT companies and also in IT department of other companies.
Consolidate "getting started" paths, maybe per area of technology (web, data, desktop, etc)
I would expect more marketing from Nubank and Cognitec, specially in different conferences
Keep the quality books coming, which not only propagate know-how but also promote Clojure.
Better spec integration.. will pull in those that desire something closer to static typing
Have a clearer recipe for "How to make a full-stack web app with Clojure and ClojureScript
Better docs for open source libs. More big examples of project structure, repl driven dev.
Collectively agree on a web framework (Rails) and (sorry) ship the holy next spec version.
Help make on boarding simpler - setting up the IDE, introduction to REPL driven workflow.
Use more friendly style to write guides and documents, don't assume readers are experts.
Improve documentation, tutorials, examples. Target devs who just do scripting in Python
More tutorials. More stackoverflow, which is better linked by Google than eg askclojure
Explanations of Opinionated stacks.. Deciding which library to use for what is helpful.
Post on medium.com, post on twitter, try to get babashka to be as complete as possible
Provide more case studies and otherwise assuage the "smaller recruiting pool" concerns
Easy to use demos outshining other languages emphasizing Clojure/Lisp design decisions
Make it easy to get started doing common things, like setting up a simple web service.
More demos. Where are all the cool Clojure apps leapfrogging other development stacks?
try to be a friendlier leader in the community; Besides Alex, most come across poorly
More and better introduction-level materials, provide space for more young new faces.
Make better docs and tutorials. Not just basic ones. Make them more widely available.
Make people aware that it is not a gimmick language and that it's made for real usage
Project templates to build serious web applications and deploy them on a public cloud
Expand on the docs for the core libraries. They are exceedingly terse and minimalist.
Make the environment setup easier (many languages provide a single script to do this)
Revamp Clojure.org - look at how other lang communities attract their users. Copy it.
Make it easier to bootstrap a project in clojure. Provide tutorials on how to do it.
Promoting it even more, but it will probable remain a niche because it's functional.
Compare performance and development time with python or other widely used languages
Publicity, make other programmer now's about success cases of clojure applications.
Provide an easy tutorial on how to include Clojure in a standard Java Maven project
Encourage some library's owners to solve questions like #beginners channel of Slack
Write superior software so that people will ask: What are you using? How you do it?
present better media showing the uses of it and why it fits the use case mentioned
more insight into nubank’s usage of clojure and technology stack and open sourcing
More core libs to have less interop A simpler, more coherent IDE (smalltalk-style)
Advertise its ability, readability, and usability (i.e. use cases with examples).
error messages, idiomatic and easy getting started for beginners on official site
- Better documentation - Advanced tutorials - Teach best practices for production
Personally I've adopted the mindset of being "enthusiastically beginner-focused."
Support the authors of robust frameworks and help the community converge on them.
Maybe more talks outside of the core community, like at general tech conferences.
More tutorials about building full-stack projects More beginner-friendly content
Talk at conferences again when they return. Continue the awesome funding of OSS!
In Korea, there must be a good case study of large scale development of clojure.
Help java programmers realize they can incorporate clojure on their current apps
Not sure what more can be done, there are so many initiatives out there already.
Keep sharing success stories. Keep the documentation and reference quality high.
Maintain libraries better, spend more time on clojurescript, work on webassembly
More focus on new resources for new programmers, particularly younger children.
Target specific proglang communities with resources like tutorials and primers.
More attractive documentation, with examples and interactivity. Like JS tools.
more women, more frameworks, less enterprise, more "do this and this and this"
Tell and educate people about the advantages of using functional programming.
improve tooling, so as to make transition from other languages more palatable
Offer more jobs and more resources for people to get interested and involved.
Continue to improve IDE integration/plugins Debugging tools (like Smalltalk)
Keep maintaining useful libraries because sometimes their maintenance stops.
Improve documentation/tutorials for widely used libraries (e.g. DataScript).
improve docs and implementation references for common types of applications
More real world examples / tutorials. Most examples I see are toy examples.
They’re pretty closed to suggestions so probably listen to what users want.
Tutorials that highlight key libraries and processes in a larger ecosystem.
beginner friendliness and well around documentation, popular IDE supports.
Make it easier to get started and learn best practices (popular framework)
Make it easier for new users to get started with an editor-connected REPL.
- Sophisticated examples and demos - Demo industry applications of Clojure
It would be nice to start up Clojure Conj again to re-ignite the community
More tutorials. A more welcoming community with more contribution options.
Make it easier to figure out editing / understand REPL-driven development
Demonstrate successes, demonstrate simplification when porting to Clojure
Nothing. Clojure is like Buddhism or LSD. One has to be ready to find it.
better error messages. platform native CLJ (think SBCL). WASM-native CLJ.
Just keep up the great work, I guess? Sorry, I don't know how that works.
improve observability of Clojure programs (REBL is in the good direction)
The core devs have to want to at a deep level. A lot will flow from that.
Keep up the amazing work, can’t thank you enough. Clojure changed my life
Try not to pick arbitrary fights. It looks childish. It turns people off.
Training material (courses, MOOCs) to improve clojure webdev fundamentals
Less dogmatism and in-group (FP) polarisation, particularly about types.
Explain with documentation and YouTube video how to use testing and spec
Keep hosting events about Clojure + easy and fun tutorials for newcomers
Increase easy to follow tutorial about more advance topic and libraries.
Better support or guides for getting started in editors other than Emacs
Improve ease of use of development tools and the documentation for them.
Market the productivity gain and simplicity compared to Java and Scala.
Perhaps create a "create-react-app" type application for clojurescript?
We need more applications especially in areas such as machine learning.
Improve documentation and tutorials. The startup time is still to slow.
ide like Racket, Data analysis and visualization like Julia, doc like R
Finish spec 2. Or tell the community that's it's officially deprecated.
Use it, talk about it, roll eyes at people bitching about parentheses.
Build successful products, and let people know it’s built with Clojure
Facilitate it's learning curve by giving More educative talks about it
Maybe it's time to think about a version that compiles to WebAssembly.
I think the community is already very supportive, especially on slack.
Build stuff so good the rest of the programming world can't ignore us.
Show Clojure used in more diverse areas. I keep only seeing "Fintech".
Be more clear and vocal about the day to day benefits of the language.
Find ways to bridge the gap between startups and Enterprise tech orgs.
Provide more documentation targeting beginners and simplified tooling.
Simplify the language of the documentation to make it more accessable
I don't know. I first should actually start using Clojure for myself.
Have a beginners path, easy as PHP and with good practises like Rails
Spread the word outside of the FP bubble (e.g., polyglot conferences)
More online and easier-to-use Javascript to ClojureScript converters.
Encourage companies using clojure to contribute to open source more.
Make it more friendly, with more libraries provided by the community
better documentation to setup IDE for both Clojure and ClojureScript
Easier getting started interactive examples such as beta.reactjs.org
Having more resources about practical, daily aspects of development.
We need a "batteries included" toolkit in each major working domain.
Better error messages, better error messages, better error messages.
Podcasts, screencasts, blogs and doing real world apps with Clojure
Not sure I can think of anything that hasn't been suggested before.
Keep inspiring developers with thoughtful opinions on common issues
Easier access to Datomic, more tutorials on Ions and Datomic Cloud.
Unfreeze clojure.core and accept new functionality and improvements
Help and enthuse the key community developers to grow and succeed.
Don't really know, we are already on the right path in my opinion.
Good question. Idk... more killer apps/killer companies I suppose.
more easy introductions, better books more explained code examples
GUI/cross-platform resources; advocate change to TIOBE methodology
Good documentation and examples. Interesting podcasts and videos.
Tooling. Docs. Stop doing things like spec when it already exists
Support to 3rd party libs support, reduce a number of abandonware
Make the community less of a boy's club. Help women feel welcome.
Reduce startup time and develop libraries to do integration tests
Change it to be more similar to modern languages, such as Haskell
Tell non-Clojure people about cool stuff we have done in Clojure
Better transparency to the core roadmap timeline and priorities.
Develop convenient tools and provide more guides to use Clojure.
Tutorials, demo applications, developer advocates, social media
Spread senior engineering knowledge, idioms, and best practices
More talks and articles from people using Clojure in production
Create a non hosted Clojure that does not rely on any platform.
Try to talk to people outside of our bubble about the language.
Make a game as popular as Minecraft, with scripting in Clojure.
Make documentation more accessible / digestible for new-comers.
More tutorials, blog posts and practical application examples.
Better training available at affordable prices. Certification!
Kickstart Android development using clojure and more tutorials
example apps - that help give example apps for people to copy
Emphasize it's connection to Java (ugh. I hated writing that)
keep speaking about it and raise awareness to it's advantages
open-source datomic :) (one can only dream) Make spec2 happen
More entry level project templates that work "out of the box"
I like youtube content. Flutter is the best ive seen do that.
Target clojure.org towards new users and make it more flashy.
more sample programs. the best are currently behind paywalls
Keep talking about it! Continue to avoid breaking changes :)
Continue developing cornerstones of the language, like spec!
More marketing about success cases and more conference talks
Evangelize to the nonbelievers (those who don't use Clojure)
More well documented libraries + more books/tutorials maybe.
Make videos about Setup, dev with the REPL, then deployment
Better documentation for ecosystem tools: builds, deps, etc
reach out to people starting clojure projects and help them
More books/tutorials about building real world applications
kill leiningen (but thanks for the critical role it served)
Polish rough edges of Clojure and core libs. Finalize Spec.
Create successful companies with products built in Clojure.
Business cases, demonstrate it is efficient and save money
Make more resources around real world clojure applications
Batteries-included projects people can clone and customize
More evangelizing? Not sure I have a good suggestion here.
I would say probably write more beginner friendly content
Have Rich Hickey get back to doing his old amazing talks.
Focus more on marketing the language to a wider audience.
More tutorials of Clojure for people starting programming
Provide more learning resources and better documentation.
Popularize kill apps such as Datomic, XTDB (Storm before)
Have a standard framework for the beginners to start with
Stay on the current track. Make sure new stuff is vetted.
Beginner docs and help. Evangelize at non-Clojure events.
We need more community, more meets to talk about clojure
More Rich Hickey ™️ Tech / software design presentations
decide on a web stack decide on data stack support torch
rich hickey new talks/presentations. its been a while :)
Better documentation, especially in Core, with examples.
Demonstrate more professional style application examples
Produce training paths and materials for new developers
Create more content on clojure and how to start with it
Make the tooling better. Better official documentation.
Documentation clarifying the idiomatic way to do things
Don't think I have anything useful to say here, sadly.
More free tutorials. Better third party documentation.
Promote Clojure for software development in companies.
Foster remote jobs, teach fast competitive programming
Open source Datomic. Asking as a Nubank shareholder :D
Detach it from JVM. I do not like the Java ecosystem.
Have courses in practical tools, like web APIs, SDKs.
Better tooling or explaining how to set up on windows
More updated documentation for tools like shadow-cljs
keep publicizing large successes within the community
Keep the good work and make success stories possible.
Increase language interop and library compatibility.
More Rich Hickey keynotes at non-clojure conferences
Write, talk and share about it, in all ways possible
Create an all-in-one web framework, like Spring Boot
Deliver sick software that just works. Like datomic.
Keep an open mind to all platforms that host Clojure
Less strangling of things made by others, more hugs.
Keep building more kick-ass applications/products :)
We can resurrect the days of stellar documentation.
Create more resources to learn clojure from scratch
Make using npm modules as low friction as possible.
Have patience, Clojure will dominate the world soon
Make getting started easier, improve error messages
introduce more successful stories and experiences.
I think better examples of real-time applications.
Keep having conferences and promoting the language
Better marketing of the language, slicker website.
Make clojure perfect in one area and focus on that
People I talk with are terrified of dynamic typing
Start hiring people even if they never did clojure
High quality and coherent documentation and guides
Online talks for new ideas and podcasts for reach.
Advertising more about the product like datomic db
Build more application which people can refer to.
More user friendly tutorials (video and/or text).
- Lower barrier to entry - Improve error messages
Not sure. I've lost the battle in my org for now.
Better error messages, killer spec implementation
More before/after success stories, testimonials.
golang runtime as a target, but compiled version
Remove "alpha" from libraries such as spec, deps
Being more helpful with newcomers. Improve docs.
Talk more about Clojure outside our community.
Make the getting started experience streamlined
Promote babashka as an easy on-ramp to Clojure.
Motivate those who make Clojure tutorial videos
Better onboarding with 'real' project examples.
more beginners guide - simple environment setup
put more love outside Java and Javascript world
More AI focus and big projects that use Clojure
Appeal to static typing afficionados with Malli
Work around the issues people have with the JVM
Better guides for more experienced programmers
More tutorials for beginners and intermediates
Better tooling. More outreach. More tutorials.
Be positive and enthusiastic about what we do.
more tutorials, more hosts, better performance
Create more tutorials/books on how to use REPL
Tutorials to learn Clojure and it's philosophy
Developer outreach/hire language evangelists?
I would love more talks from Ritch, please :)
Publish more content online for other to see.
Keep doing the work, keep spreading the word.
Show that you don't have to give up the JVM.
build more off-the-shelf, complete solutions
Better interop. Mainly around documentation.
I wish I knew. Help programmers grow spines?
finish spec more open-source success stories
in person conferences -- bring back The Conj
Tutorial on how to used the repl efficiently
More tutorials on using different libraries
Having a famous product built with clojure.
More tutorials and real-world example apps
not entirely sure -- many theories on this
Get meetups and conferences back on track.
Support of more boring IDEs, like eclipse.
Support widely adopted libs, such as malli
More Tutorials with language translation.
Focus on adoption at large tech companies
Create a good guide for Clojure libraries
Build companies that use it successfully.
Share why Clojure is good, help newcomers
I would like to attend Clojure Conj again
Be patient? Start teaching it in schools?
write more blog to introduce the clojure
- Development productivity - Type system
Improve the tooling, frameworks and IDEs
More tutorials/books/educational content
Pick one build tool for the love of god.
Better documentation of common use cases
Continue supporting an awesome language!
Simplify cljs use and frontend resources
Talk more about REPL driven development.
Help keep popular libraries up to date.
More Rich Hickey Talks; Updates on Spec
Better error messages and stack traces.
More free content, eg, YouTube channels
build cool apps that people love to use
Make ClojureScript way, way easier. NPM
more clojure notebooks / clojure colab?
Events, Training, Open Source Projects
More outreach and educational material
Make HN frontpage as often as possible
enrich documentation for the community
Keep delivering high quality products
Make it easier for beginners to start
Keep doing what you're already doing.
Improve tooling. Editor integration.
Help with the machine learning tools
Better tutorials and "sales funnel".
Continue to be welcoming and helpful
more entry level jobs opportunities.
signal boost clojure success stories
Beginner friendly docs and tutorials
improve accessibility for beginners
Have more user friendly stacktraces
Provide jobs for junior developers.
Show corporate deployment examples.
Documentation, community, libraries
Dunno, maybe teach it Universities?
Just keep doing what you're doing!!
Lots of documentation and examples
Continue to improve documentation.
Be kind, thoughtful and inclusive.
More "advanced beginner" tutorials
It needs the "killer applications"
good talks about different mindset
Write more, teach more, work more.
Kindness? Empathy? Less aloofness?
We need more Talks by Rich Hickey!
Talks with a OOP-audience in mind
Visibility and avoid LISP-elitism
Things like moving away from Java
One third lines of code than Java
Idiomatic use of Clojure language
more focus on web development gui
Keep releasing good Clojure books
Open-source Datomic, Replace JVM
Tutorials, tutorials, tutorials.
make more demo projects and docs
Focus on new developers perhaps?
Talks at non clojure conferences
Provide more learning resources.
Get more people to learn clojure
Release the Spec sooner. Please.
more videos with Mr. Hickey :-)
Get more companies to use it...
Keep it being a great language.
Refactoring tools. Spec Web Api
Write nice software in Clojure.
Recently I trained an intern to
Easier editor+repl installation
more tutorials. more marketing
Please stabilize clojure.spec.
Publish more interesting talks
Be more pragmatic, less theory
Have a clojure conj this year.
Keep doing what you're doing!
Promote funcional programming
Publicise it's benefits more.
More example based tutorials.
Prioritize user-friendliness.
Publicize more case studies.
More free beginner tutorials
Improve the compiler errors.
More tutorials for beginners
keep telling success stories
Improve support for windows.
thinks outside emacs/vim ;-)
More tutorials for beginners
We all need to advocate it!
Improve Java interop syntax
Make issues more searchable
I think have more tutorials
More material for beginners
A robust training programme
more articles for awareness
Make more simple tutorials
More usage in data science
More tutorials an examples
fix and continue debugging
More tutorials and content
Keep building great stuff.
Clear tutorial for Web dev
Keep GraalVM as a priority
docs, examples and demos.
I can't think of anything
Tell our success stories.
Improving error messages.
Avoid terse code examples
Rich Hickey bobbleheads!
Better Cljs productivity
Open-sourcing Datomic :)
More talks and tutorials
Improve error messages.
More online conferences
Friendly error messages
Improve documentation.
Keep up the good work.
Improve error handling
(inc clojure-adoption)
Better error messages.
Keep up the good work.
Share success stories.
Keep up the good work!
More talks from Rich!
Progress self hosting
Better error messages
keep up the good work
Restart Clojure Conj!
Better documentation
Videos for begginers
Clone more borkdudes
up-to-date tutorials
Do more fun things.
Making a killer lib
Conferences & talks
Make more tutorials
More code examples.
continue like that
Add static typing.
Hold competitions!
make it more known
Clone Rich Hickey.
I don't know yet.
A Clojure conj :)
Idk, to be honest
more tutorials :)
Better tooling :)
I wish I knew 😞
Better tutorials
more conferences
Easier tutorials
Emacs tutorials
Improve tooling
I have no idea.
tweet way more
Stay friendly!
online courses
More examples.
more tutorials
More training
Doing enough.
I dont know
I wish I knew
I don't know.
Blogs Videos
I don't know
A killer app
more videos
kuhjv vkvkv
no idea :)
Marketing.
¯_(ツ)_/¯
education
more jobs
tutorials
Tutorials
Marketing
Tutorials
Not sure.
More jobs
more docs
tutorial
Teaching
Keep up!
Not sure
No clue
more ML
Unsure
Try to
IDK
d
.
Obviously there are the big names who are all highly deserving: - Alex Miller (extremely helpful and responsive, and willing to openly discuss issues across the ecosystem -- Thank you Alex!) - Borkdude -- too much to be thankful for - clj-kondo, sci, babashka, pushing on clojure and graalvm, and a thousand other small things he touches and improves - Rich Hickey -- for all the obvious stuff - Bozhidar Batsov -- again too much to list, over such a long period However it's the large number of less well known people whos contributions often get forgotten, that I think deserve a mention. The long tail provide a lot of the libraries and bulk of the community we depend on in no particular order: - Dominic Monroe -- for his work on pack and many other things - Paula Gearon -- for her work on Asami and beyond - Kelvin Qian -- for flint - Erik Assum -- deps-deploy, clj-commons, being very responsive to PRs etc - Weavejester -- Ring, Integrant - Oliver Hine -- Martian (it's awesome) - Malcolm Sparks -- for his clojure work in the UK, and his many well thought out libraries and approaches to tackling hard problems - Howard M. Lewis Ship - lacinia and his work in graphql - Valentin Waeselynck - scope capture (super useful conveniences for developing and debugging and an important part of my workflow for years) - Nick A Nichols (for the clojure dependency update github action -- this is great) - Iizuka Masashi (for antq on which the above depends) - Andrey Antukh (for maintaining buddy and his responsiveness at applying suggestions I had to the maintainance of this important library) - Kiran Shila (for quickly responding to merging PRs patching CVEs on cybermonday) - My colleagues - Many talented clojurists who make work a pleasure - At least a hundred other people I could list, appologies for not having the time!
Jordan Miller: I learn A LOT from her perspective (things that I would honestly have never thought about on my own), and her colors and energy and playfulness give a strong, long-overdue dose of humanity and spirit to what has been comparatively monotone until her arrival. She opens doors we never knew we had, and I'm ever grateful to her for it. Michiel Borkent: clj-kondo helps me fix problems before there are problems multiple times every single day. His other tools are similarly fantastic. And his kindness and humility, especially in the face of adversity, are so rare in this ego-driven software world. I hope more people follow his lead. Thomas Heller: Any time I search about a difficulty I'm having with shadow-cljs, I find someone asking a similar question, and he, the author and maintainer, is right there with an answer, often with tested sample code and detailed explanations of advantages and disadvantages. Really, really can't overstate the value of his direct support in a wide variety of online fora. And that's not even taking into account how powerful and well thought out shadow-cljs has turned out. Awesome. Alex Miller: Multitasking community support, official comms, clojure.core, and Strange Loop needs like a master juggler, he keeps the cats well herded and provides a consistent stream of very useful and timely information. With kindness and humility, to boot. Is this a trend here? <3
There are certain folks who set the tone of friendly/curious/intelligent/kind/generous. I'm guessing this must start from Rich/Stuart. But I see it every time I visit Slack. Folks are just decent. There are so many I am thankful for, but here are a few off the top of my head: Alex Miller - so smart, patient, and ready to listen, even, yes even, when I am sometimes not making a whole lot of sense Borkdude - scary smart but not at all scary, approachable and contagiously enthusiastic - even with his new levels of stardom Sean Corfield - so generous with teaching newcomers, a real Clojure promoter Hiredman - belovedly gruff and oh so informative! Pez, Ericdallo, Bozhidar, bringe, dpsutton - For their awesome energy and works. practicalli-john - for the guides and help! tcrawley - for keeping clojars up and running martinklepsch - for being so welcoming on cljdoc vijaykiran & raymcdermott - for the absolute best vegetarian Clojure podcast out there Eric Normand - for sharing his deep thoughts in my earbuds while I go for long walks (Ok... I can hear the wrap-up music getting louder and louder) Yeah, there are tons, I feel bad about not mentioning everyone in the community!
Michiel Borkent is a power house of open source Clojure development delivering so many useful tools and libraries. Babashka is one of the simplest way to get started writing small piece of code Clojure snippets to do something useful. His sci library has been used by so many others to build more portable Clojure code, e.g. Malli using sci to facilitate portable schema validation functions. Metosin (especially Tommi Reiman) delivers so many good open source libraries for web development that I consider them an indispensable part of the Clojure ecosystem. Malli, Reitit, Muuntaja, and others enable the development of super solid Clojure web services. Sean Corfield has put so much work into SQL oriented libraries that have made Clojure one of the best languages for developing more declarative and functional SQL code. Working with SQL is much more enjoyable in Clojure than most languages thanks to Sean. Peter Strömberg's work on Calva is inspiring. As is the work on Cider by Bozhidar Batsov. Cider and Calva will make Clojure much more accessible to new developers thanks to the great REPL experience inside a familier editor.
Rich Hicky. Because of the thought provoking, entertaining, and educational talks he gives. Bruce Hauman. Because he sat with me and walked with me and shared many conversations about programming (and other things) that inspired me and opened my mind to things I may not have discovered for some time. Clojure and Datomic were among them. The idea and power of immutable state was also among them. I'm not sure when I would have discovered Clojure and if I would have understood its significance with Bruce. This guy in Portland Oregon who's name escapes me. He ran the local Clojure Meetup there - Office Hours style. He encouraged people to bring their Clojure code to show off and ask questions about. That inspired me to write my first serious Clojure program: a parallel fractal renderer with Google Maps style navigation. I got wonderful feedback on the code (I had questions!) and this really inspired me. The code is incredibly naïve and beginner, lol. https://github.com/jzwolak/fracjure
Alex Miller - for always being incredibly helpful. Sean Corfield - Always polite and considerate. For wonderful libraries like deps.new, clj-new, depstar etc which tackle the quick start problem. borkdude - This chap is like the Gauss of Clojure libraries! So many great projects. Also, he documents his projects incredibly well. pez - For Calva. VSCode is widely used and making Clojure work well with it will no doubt help improve the user experience. technomancy - Despite being the author lein, he is constantly looking at how to improve the getting started experience. As so many of his posts on reddit indicate, He also believes that while Clojure is hard to learn, it shouldn't be frustrating to learn. All the fine library authors at metosin - Wonderfully documented libraries. Heavy focus on data orientation. Conferences. Bozhidar Batsov - for being an important critical voice in the community. Yogthos - Again, prolific library author.
Rich Hickey, for creating the language and acting as a great filter of taste for the plethora of interesting computer science ideas from the last decades that should be prominent today, and creating a crystallization nucleation point for a community that itself reflects continued good taste in computer science and software engineering. I would be remiss in not acknowledging other influences both past and present in the community, like Tim Baldridge for producing tutorials/explanations of the core.async deep-walking macros that finally made macros and their incredible power clear, David Nolen for both fostering ClojureScript and introducing the power of logic programming to the community via core.logic, Alex Miller for being an active community link to the distant winds of the Clojure core development team, Michiel Borkent for Babashka plus innumerable small high power utilities it empowers, and many more who I cannot name.
From way back in the day, I've appreciated Fogus and CHouser for their work teaching and spreading Clojure knowledge. Likewise David Nolen, who I had the pleasure of meeting and talking with at an early Conj. Phil Hagelberg (technomancy) seems to be doing less with Clojure these days, but I have always appreciated his attitude and contributions. I can often tell a comment is his before looking at the author, just by its tone and outlook, and it's invariably thoughtful and interesting. I have not made as much use of the resources as I'd like, but I really appreciate Eric Normand's videos and writings. It's encouraging to see him working hard to expand and improve the Clojure audience. More recently, I really appreciate Michael Borkent (borkdude) and his myriad contributions to the Clojure ecosystem. Dude (pun intended) is really doing great work on lots of interesting things. It's great having him in the community.
So, so many people! - Tony Kay for his superhuman efforts on fulcro. - Wilker Lucio because Pathom rocks hard and well defined REST APIs are rarer than unicorns. - Chris Nuernberger for every library he ever blessed us with. - Alex Miller for all his community efforts - Jaret Binford for outstanding datomic support - Paula Gearon for fascinating talks and discussions - Jakub Holý for making fulcro more accessible to newcomers. - Daniel Slutsky who spreads so much joy in the CLJ data science community - Zach Oakes for his general awesomeness and introducing me to nim ;P - Michiel Brokent for all his libs really - lambduhhh A new, super kind voice in the CLJ podcasting landscape And so many more! Honestly, the CLJ Community is the most awesome one I've ever been part of. Also, a big shout out to everyone who blogs about Clojure, makes YT videos or streams on Twitch! :)
I took a big break from it this year and then found myself hacking on some small projects and fell in-love with it again. - It's really amazing that Nubank acquired Cognitect and has been putting everyone in a good position to make the language even better. - It's cool seeing people come from so many diverse languages like Java, Python, Ruby, JS, and others to compare notes with and experience their discovery of Clojure through. - Meeting people like Borkdude who seem like unstoppable machines in what they're able to build and maintain is really inspiring. - Alex Miller is still running his weekly deref blog, and I appreciate how much time he gives to answering questions, ask.clojure.org, and announcing the releases. It was comforting coming back into the community and seeing him continue to do what he does.
There's integration with pretty much every editor (although I only use Cursive, but I imagine it's important for other people) Rich Hickey, Alex Miller, Carin Meier and Stew and James Reeves (I'm thankful for the others too, but these are the names I remembered). And Collin of couse (from Cursive). The community is really friendly and patient. I don't remember the name, but there's financing for widely-used open-source projects, that's awesome. For such a "small" community there's lots of money flowing to individual community members, IMO that's something distinguishing and a thing to be proud of, leading by example! You guys are doing a great job! Thanks a lot! I've been tinkering with bash-autocompletion for clj lately, so hopefully I'll soon become a more "active" member of the clojure community.
Rich for Clojure and all the wisdom, Alex Miller - for everything he's been doing since forever (learned me some Java from the old tech.puredanger.com, thank you very much!), Stu Halloway - for being funny and giving great talks, @nikitonsy - for being amazing and inspiring, @borkdude - for everything he puts out (somewhat demoralizing), @danielwithmusic for Clojurists Together, Ray and Vijay for @defnpodcast, @danlebrero for https://danlebrero.com/2018/11/26/repl-driven-development-immediate-feedback-for-you-backend, Coling Fleming for Cursive, Dmitri Sotnikov for Luminus, @metosin for all the goodies, @ericnormand, @nonrecursive, @bbatsov, and many others. Haven't used ClojureScript yet, but I'm already grateful to David Nolen, Mike Fikes, Thomas Heller, Bruce Hauman.
In no particular order: - alex miller (this one is actually ordered. Take a bow) - hiredman - noisesmith (I hope he doesn't leave the community after funding circle. I feel like i see him less these days. I've told him I want to hire him when he's ready to return to the job market) - sean - ghadi - bronsa - eric dallo - thomas heller - quoll - borkdude - favila (more quiet these days but one of the best coworkers i've had and always so knowledgeable) - mfikes and dnolen. - of course rich hickey. I remember him participating in slack a little when REBL first debuted and enjoyed seeing him chat with people in Slack. He also chimed in to shut down someone acting very inappropriately in Slack. I felt bad that he needed to step in like that but I'm so glad he did.
Rich obviously. Alex Miller although he's a quite strange guy (to me). Ptaouniassis (sorry I don't know the spelling he's the author of Sente). Weavejester, Sean Corfield. I don't like Yogthos. What they did with clj-kit is awful. Choosing HugSQL instead of HoneySQL? Selmer instead of Hiccup? These guys don't understand what Clojure is about. At least the core does not tie our hands. (And the basic idea is cool.) I don't like metosin either. At first I thought they are cool but now I think they overcomplicate things. Sometimes. I don't like the fact that the core Clojure/CLJS devs seem to have this personal issue with theller of shadow-cljs fame. I think that shadow-cljs is rad (esp. that user guide). Deps.edn is ok but the design feels like Bauhaus to me.
Daniel Slutsky, because of his never-ending effort to bring new people to the language, even if they have little prior programming experience, and for putting enormous efforts into improving and coordinating the improvement of the Data Science / Machine Learning ecosystem in Clojure, and for being the calmest person I know and always not just answering but even appreciating questions by people with less experience. Arne Brasseur, for creating Witchcraft and bringing Clojure to the Minecraft world, for Lamdba Island, and for creating a bunch of very useful libraries. Martin Klepsch for cljdoc and improving the Clojure documentation ecosystem. Peter Taoussanis, for creating a bunch of libraries that are very easy to use and reliable.
Tommi Rieman & the Metosin team - malli is a really interesting and powerful tool with tons of great applications - I have found it useful for working with semi-structured data in a way that allows me to colocate parsing functions with data definitions by using encoders & decoders. Paula Gearon for her work on Asami, a powerful and supremely flexible database with wonderful documentation going all the way from the graph theory fundamentals to how to operate the database. Clojurists together for the work they've put in allowing major contributors to our community to earn money giving software back to the community. Making sure people can get paid to do open-source work is very important.
Thomas Heller - shadow-cljs is an incredible build tool that runs circles around every other build tool in every language I've used. Thomas is always quick to help in slack. I can't thank this guy enough. Michael Borkent - clj-kondo is invaluable. I can't imagine going back to the time when we didn't have clj-kondo linting as part of our CI process. Babashka is great too since I no longer have to write tools in bash. Eric Dallo - Like the other tools here, clojure-lsp is invaluable, and Eric is so helpful and responsive in slack. Bozhidar Batsov & cider contributors - cider is great and robust. There is so much incredible work that goes into. Also very helpful and responsive.
Rich: For gift of Clojure, and articulation/enforcement of Clojure community ettiquite. Alex is doing an excellent job of communicating between the community and Clojure Core team, there are impedance mismatches between these, and he handles with maximum possible grace. Sean Cornfield: all his contributions Borkdude: all his contributions thheller: for shadow-cljs, and continuing with little/no love from core cljs team ikitommi: for Maili, and construtively providing an alternative for those of us with different needs than currently targeted by spec juxt: for tick and xtdb eternal thanks to folk who got Clojurian-Slack history restored, this is HUGE
I appreciate the openness and helpful attitude of people. I also am glad there has been a clear voice of focus to what Clojure the language is. I believe it has kept the language tight, not bloating for every new paradigm, and slim. I am also very glad that types haven’t been pushed into the language as a requirement. Having them as optional and thru Spec is a much better approach and keeps the flexibility of a dynamic runtime language with option to add type info for optimization at the slow points if needed, much like Common Lisp has. I’m a old Smalltalk and Common Lisp user and very much dynamic and REPL oriented.
Brandon Ringe. Makes wonders for the Calva project. The way he gives user support and takes care of the user feedback is on the super professional level. Michiel Borkent. Always so helpful and supportive to the rest of us in the community. Bringing Clojure to new frontiers. Eric Dallo. So amazingly supportive and open to feedback. Taking responsibility for, and running the clojure-lsp project with such clarity and energy. Eugene Pakhomov. Fantastically helpful, amazingly knowledgable. The way he helps people learn about, and use, Clojure and ClojureScript helps Clojure and ClojureScript to be used in great ways.
I use and appreciate stuff from thheller (shadow-cljs), Sean Cornfield, ptaoussanis (timbre, redis), weavejester (so many things, including integrant), tonsky (data script), Jon Pither and the Juxt folks for XTDB, the gentleman behind Polylith whose name escapes me at the moment, and the many many kind folks that have humored me on Slack and elsewhere when I ask dumb questions after too many hours in front of a screen and getting up and walking away would have been the better choice. They are unsung heroes all. Oh, tip of the hat to Mr. Alex Miller for keeping the gears of the Clojure machine turning.
There are many outstanding people in the community. Rich himself is obviously a pivotal figure; Alex Miller does a lot for "public relations", as it were. As for the more "grassroots" part of the community, I'd be remiss not to mention Michiel Borkent vel borkdude for his outstanding contributions; Peter Strömberg, the creator of Calva, essentially enables my Clojure work… Frankly I could go on. I'll just drop one other name: a reddit/clojureverse user by the nickname of joinr, who's always immensely helpful and whose rants, usually on optimisation, I enjoy reading. Thanks for your hard work.
David Nolen for his work on ClojureScript and his good communication skills. (a bit sad that I havn't seen much from him the last couple of years) Clojurists Together for a great initiative. Peter Strömberg (PEZ) for Calva which (together with edamagit extension) finally made it possible to ditch Emacs while still having a decent developer experience. Thomas Heller for providing the awesome tool Shadow-cljs and very competent support as well. Michiel Borkent (borkdude) for his work on Babashka and clj-kondo Some clever and awesome people on Clojurians Slack who tireless answers questions.
Sean Corfield: totally welcoming and helpful on Slack and Clojureverse. Pez, likewise! I think the community would feel v different without both of them. Eric Normand for his great essays and podcasts, and detailed tutorials on setting up. Jacek Schae’s courses are really good: very clear and direct. Russ Olsen: his Getting Clojure is the best intro imho. Dmitry Sotnikov: his Web Development book (which i’m working through now) is not just a great intro to Clojure web dev but for web dev in general. Last but definitely not least, Zack Teo for his generous help to me as a noob.
- @thheller - ShadowCLJS - Jacek Schae - Pretty much I learned 80% of the stuff I use from him, also has a great podcast - p-himik on Clojurians Slack: This guy answers ALL the questions on the React/Clojurescript side of things. I don’t know if he has any paid products but we need to pay him for all the work he is doing @vishalgautamm - Youtuber building Frontend apps Arne Brasseur - Lambda Island - Another great resource I found. To this day, this was the only place where I could find some info on creating JWT auth style with Google, Facebook OATH2 implementation
First to everyone on the core team for making all of this possible. Then to Michiel Borkent and Bozhidar Batsov for their fruitful and outstanding OSS work as well as the numerous heroes who put their time into building essential open source tools for the community. Special shout-out to all the great minds that have contributed to frameworks of all kinds which definitely have their place in the ecosystem despite the simplicity of Clojure. To Jacek Schae for his quality podcasts and courses. Last but not the least, a big thank you to everyone in this wise community.
Michiel Borkent for contributing to and inspiring so many new projects. Eric Dallo for being such a welcoming maintainer of clojure-lsp, a tool which has become central to my workflow. Bozhidar Batsov for maintaining more important tools. Alex Miller for handling the most human and most technical parts of this community with equal aplomb. Jared Binford for unknotting Datomic problems with a smile. The rest of the Datomic team for making AWS livable. Nice database too. ;) Everyone else… how lucky are we to have such a nice language and generous community?
- Alex Miller for providing thought provoking answers with his deep knowledge of Clojure. - Colin Fleming for maintaining and improving Cursive all these years. - Daniel Compton for creating Clojurists Together and continuing to volunteer his time at the organization. - Ghadi Shayban for making sure you have a problem statement. - Martin Klepsch for cljdoc. cljdoc has grown to become a tool I use nearly every day. - Sean Corfield for, somehow, always being online, even to the wee-hours of the night, and happy to answer questions or just chat.
Rich Hickey - for his deep thoughts, inspiration. Alex Miller for his work, strong and continuous contribution to Clojure community. Stuart Halloway for his great witty talks and verbal punches in twitter. David Nolen for his great and inspirational talks and clojurescript contribution Bozhidar Batsov for his exellent dev-tools Bruce Hauman for amazing dev-tools and rare but great talks Mike Fikes for contribution in clojurescript comunity. Nikolay Rizhikov for contribution in Russian clojure comunity and clojure popularization
I liked the guys who ran re:Clojure conference. It was very inclusive and the talks were awesome. I appreciate borkdude (Michiel Borkent) for his prolific contribution to Clojure, Bozhidar Batsov (bbatsov) for CIDER and Martin Kavalar for his work on Clojure notebook just to name a few. Others than I can name are Christophe Grand (@cgrand), Peter Strömberg, Sean Corfield for their contribution on the Clojure ecosystem. And last but not least Rich Hickey for creating this awesome language and his inspiring talks, etc
The Clojure community contains the highest concentration of experienced software engineers that I've ever seen in a PL community, so it's a great place to learn, regardless of what language you're using. The Clojurians Slack is also an incredible community. You're able to talk with the maintainers of most of the ecosystem's important tools and libraries, that's something I haven't seen in any other community. It makes it really easy to learn the tools and contribute to them. If you have a question, you can just ask!
- slashdevslashrandom - super helpful and friendly, has spent a lot of time in DMs helping me out the past 2 years ever since I was just getting started with Clojure. Also in part because of them that I learned Clojure in the first place after using Racket. - Joshua Suskalo - Super helpful in Discord and made the main Clojure Discord community - Sean Corfield - super helpful in Discord and has made so many libraries and contributes to others - Borkdude - babashka and contributing to so many other libraries.
I like (it seems at least) that people using Clojure are thinking way longer term than people using JavaScript. They give 'love' to their codebase, and improve incrementally. (For instance, the new syntax of functions of maps is a great improvement. Not a bad revolution were everything you learnt is destryed.) I'm reading a book about React dated from 2019 ; it already seems outdated ! (They don't use 'class' components anymore, so what about the structure of the code ?) This is too fast a fashion for me.
Michiel Borkent - great attitude, generous, makes everyone's lives better Jordan Miller - I love her authenticity, enthusiasm, and generosity Arne Brasseur - he's creating a wonderful environment w/ Lambda Island Paula Gearon - she's very helpful and Asami is top-notch PEZ - I appreciate his generosity and focus on helping beginners Sean Corfield!! - I use many of his libs, and he's such a great source of support Paulo Pfedrippe - his Recife library is very helpful, and he himself is very helpful
https://github.com/seancorfield next.jdbc and honeysql are fantastic libraries for those of use still stuck with SQL. The documentation is fantastic and Sean is always very helpful on slack. https://github.com/borkdude gives clojure more reach babashka and graalvm trailblazing. Not having to write bash and being able to use graalvm for tools has been great. https://github.com/thheller makes clojurescript a lot less painful. Honestly, clojurescript has too many sharp edges without shadow-clj.
Alex Miller - obvious ; ) Sean Corfield - obvious ; ) Ghadi Shayban - for the ever-present reminder of "what problem are you trying to solve" (Alex also does this :) Wilker Lucio - for pathom and fulcro inspect Tony Kay - for his work on Fulcro all the docs and always being available for help Paula Gearon - for being a one-woman datalog DB production studio Huahai Yang - for being a one-man datalog DB production studio Thomas Heller - for shadow-cljs Mike Thompson - for re-frame
So many people! The whole core team, especially RH obviously and Alex for the reasons above. Borkdude is a huge standout in the past couple of years; Babashka, clj-kondo, and his other projects have been phenomenal. All the regulars on Clojurians slack, the admins, and especially all the people who help out in #beginners. All the folks who have written and contributed to the libs I use every day. The Clojure art & music contributors. The whole community is pretty wonderful :)
Taoensso for his work on niche libraries and sheer amount of responsibility, sean corfield for his work on next.jdbc and for being quick and reliant answering questions from the community, chris miller self explanatory, thheller for designing and maintaining shadow-cljs which makes cljs just a dream to work with (makes cljs simpler than javascript) and of course Rich Hickey for creating and designing the language and working hard to make it what it is and can become
Everybody who sponsors open-source projects and contributors. It is amazing that more people can support their living from contributing to Clojure ecosystem. Cognitect for long-term Clojure stewardship. All people who support Clojure in their organizations, contribute code, experiment and write amazing libraries. Thanks for writing Clojure Deref and experimenting with new formats like "Clojure 1.11-alpha4 chat" video. It is important to know what you are working on!
I don't even follow Daniel Higginbotham, but I just loved his book. It's nice to read and holds my attention, so I think he is a person I appreciate in the community. Of course, Rich Hickey is a person I admire too, I don't even need to say why haha And I also have a coworker in Nubank who I really appreciate and who helps me a lot with Clojure: Felipe Thome. He's my focal point here about Clojure, he's always helping me understand and giving me feedback on it.
Peter Stromberg, for making a Microsoft editor sing the Clojure tune. Bozhidar Batsov, for sharing the Cider Orchard and sparking a new golden age of editor plugins. Michiel Borkent, for pressing the limits. Chas Emerick, Brian Carper & Christophe Grand, for the book that applied literary-criticism technique to show how Clojure is a thematic work of art, not just 850 random functions. Stu Halloway, for his tireless tweeting. Rich Hickey, for easy vs simple.
First, I appreciate all the developers who provide resources (libs, tutorials, slack-responses, ...) Second, I would specifically note that I appreciate non-open-source technologies like Datomic and Cursive, although I am not the target for their commercial products and would benefit from open-source solutions. I understand that people need to eat and want to profit from their work. Having said that, I am very grateful of open-source sponsoring.
Focus on design, backwards compatible/stable ecosystem and the friendly community. These things are valuable because I can spend time coding and not worrying about a random breakage somewhere and it gives me confidence that I can use many open source libraries as learning material. Finally, knowing there is a place to go when I have questions is amazing. Clojure draws experienced developers and they are willing to share their knowledge.
Alex Miller: It's so cool seeing someone super in the middle of the language helping people out in the slack. Sean Corfield: Well talk about helpful! Michiel Borkent (borkdude): I really appreciate bb and all his contributions everywhere, also he's very newb friendly when we try to help. Carlo Sciola: He's hosted over 130 or so consecutive meetups (over 10 years of contiguous meetups).. arguably the biggest reason I have a job today.
Michiel Borkent Bozhidar Batsov Léo NOEL (maybe an alias) (@leonoel on github) - he's building an ambitious and intriguing concurrency library for clj and cljs Nikita Prokopov - if his work on a clojure UI framework gets finished it could be a great way to use clojure to build desktop apps Christophe Grande - if his work on the clojure -> Flutter compiler gets finished it could be a great way to use clojure to build mobile apps
borkdude because of babashka, et. al. That really gave Clojure a boost to me, due to it filling a new niche. Sean Corfield because he is so helpful and knowledgable on various platforms Mikes Fikes for CLJS on embedded (and before that planck) Alex Miller for being ever present and helpful on reddit and Ask Clojure and various other people for their great libraries and Clojure(Script) core work that helps me every day.
Core team members who participate discussions on Clojurians Slack. It's an endless effort but I see active communication between the core-team and the community very valuable. It's a useful feedback loop for both. Also I appreciate all members who put time and effort in helping others, creating and maintaining high-quality libraries, giving conference talks etc. Their efforts keep the ecosystem evolving every day.
Too many to list but the one who really helped me tap Clojure's super powers is Bozhidar Batsov. I could never get Slime to work and I agonized over it. Then along came Cider and before long I was jacking into Clojure and genuinely feeling and developing like a pro. Of course Rich and Stu continue to motivate me with their outstanding talks. And you too, Alex - your engagement on the forums is priceless.
Thank you to the Clojure core team for your continual work on improving the lives of Clojure developers! I'm loving all the recent changes, and have used both "iteration" and "parse-double" in the last couple of weeks! I think the Clojure community is one of the most pragmatic and innovative communities I've ever seen — kudos on helping foster such a vibrant community with so many shared values. --Gene
Who don't I appreciate? ;-) * Fulcro maintainer Tony Kay - for all the value he brings with * Fulcro contributors Jacub Holy and others - for community building * Jeremy Taylor from Juxt - for helping out with Crux adoption * Sean Corfield - for being a force of nature in the community * Alex Miller - for obvious reasons * the Polylith guys - for helping out with Polylith adoption * ... many others...
The person I appreciate the most in the Clojure community is James Reeves (https://github.com/weavejester). I use probably 2-3 of his open source libraries in every project I do, but he has a good half dozen projects that are practically ubiquitous among Clojure projects. The fact that he not only developed all of these, but is also willing to maintain all of them, is beyond commendable. Thanks James!
Everyone, really. I spend most of my time at Clojureverse so I'd have to give a shout-out to Sean Corfield, didibus and WebDev_Tory for being fantastic resources, deep thinkers and just great people. Gigasquid for being an inspiration to all of us. I appreciate Eric Normand's work. And of course Rich Hickey for making his programming language into a philosophical exercise as well as a practical tool.
Rich Hickey for creating the language, giving inspring talks and most importantly for changing the way I think about software development, Alex Miller for his clear explanations on various forums, Michael Fogus for this book Joy of Clojure, Tony Kay for his great YouTube videos on Fulcro, Nikita Prokopov for creating Datascript and fixing bugs quickly, https://github.com/gnarroway for creating Hato
- Rich Hickey for having the courage to take a sabbatical and build something and keep at it despite some people hating on clojure on reddit. 2) Alex Miller for being very active and answering questions on twitter and slack. Alex is amazing! 3) Oliver Caldwell for writing conjure. 4) Borkdude.... (Need I say more?!) 5) Daniel Higginbotham without whom I probably would not have learnt clojure.
The community (on Slack) is relatively active, welcoming and helpful. The community feels a lot more "mature" than other programming communities, but perhaps a bit too "stern," not as "fun and bubbly" as the Ruby and Elixir community, for example. The Clojure community is very helpful, which is great, but perhaps it does not feel as approachable as some other programming language communities.
Alex Miller is always willing to engage and educate. I think he has been an excellent and balanced representative (aside from dev duties). I really like the work the SciCloj folks are doing; they are pumping out libraries and workshops for an ecosystem that has been sorely overlooked by most of clojure (some of these like tech.ml.dataset are entering best-in-class territory).
Arne Brasseur - constant output Sean Corfield, hiredman, Will Acton - help on Slack Oliver Caldwell - for vim-conjure Michiel Borkent - for clj-kondo and bb Bruce Hauman and Thomas Heller - for their tireless work on maintaining the cljs build pipeline Alex Miller - for constant help and setting a great tone for the ecosystem Chris Badahdah - portal has been such a huge help
Rich Hickey (creating and maintaining the language), Alex Miller (helps maintain Clojure community, communication about what's going on in Clojure, question answering), Michael Fogus (Joy of Clojure + work + writings), Jacob O'Bryant (Biff, interesting writing), David Nolan and Mike Fikes (ClojureScript), Christophe Grande and Baptiste Dupuch (Clojure writings, ClojureDart).
Rich Hickey (very original thinker), Zach Oakes (odoyle-rules got me excited about rules engines), Dan Stone (my colleague, creator of relic, exceptionally Clojure/FPer), Sean Corfield (prolific contributor of plenty of libs I use every day), Eric Normand (love the way he goes through famous papers on his podcast), the defn guys (good Clojure podcast) - so many smart people!
Alex Miller - helping to beginners, articles, videos, development of clojure itself. Sean Corfield - helping to beginners, development and maintaining nice clojure libraries Michiel Borkent - helping to beginners, development and maintaining nice clojure libraries Bruno Bonacci - organizing clojure meetups. and many others. The community in general is very nice and friendly.
Fogus. He's always writing something insightful. And he's a contributor to the code. Alex Miller. He does a good job communicating what's happening within the community. Martin Kavalar. He is showing a better way towards building and documenting apps while also leaning on lessons of the past - knitting together other projects in the ecosystem while also giving ample credit.
Sean Corfield for his invaluable support on Clojurians Slack and elsewhere. Same for Alex Miller, Dan Sutton, and a bunch of other Clojurians "grey beards". Michiel Borkent, Eric Dallo and Oliver Caldwell for their epic developer tools that I use every day: babashka, clj-kondo, clojure-lsp, Conjure. Rich Hickey, for his vision that improved all our [programming] lives.
Uh there's so many people. Obviously the core team for digging up old ideas found in other languages and ecosystems and trying to adopt them in a modern manner. People behind may daily tools: ring, re-frame, figwheel, jdbc.next, etc etc. All those people made working in the Software industry fun and exciting again. I'm grateful for all their hard work. Thank you!
Sean Corfield for his "statesmanship" (I think of him as the Benjamin Franklin of the Clojure community) and his helpfulness on Slack Alex Miller for his work on everything and his helpfulness on Slack pez for Calva Eugene Pakhomov (p-himik) for always patient help on Clojurians slack Michiel Borkent for his excellent contributions metosin's excellent libraries
Rich Hickey for creating and designing the language Bozhidar Batsov for creating Cider and the Emacs tooling Michiel Borkent for creating various of tooling for Clojure Arne Brasseur for creating various libraries Martin Klepsch for creating the cljdoc project and the mentorship James Reeves for creating various libraries Carin Meier for the Living Clojure book
Far too many to do any of them justice! The community is great and always helpful. There are authors of FOSS libraries which go out of their way to keep their projects shiny and even spend their free time to help users, even if they just commit beginners' mistakes. And the core developers, always improving the language thoughtfully. I would not want to choose.
Alex Miller for... well, everything. His leadership on Clojure has been great, and the fact that he makes himself so available to the community has been a fantastic resource. Sean Corfield, Dan Sutton, Peter Strömberg, and the rest of the admins of the Clojurians slack. Their hard work at creating a productive and pleasant community is much appreciated.
This will be an essay length answer, but if I had to pick one stand-out character for FY 2021, it would be borkdude. He added a whole new scripting piece to the Clojure story, and apart from being prolific, he is just a nice dude. A wonderful role model. I hope he experiences the joy and creativity he has found, for years and years to come. _\//
Rich Hickey is awesome. Listening back to his Conj talks etc. has completely changed my thoughts on programming. I was an OO enthusiast before I first listened to one of his talks, and it took months of immersion in Clojure and his talks for me to feel comfortable and confident both with Clojure-flavoured-FP and with all of the power that gives you.
Michiel Borkent: endless font of encouragement, help, knowledge, timely reponses and a lovely person to interact with. Bozhidar Batsov: for building such a great emacs integration in cider Thomas Heller: for improving the experience of cljs compilation so much Rich Hickey: for making clojure open and accessible to all and continually improving it
It's because people want to genuinely help each other. Also, people in the community are knowledgable, they don't answer to questions that they don't have a deep understanding. Also, I like the fact that people like Alex Miller or David Nolan are easily reachable through Slack, even though most of the time other people can answer the questions :D
Of course, love all the old videos from Rich Hickey. His thoughtfulness about everything really sold me. Many other videos from users and the core team as well. Current people in the forums that seem to know the most and post quite a bit like Sean Corfield. On Youtube, Fred Overflow's channel has been super helpful to thinking in a "Clojure" way.
Borkdude unlocked clojure for so many more use-cases - it's now getting into all of my projects regardless of language, b/c a bb.edn is the best task runner there is! It's also supporting a custom window manager that I've layered on top of awesomeWM. I just want clojure everywhere, so I super appreciate the increased portability sci enabled.
Oh, so much. I find the average Clojurist to be thoughtful, respectful and wise. And saying that in general is just so weird. The Clojure community has a fantastic "great idea" density. And the people are interested / welcoming too! Great job by Clojurians / Clojureverse mods. And great that the core team spends time with the community. 🙏
Rich, Stu and other Cognitect crew. I appreciate sticking to the core message and keep Clojure something I can rely on for 10 years now. I know it's hard to resist the pressure to do new, shiny things or make things "easier", but I super appreciate knowing of all the things that are going to break, my language is probably not one of them
In the last year I asked if anybody would be willing to give me feedback on my ClojureScript repos to help me level up. I got amazing feedback from two different community members. Both of them gave me high quality feedback in a very humble and nuanced way, discussing tradeoffs etc. I am so impressed with the wonderful Clojure community.
So many people. Of course Rich Hickey for creating Clojure, David Nolen for maintaing CLJS, Borkdude for babashka, PEZ for Calva and certainly Daniel Compton and team for Clojurists Together. Clojurists Together is absolutely brilliant and I am so grateful to them because I know they are helping to improve and maintain our ecosystem.
Rich Hickey is one of the most insightful people I know who’s willing to share that insight in broad ways. Peter Strömberg for making and maintaining Calva which provides a pretty great Clojure experience. Everyone who gives talks or writes content about Clojure and helps me and others navigate the awesome stuff Clojure has to offer.
Sean Corfield - super helpful in the #tools-deps Slack channel and his tools projects have been a life saver Borkdude - just all libraries and projects he maintains Jordan Miller - the variety of people she's had on her podcast and the podcasts she's been on have introduced me to a huge array of Clojure and Clojure-adjacent people.
Tooling and getting help is very important during development. And I think there is no person who influences this more than borkdude, as you already know I think. Also @PEZ's work on Calva is awesome and I hope it improves and gets more features. I am sponsoring both on GitHub, because they provide so much value for the community.
It's a community of practical people who use Clojure at work and have a life outside work. Clojure gears toward allowing us to have a life outside work through these properties. (Just examples not include everything) - Stable and backward compatible - Fast development time - Ease of debugging - Low complexity code - Stable runtime
Alex Miller for giving us insight at Clojure core team works and for his help online. Bozhidar Batsov for all his work on editor/repl tooling. Sean Corfield for his bleeding edge experience reports on his blog. Michiel Borkent for his work on tooling. Everybody behind very helpful libraries: Metosin, Juxt, Lambda Island, Funcool
Rich for being willing to attack big problems with the simplest problems. Pure danger for taming the tigers. Fogus and zach tellman for bringing deep thought to the platform. Borkdude for taking it all in new directions. So many more! The funcool crowd, weavejester and metosin. Wouldn't be a fun place to code without them.
The amazing core and Cognitect team, who continually expand and make Clojure the most fun and simple language to work with. Daniel Slutsky and the #data-science group who are building amazing data tools to work with Clojure and always super positive and helpful. Everyone really, it's an amazing language and community.
Borkdude: clj-kondo is a huge tooling improvement, as is babashka Alex Miller: He is the voice of the community and his presence drives a lot of Clojure work Sean Corfield: His libraries are excellent and he is the "working outside Clojure core team" (therefore unbiased in some sense) voice of the Clojure community.
borkdude is just hanging on slack answering my questions + literally updating babashka with some new feature I ask for within 5 minutes. Also the datomic team in #datomic slack. Also Joshua and Jonny on discord. And quite a few others on slack answering questions - amazing. Alex Miller and Ben Sless come to mind.
Everyone. especially on slack. Day8 for writing killer documentation. Alex Miller for constantly answering noob questions back when I was learning. The juxt crew for building useful thing after useful thing, higgenbotham for writing one of the best how to program books ever. And rich himself for the whole thing
Alex Miller for all the hard work he does Rich Hickey for having a steady hand in guiding the language Borkdude - For Babashka - increasing Clojure's reach into scripts Chris Nuernberger - for extending Clojure reach into python and Data Science Daniel Slutsky - for creating a community for Clojure Data Science
Alex Miller, in there every day helping new users happily pez, helps new users, and almost daily improvements to calva wilkerlucio, pathom is amazing for working with multiple data sources borkdude, the sheer amount of code he outputs, and he is always supporting clojure, clojurescript and all his own libraries
Rich Hickey, Eric Normand, Daniel Higginbotham Arne Brasseur, Sean Corfield, Alex Miller, Daniel Slutsky. Many others. Those names just popped up first. Rich, Eric, Arne, Daniel Higginbotham and Alex for the guidance their work provided me. Sean and Daniel Slutsky for the gigantic dedication to the community.
I really appreciate the openness and helpfulness. I also appreciate the stability of the overall software stack. That includes core library as well as other libraries. Stuff just works, and it keeps on working, which means there's a huge amplification factor as you are able to build on that stable foundation.
Alex Miller for keeping the development of clojure going and answering many questions. Michiel Borkent for working on and promoting graal vm based native executables - clj-kondo and clj-lsp make a big difference to clojure development and wouldn’t work so well without being compiled. And of course babashka.
Everyone is really helpful, the community stays both positive and casually professional without becoming stuffy or unfun. Alex Miller is a constant source of helpful interactions and wisdom and is a major reason why I’ve stuck with the language as some of the other devs can be brusque to the point of rude.
technomancy is a pretty rad dude who not only wrote a lot of pretty important clojure tools, but is also a good steward of the communities he maintains (Including not ignoring issues of privilege and other problems that can cause some communities to fester--something I feel Rust is also really good at)
Rich Hickey - Just can't praise RH enough. He really changed my brain for life. Clojure slackers: The clojure slack is such an amazing resource. I'm surely missing tons people, but here are specific people that immediately come to mind: Alex Miller hiredman Ben Sless Sean Corfield quoll lilactown ghadi
Dragan Djuric - Neanderthal, DeepDiamond, Bayadera. SOA number crunching, DNN, and prob programming - and in Clojure! Chris Nuernberger - dtype-next, tech.ml.dataset stack. SOA C interop and dataframes - and in Clojure! Daniel Slutsky - all around and tireless Clojure data science community organizer
@borkdude, he's responsible for remarkable tooling that makes clojure more accessible for everybody, @bbatsov, because cider rocks Sean Corfield, because he's been everywhere since pretty much the beginning Alex Miller, he's keeping everything together it seems and many more, it's a great community.
Borkdude for his prolific contributions and for making Clojure usable in more places Chris Nuernberger and Dragan Djuric for dramatically improving the state of numerical and scientific computing ecosystem for Clojure Daniel Slutsky for his community organizing in the clojure data science space
Borkdude for his productivity Praticalli for the endless stream of tutorials Tonsky for rum and everything else Taoussanis for his libraries and kindness BBatsov for Cider Sean Cornfield for clj-new Alex Miller for the community effort but really, there are so many great contributors out there
Rich and Alex for their experience and wisdom in guiding the language and community hiredman, seancorfield, and ghadi (plus others too many to mention) for answering technical questions and giving general open-ended advice in slack borkdude for his prolific contributions in the last year or so
Rich—his decision to to assume the role of BDFL gives me confidence the language won't go off-piste at the hands of some well-meaning committee. He is also a truly excellent teacher: I have learnt more important engineering lessons from his YouTube videos than anywhere else by a large margin.
I am not well versed when it comes to the community, but I can say that it consists of professional people who hold themselves to high standards (that's probably influenced by the language's high quality itself). They don't act in a toxic manner and don't come across as elitist. I like that.
The documentation, clojuredocs has been the main way I've learned Clojure. Or when I was trying to learn the tools.build I couldn't get it, then the blog was update and the new code worked. It was really nice to have an example of working code and also working code that follows best practice
Alex Miller — for his hard work organizing releases, communicating with the community, teaching Sean Corfield — for answering questions and providing examples of well-thought-out libraries Robert Stuttaford — for being a shining beacon of positivity and seeking to build the Clojure ecosystem
Colin Fleming has been doing great at maintaining a highly usable editor experience in IntelliJ. I would also like to thank the whole clojure and clojure tools team for always finding elegant solutions to thorny problems, like tools.deps and datafy (just to name two relatively recent ideas).
Rich Hickey and other Cognitect engineers for the mind blowing presentations. Borkdude for being so active in the community and for maintaining Babashka. Tonsky for some very interesting articles and for suggesting a 2 spaces indentation for Clojure :) Colin Fleming for the amazing Cursive.
Wow. The list is long. Sean Corfield, Borkdude, Alex and the core team, Rich for being such an amazing inspiration, Pez, Didbus, ...essentially everybody who hangs on the beginners channel and just makes such an amazing job of being relevant and friendly and making people feel welcome.
Borkdude as he is contributing with many tools and is always available to help people in Clojurians Slack Ericdallo as he improved a lot about clojure-lsp, which is helping me for the linter issues Thheller as he did a great work in shadow-cljs and is always helping people with issues
A lot of people, it's very welcoming community. But since I mainly do web then Sean Corfield for being very active and helpful user of ClojureVerse, Weavejester for creating many helpful libs, Eric Normands for PurelyFunctional.tv, Daniel Higginbotham for BraveClojure and other books
In general, I appreciate every contributor. In particular I appreciate metosin for their simple libraries (I don't use spec) and re-frame creator for the simplest UI framework. I appreciate david nolen for core.logic, but the library needs maintenance and better documentation.
Eric Normand - Books, podcasts, online courses, excellent educational material Alex Miller - Community outreach, language development Rich Hickey - Public speaking, language development Mia - Community outreach, podcasting David Nolen - Public speaking Mike Fikes - Podcasting
I admire how innovative the community feels, and how many different approaches they took to explore how to do better software. Definitely I'm a better programmer today thanks to all I've learned in Clojure-land - even when using other languages/ecosystems! Thanks a lot! 🙇
Sean corfield, Eric dallo, Alex miller, Eugene Pakhomov, John Practicalli, lilactown (will), Vemv, Dp sutton, ghadi, hiredman, andy fingerhut, quoll, and likely some others i'm forgetting .... but basicall the people on slack who are kind enough to help teach me and others!!
The fellows that produce the Functional Design in Clojure podcast, especially the series on Clojure Core. It's AWESOME!! I've learned so much and felt comfort knowing I'm not alone with the struggles I've had. Too bad -- it seems like the are not producing anymore episodes.
Daniel Higgingbotham for "Clojure for the Brave and True" Eric Normand for his Clojure courses Peter Strömberg for Calva (Calva made my Clojure learning curve so much better) "on the code again" for his great YT channel Rich Hickey for creating Clojure and his great talks
The easier question to answer is "What is the set of people you depreciate in the Clojure community?" Answer: #{ } Most recently I would have to say "everyone in the visual tools community" because of the amazing creative energy and support everyone has for each other.
Borkdude for all his efforts in bringing Clojure onwards to new territories with SCI, using it with native-image and nbb. Really approachable nice guy that has done a lot :) Christophe Grand is also a really nice guy and has been a pleasure to meet in person even :)
- Everyone at Cognitect for stewardship - Bozhidar Batsov and cider team for clojure editing tools - David Nolen and Mike Fikes for Clojurescript - James Reeves for Ring/Duct/Integrant - Tony Kay for Fulcro - Wilker Lucio for Pathom - Thomas Heller for shadow-cljs
Tony Kay for his outrageous work on Fulcro. Wilker Lucio for Pathom. Peter Strömberg aka Pez for all that is Calva. Too many conference speakers to list, but so many have been massively in helping lay a more design-oriented/functional philosophical foundation
Alex Miller is a wonderful face of the technology. One million thanks to him. Dmitry Sotnikov for Luminus/Kit and so many more things. Daniel Compton for ClojuristsTogether and so much more. Christoph Neumann & Nate Jones for the podcast (hope it returns!).
- Michiel Borkent / Borkdude for his continuous flow of useful contributions - Jakub Dundalek for trying to build a modern shell based on Clojure - Alex Miller for his consistent stewardship of the language - Rich Hickey for everything that Clojure is today
There are just some amazing people doing basically a 24/7 job and trying to help. It of course doesn't always help but that is how it is. The great thing is, Clojure is so clear, I mostly just don't need to interact with the community to be productive. :-)
- Kyle Kingsbury ("Aphyr")'s Clojure from the Ground Up is a resource I revisit and learn new, subtle things. - Alex Miller does a great job of trying to show more of "how the sausage gets made" via Inside Clojure, Deref, Clojure 1.11.0-alpha4 chat, etc.
Eric Normand for getting me up to speed and giving great advice on building a career. The writers of Clojure documentation who manage to capture a lot in a short page. The team I work with for sharing knowledge and showing neat ways of solving problems.
- Alex Miller for the tireless maintenance and development of the language, plus the always extremely friendly an helpful support on forums etc. - Arne Brasseur for his blog, the useful libraries and the playful approach to Clojure (i.e. Witchcraft)
Colin Fleming because Cursive is a great clojure development environment that lets me effortlessly decompile and debug Java code with which we are interoperating. Michiel Borkent because Babashka makes Clojure usable for scripting and fast tooling.
Eric Normand got me into the language. I discovered his articles, blogs, newsletters, and youtube videos while I was learning FP as a JS developer, and they were hugely influential in my decision to adopt Clojure and Clojurescript for my own work.
Sean Corfield. He builds a lot of libraries I used daily, share his IDE setup and spend a lot of time answering question on Slack or github. The whole metosin crew. They do excellent libraries like malli and reitit. The ClojuristTogether iniative.
There are too many people to name them all, but the people on Clojurians Slack are extremely helpful, and several library authors are also extremely approachable and responsive to queries and concerns. I'm glad to have gotten exposed to Clojure.
Loving the maintainers involved in clj-kondo, clojure-lsp and shadow-cljs. Thomas, Borkdude... the tools are making a big difference to the real lives of developers and their engagement with users is inspiring. Colin/Cursive is exceptional too.
- Michiel Borkent. Creativity and productivity are inspirational. * Alex Miller. Being a constant calming presence and representative of Cognitect/Rich Hickey. Other people I admire - Sean Corfield, Carin Meier, Arne Brasseur, Eric Normand
Tonsky because he makes a lot of cool Clojure tools and frequently writes about them. Clojure commons and Metosin for maintaining a few but fantastic Clojure libraries in a centralized location. weavejester for his work on Ring and Hiccup.
Alex Miller has a great presence on e.g. Twitter, Slack and Podcasts, making Clojure graspable. Sean Corfield provides exciting insights into Clojure as a main systems language. Mike Fikes does some great work on leveraging ClojureScript.
Lots of people, To name just a couple @borkdude and Daniel Slutsky. The first for babashka, which give me a new uses case to apply Clojure, replacing bash scripts. The second for the push in creating a community around AI/ML using Clojure
Daniel Compton for his work on funding important development in the community. Michiel Borkent for his creativity and friendliness. Eugene Pakhomov (p-himik) for his persistent and friendly efforts on helping people get unstuck on Slack.
It seems people have dealt with the big project issues. Distributed, async, event based systems for which there quite a few build in solutions (for instance namespaced keywords, core.async) or libraries (phantom, datomic pull library).
Christophe, smart. Heller, great docs and great tool Reagent guy, slick integration that's so clojure. Juxt, I'm getting into XTDB. Bork dude, he got me off of she'll scripts. That dude who wrote magit and many others is a clojurian.
A language seems to live and die by its communities ... at least thrive, if not survive. I feel that the whole Clojure community is supportive, engaged and very helpful. Props out to all of those Clojurists who help other Clojurists.
- Borkdude: a devops magician who increases the Clojure reach to more and more platforms and is very creative (it's inspiring). - Alex Miller: nice support and dedication to the community thanks it's good to see you're always around.
Rich Hickey for so many reasons. Alex Miller, especially for being a bridge to the wider community. Daniel Compton, especially for Clojurists Together Michiel Borkent, for making Clojure so much easier without sacrificing simplicity
ive been learning clojure since 2016 and i think the community is helpful, mature, open minded. appreciate cider/bbatisov, babshka/borkdude, compojure/reeves, luminus/yogthos, reitit/metosin, alex miller/general help, and many more.
I have deep gratitude for the kindness fo the people in the Clojure community. The expertise and problem solving ability is a constant in dealing with Clojure devs. I appreciate having so many experienced devs working in the space.
wavejester, Sean Corfield for their excellent libraries and community support. Daniel Compton for popularization and best Clojure podcast. Nikita Prokopov, for developing Sublime Text plugin, and for desktop UI framework Humble UI.
Sean Corfield- provides great libraries and I come across a ton of useful advice from him. Dmitri Sotnikov- the Luminus and Kit frameworks have been super useful, and he writes a TON of great documentation. Very much appreciated.
People are open, nice and welcoming. They are also helping each other and there is a feeling of people being expert and experience in the domain, and I can always learn from them. I am happy if I can contribute back in any form.
I have yet to meet a Clojurist who did not have something great to teach me or show me, picking any particular name would be just because I saw them recently on Twitter or whatever. Best community top to tail, in my experience.
Alex Miller, for so frequently answering questions, including ones that only he knows the answer to in Clojure internals. Sean Corfield, for his helpfulness and friendliness. Eric Normand, for producing good training materials.
Alex Miller truly the heart and soul of Clojure community, grateful for his involvement every day :) Daniel Slutsky for being one of the main driving forces in SciCloj community All of the authors of clojure libs and tooling ;)
Rich Hickey Alex Miller Michael Fogus Sean Corfield James Reeves Michiel Borkent Bozhidar Batsov Tommi Reiman Peter Strömberg Brandon Ringe Eric Dallo Eric Normand Nikita Prokopov Dmitri Sotnikov Thank you for your hard work!
Alex Miller is kind, pragmatic, and a great interface to the community. Rich Hickey is unmatched in his technical wisdom and ability to communicate his vision. David Nolen and Mike Fikes tirelessly maintain and improve CLJS.
All the unpaid lib authors (and consumers) that respond to questions in Slack. Too numerous to name but standouts are: Thomas Heller Borkdude Tommi Reiman Nathan Marz Karol Wojcik Rafał Krzyważnia Francis Avila Mike Thompson
Daniel Slutsky for his organizing efforts around building a visual tools community! Eric Dallo for his awesome work on clojure-lsp! Thomas Heller for his great work on shadow-cljs! Michiel Borkent for clj-kondo and babashka!
I'm very thankful for all the dedicated Clojurians - on all levels - and all the time and effort they have spent and are still spending on the language itself, tooling, libraries and so on. There are too many to mention.
I have immense respect for all the core team members/contributors, for obvious reasons. Lately I have appreciated Arne Brasseur for Kaocha testing framework, it has materially improved my testing life in the last year.
seancorfield, borkdude, srasu, alex miller, rich hickey, and everyone else who's active in the community developing the language itself, the tons of great libraries we have or helping people out in Slack and Discord.
Alex Miller, for his slack and newsletter comms. C. Fleming for cursive and his activity in the cursive channel. p-himik for help in the re-frame channel. The whole Advent of Code channel for fun, kindness, education
Alex Miller for his work as the visible face towards the community beyond the work in Clojure tooling itself, Bozhidar Batsov for CIDER and the style guide, Peter Strömberg for Calva and Thomas Heller for Shadow CLJS
Rich Hickey, Stuart Sierra, Stuart Halloway, David Nolen, Mike fikes, Michiel Borkent, Weavejester, Taoensso... Maintainers + OSS Developers. These are the people/aliases that come to mind and make this stuff work.
Of course borkdude, Mike Fikes, David Nolen, Thomas Heller, Fogus, bbatsov. On the Clojure/JVM side it seems like we've lost a lot of good talent as people have moved on. Not many interesting areas left to explore.
- Michiel Borkent - Eric Dallo - Alex Miller - Sean Corfield Amazing people who always answer questions in the Clojurians Slack and help everyone. I also really admire the work they do in their different projects.
Joshua Suskalo - he not only produces excellent open source libraries, he also spends countless hours on Discord patiently helping newcomers to Clojure (including folks brand new to programming). A thankless task.
The XTDB team! They're always nice, helpful and responsive, and they value my input on XTDB a lot even though I'm just a solo dev, not a paying client. (And they/JUXT have started sponsoring my open-source work.)
Wilker Lucio because he's really smart and open and honest and is working on something he cares about that is impactful. Most other people tend to be more dogmatic and the passion is covered with other bullshit.
Borkdude - for creating a lot of awesome Open Source tools and spreading his knowledge about Clojure. Alex Miller - community support. Rich Hickey, and Stuart Halloway - do I need to say something about them? :P
All project maintainers who interact with the community on their project channel on the Clojurians Slack (CIDER, clojure-lsp, shadow-cljs, etc.) John Stevenson (Practicalli), good docs / tutorials are essential.
Thomas Heller. He created an amazing library/tool - shadow-cljs. It's capable all the clojurescript and interop features. Some most important ones are. * npm integration. * Configurations for multiple targets.
It's hard to put to words, but there seems to be a better understanding that reciprocity is a two-way street. And that attention isn't the unequivocal good it's made out to be in US-ian culture. Weird. I know.
Rich Hickey — because he saw incidental complexity as the most important problem facing all designers and created a programming language to confront the most fundamental problems in our engineering discipline.
The tools builders. Cider, shadow-cljs, dirac, deps, build. On one side it is using code to facilitate the work of coding. Apply to self. On the other side they provide visibility of the data flowing through.
They are quite beginner friendly and write great libraries, most often with great docs. Also, the idioms are well shared/propagate efficiently. E.g.: replacing macros with data structures (reagent, honeysql).
Daniel Higginbothan, for his wit and insight Joshua Suskalo, for his stewardship of the community Elena Machkasova, for introducing me to the language Michael Borkient, for his bewildering array of libraries
There is always an answer for a question in the Clojure slack. It may not always be easy to get to that answer, but there is usually someone there who is willing to help find the real problem and solution
Bozhidar Batsov - For CIDER Michiel Borkent - Babashkia Thomas Heller - Shadow-CLJS ( would not have gotten to clojure w/o this) Uncle Robbert Martin - Promoting using clojure in a clean professional way.
Rich Hickey - talks totally improved my way of writing code (even in my main daily work language C#) and the way how I design solutions. Learning-wise, the guy from "On the Code again" and the Calva guy.
Zach Tellman, made me think about performance in clojure, made me realize my concerns I had for the language weren't just my own. He's moved on from the language from what I can tell, and I have as well.
All the people out there who write/vlog about their experience with Clojure. LVH, Tyler Hobbs, Stuart Sierra, Rich Hickey. There isn't a lot out there on how to structure large projects, which is tough.
Clojure community is the most "out-of-the-box" community I have ever come across, I don't know how or why, but it feels like members of the community are very keen on disrupting how software is written.
Tony Kay - I'm still new to Fulcro, but it seems great. Daniel Slutsky and the rest of the scicloj group not only for library improvements but also for making an incredibly positive and welcoming space.
I watched a talk session with Alessandra Sierra and another talk session with Rich Hickey. Both talked about your career and Clojure it was very inspiring to me to continue my improvement in my career.
Other than the author Rich, there are many folks who do spend time in meetup/blogs/etc who contribute - however many of their efforts is wasted due to the lack of great materials (that are versioned!)
I appreciate Eric Dallo for his work on clojure-lsp, for being very responsive, and for helping with Calva's usage of clojure-lsp. I also appreciate Peter Stromberg for creating and maintaining Calva.
Daniel Slutsky being very kind and for reaching out to me when was trying to be more involved in the community. Sean Corfield for being very helpful and willing to give his time to answering questions
Rich, Alex, Stu, Nubank, weavejester, Zach Tellman, Niki Tonsky for being generally bad mf's (i.e. an inspiration) Ghadi for the talk title "Passion of St. Async"!!!! Ben Sless for hyping transducers
Sean Corfield, Alex miller and Borkdude because they hard work and will to help anybody. Wilker Lucio because of it's awesome Pathom library which i still believe could become Clojure's killer lib :)
First and foremost the core team for their tireless and careful work. Other <> & prolific contributors. Basically, all the generous grown-ups (e.g. borkdude) that make the Clojure community awesome.
Rich Hickey of course, but everyone is great! When I ask anything on the Discord (server "Discljord"), I get a quick help always very quickly. The community is a great and important part of Clojure.
Sean Corfield! Great blog, SO MUCH HELP on ClojureVerse and on Slack. Rich, obviously. Stuart Holloway for some GREAT talks out there. Eric Normand, incredible resources for learning Clojure and FP.
Ray McDermott. He is a true advocate for the Clojure language and just a very nice person. He is involved in so many projects (Defn podcast, Apropos, ...) that promote Clojure to a broader audience.
Rich Hickey for his insights, Fogus for his humour, Zach Tellman for his general brilliance … and I obviously appreciate all the hard work many others are putting in (thanks for all that you do!) …
Inclusivity, the sense that even if someone lacks context they deserve an answer and respect, and the push to solve problems that people deal with in their work instead of theoretical bike shedding
b0rkdude (babashka, clj-kondo), Eric Dallo (clojure-lsp), viebel/Yehonathan Sharvit (data-oriented book), Daniel Higginbotham (Brave Clojure book), Metosin group (sieppari, muuntaja, reitit, malli)
Alex Miller for being the voice of the dev team. Jordan Miller for making the Clojure community look less like a bunch of cranky old men :D Rich Hickey for creating the language and good community.
The slack community has been crucial to the point where I don't know if I would still be using Clojure without it. I love the work that Clojurists Together organization is doing for the community.
So many people. The London Clojurians. All the people in #clojure-europe. The people in clojure zulip. Esp Chris Nurenberger and generateme as they've been building the data science tools I need.
Michiel Borkent and Thomas Heller. Both are tirelessly involved with projects that propel others forward with clojure. Thomas Heller in particular makes integrating with modern JS -much- better.
Maturity and homogenity. I didn't need to invent my style I just need to discover what is the idiomatic clojure. I have got a feeling, there is common understanding in the community, what is it.
Eric Normand, he gives a lot of practical tutorial. He also give me free access to his tutorial sites because I can't afford it. I make promise to myself to pay it forward later, if i get a job.
Alex Miller for their community outreach and core work Sean Corfield for their consistent help with newcomers and tireless work on key libraries Borkdude for their work on babashka and clj-kondo
Alex Miller for his unceasing professionalism, tact and positivity as a main face of the core team; the countless contributions, tasks and chores he stays on top of; and his natural musky aroma
Bozhidar Batsov serves as the great clojure tooling coordinator, David Nolen for his efforts in clojurescript, Bruce Haumann && Thomas Heller, Peter Strömberg aka PEZ - great progress in Calva.
I really appreciate Jacek Schae's courses for learning Reitit, Reagent, and Re-frame. If these had been available when I was first learning Clojure, I'm sure I would have stuck with it longer.
Sean Corfield for his awesome libraries and helpfulness. Michiel Borkent for the same :) Peter Strömberg for Calva and screencasts. Daniel Slutsky for being the driving force building SciCloj.
Alex Miller, for amazing stewardship and outreach; Michiel Borkent for letting me use Clojure in more places and ways; Sean Corfield for being such a positive presence in the online community.
Borkdude for clj-kondo and babashka stuff. Metosin folk for ClojuTRE (which sadly has been on hiatus since the pandemic started). Day8 for re-frame. Tonsky for strong opinions on performance.
Alex & Rich for their excellent stewardship and advice to those wanting to contribute. Keeping standards very high. Everyone on slack is incredibly helpful and friendly. Wonderful community.
Alex Miller for all the hard work he is doing. Rich Hickey, for keeping everything together. "Borkdude" for all the tooling he is producing. Sean Corfield for helping the community on Slack.
The Clojure community is very nice and helpful. I think the polite and respectful tone comes from key leaders like Alex Miller and David Nolen being incredibly approachable and respectful.
Alex Miller for communicating well about core development. All the great tooling and library authors, some very prolific! Generally the tone is positive and helpful, e.g. on mailing lists.
The answers provided to questions online are comprehensive and cover many related aspects to the question as well which leads to more research on the other topics referenced in the answers
Thomas Heller, shadow-cljs made it very easy to use clojurescript! Worlds ahead of other development tools for cljs Borkdude, love clj-kondo and SCI many more I'm not thinking of right now
Chris Houser (Chouser) - He does a great job with leading internal learning at our company. Eric Normand - Love his posts online and also the work he does to spread Clojure at my company.
Off the top of my head, I'd say that that I'm using several of Sean Cornfield's libraries and tools, including next.jdbc and HoneySQL. He's also very present in Clojurians Slack channels.
All the old crew. joinr, alex miller, didibus, sean corefield, etc. They are consistent - join in on online debates and such and seem to always present a good argument for various things.
The language attracts smart people who are creative but pragmatic. People are using clojure to do extremely varied things and there is always a clojurist cooking up something interesting
Rich Hickey (naturally), Mey Beisaron, Daniel Slutsky, and David Nolen. Simply: they all just push the limits; they break paths. What is more, they show the way to what they've achieved.
Borkdude provides excellent support for excellent community projects. Ray and Vijay for the Defn Podcast. Alex Miller for fast responses about language questions on the Clojurians Slack.
Any Slack regulars who participate and drive discussion and answer questions. I (almost) never feel dumb to ask questions or similar, because people are generally very helpful and nice.
Phil Hagelberg - Leiningen tooling. deps and clj cli has a lot to learn from it James Reeves - great quality code and libs Metosin and JUXT for high quality contributions to open source
Michiel Borkent (@borkdude), Dmitri Sotnikov (@yogthos) - I make use of their tools and libraries (and book in the case of @yogthos) and they are super helpful and responsive on Github.
Thomas Heller, Tony Kay, Paula Gearon – to name a few. The community as a whole is very helpful and welcoming. Clojurians Slack greatly contributed to my adopting the language full-on.
Alex Miller. He's helped me many times and is very patient. He also writrs fantastic Vlaaad for making CLJFX and helping me learn to work with it Joinr for his insights on clojureverse
Alex for his tireless outreach with the community. Borkdude for bringing clojure to new and productive areas. Rich and David for their level headed stewardship of clj and cljs. Thanks!
There are many people in the community who deserves my gratitude. Here are some (but not all): Rich Hickey, Alex Miller, David Nolen, Michiel Borkent, Sean Corfield, Thomas Heller...
Clojure's thoughtful design and Lisp superpowers continue to delight me, even as I am broadening my horizons and appreciating the benefits of other languages and communities as well.
Is this a special spot for Borkdude ? Because ❤️ His involvement and help is amazing. Also special shout out to Alex Miller, his approachability is truly humbeling. Thanks to both!
I love all of Rich’s videos for motivation. By far, though, Tony Kay’s Fulcro 3 tutorial series has been the biggest help for me. I just wish it didn’t take me 4 years to find it.
I really appreciated Russ Olsen's book Getting Clojure. I also appreciate all the efforts of @pez, @seancorfield, and @cora to welcome and help beginners in the Clojurians Slack.
Corfield because of great libraries and helpful. didibus because helpful. Mike Thompson because I love re-frame. Thomas Heller because shadow-cljs is brilliant and he is helpful.
- The entire Clojure core team - Sean Corfield, Kevin Downey, Dan Sutton, Eugene Pakhomov, and others tirelessly helping beginners over at the #beginners Clojurians Slack channel
Alex miller, the recent YouTube video he did about the new things in a Clojure release really helped give context to what's happening and confidence that Clojure is in good hands
Rich Hickey. His talks on YouTube have so much useful information. Seeing the same issues at work that he points out and and trying to mitigate them using Clojure brings me joy.
The friendliness and openness. I used to contribute to Python community in the past and feel that Clojure community is like Python 10 years ago when it was open, geeky and fun.
Sean Corfield - for his diligence in creating, maintaining and documenting so many libraries that I use on a daily basis. Michiel Borkent - for creating clj-kondo and Babashka.
Shadow-cljs! Huge respect to this project and the maintainer, Thomas Heller, for putting together one of the highest value-add projects in the Clojure ecosystem. It just works!
I love Rich tremendously as our BDFL. Great person with great thoughts and design taste, a real pragmatist. I also really like Alex Miller's work and presentations / writing.
Stuart Halloway / Rich Hickey for their talks Zach Tellman for the hard work around abstractions David Nolen for Clojurescript Alex Miller for his investment on the community
Rich Hickey's hair, of course Anyone who writes code or does presentations. That music composition presentation is what got me to finally pull the trigger on Clojure myself.
Borkdude for putting out a huge amount to open source. Rich Hickey for being a usually corrwct guiding voice. Oliver Caldwell for Conjure. Everyone that works on clojure-lsp
The clojure community has taught me a lot about programming and completely changed my perspective on the whole thing. The focus on simplicity and data in mind transforming.
Everyone that makes this great community grow and develop. I am very grateful for the work many people did so I can build great apps for my clients! Thank you to everyone!
The contributors :) Then the folks who are always there to help beginners in slack. Sean Corfield Thomas Heller Lilactown P-himik Ikitommi Borkdude Alex Miller David Nolen
Sean Corfield and Michiel Borkent, for their awesome contributions to open source. Wilker Lucio and Tony Kay for their innovative and inspiring work on pathom and fulcro.
The podcasters (lost in lambduhhhs, apropro, defn, cognicast), and Borkdude for his prolific open source work. Getting other ways to use clj out there expands the market.
- the stability of some "core" libs (ie. Ring) * Metosin (reitit, jsonista, malli...) * the overall level of expertise which makes asking / answering questions a pleasure
Alex Miller, the Nextjournal team, Borkdude, Clojurists Together, C Grand, and many others who aren't coming to mind as I stare at this little box. It's a good community.
There is certainly Borkdude. Peter Taoussani. Arne Brasseur. Ztellman. Aphyr. Bbatsov. All for their libs. Alex Miller for being patient and answering so many questions.
Alex Miller for consistently managing so many core language bugs over the years. Greg Haskins for providing the protojure library for protobuf+ gRPC clients and servers.
I appreciate Sean Corfield, he gives a lot of people something invaluable - his time. He is also a very humble person and I look up to him a lot, a true senior engineer.
Too many names to list everyone, but Stu Halloway, Rich Hickey, Michael Borkent, Alessandra Sierra, Ghadi Shayban, Alex Miller, and Michael Fogus are all heroes for me.
Openness, pragmatism, and curiosity. The community loves pulling from other communities and the past, but at the end of the day is still focused on getting things done.
Most senior developers out there that contribute such simple, small, KISS, Unix-philosophy friendly libraries/projects as well as the enlightened core Clojure team.
Rich Hickey and everyone working on libraries for clojure, writing documentations and tutorials and those clarifying questions on places like clojurians slack channels
people are smart! but there's a bit too much "we know better". It used to feel more justified (maybe I was one of them too) But I think other languages have caught up.
Clojure-lsp project team. Static analysis using lsp for any editor is invaluable. It allows me to write a personal Acme clone, for example, with a built in LSP client.
Everyone. All the open source maintainers are really active to give hep on the use of their library. The Clojure slack is always ready to give you an hep if you stuck.
Alex for tanking pain, Stu for financing this, Leo Noel for quietly building the right thing, Joel Holdbrooks for Meander, Rich for rejecting the way things work today
The "Discljord" Community on Discord for being my primary place of exchange with other Clojure devs and for helping many new people getting started with the language.
The number (and availability of) knowledgable veteran clojurians (including the dev team!) willing to help out with sometimes generally obscure problems is wonderful.
Peter Taoussanis for libraries of the highest quality, Alex Miller for community management (and more!), Michiel Borkent for babashka, and Rich Hickey for everything.
People are really helpful and focused on providing solutions. I have never come across a harsh message. It feel it is an community that is welcoming towards newbies.
Friendliness, this is so important especially when getting started, people wanting/willing to help is always good and it helps to promote the use of Clojure as well.
James Reeves Zach Tellman Alex Miller Defn podcast team Functional Design in Clojure podcast team Dragan Djuric Colin Fleming Michiel Borkent Brian Marick Uncle Bob
- Metosin: Useful and powerful libs, we much use of their libs - Weavejester: We make much use of his projects (Ring & co, many smaller libs) (to many others....) -
Pragmatism and simplicity: my 3 person team has been running an enterprise app in production for 5 years now and it's only recently that we had to hire a 4th person
I haven't been around long enough to know specific people, but I really appreciate being able to work in the Java ecosystem through a Lisp instead of through Java.
Alex Miller for Clojure News, Eric Normand for Grokking simplicity. Rich Hickey for Clojure itself. James Reeves for his libs. Metosin and JUXT for libs and blogs.
Alex Miller for his efforts to engage with the community. Thellman for pushing cljs forward. Various others for putting out high quality libraries with dedication.
Michiel Borkent, for being the supehuman producer of influential tooling and also having faith and trust in me to co-maintain a lot of them, specially Babashka! :D
very nice and well behaved. usually made of experienced developper with background / interest in software craftmanship and developping robust and quality software
Borkdude has been doing an amazing job with babashka. A true breath of fresh air, taking all the good parts of clojure and packaging it in a tiny portable binary.
Bozhidar Batsov for his contributions and overall positive energy. The Defn podcast because it's fun and technical. Too many people to give credits to in general.
Nikita Prokopov: high-quality projects, clear statements about what's wrong in mainstream software development. Thomas Heller: shadow-cljs. Vlad Proczenko: cljfx.
I have been quite isolated from the wider Clojure community. The internal community of developers of my workplace has been providing the in-person support I need.
Alex Miller. I think the clojure core team was unfairly criticized a while back for not being opaque enough. So Alex now shares lots of updates on a regular basis
pez - for Calva. Sean Corfield - for being outspoken and super active on Slack. Alex Miller - for representing Clojure and actively working on community building
All the people who somehow find time to create all the excellent open-source Clojure/Script projects who we must assume have bill paying jobs to fit in as well.
We have a heavy emphasis on engineering wisdom and not just what you "can" do, but what you "should" do that leads to very healthy libraries and project design.
bbatsov - cider and prelude bhauman - figwheel-main borkdude - clj-kondo and babashka technomancy - leiningen jonpither - everything juxt ..and lots of others!
Lot of people, but some shoutouts: Rich hickey, borkdude, alex miller, fogus, sean corfield, mike thompson, arne brasseur, bruce haumann, and quite a few more.
Ray and Vijay of the Defn podcast. Eric Normand for his podcast. Michael Borkent for clj-kondo. The whole Clojurians slack community for provoking me to think.
The friendliness and helpfulness are absolutely top notch. It helped me get started with the language, and to quickly lose my feat of asking a stupid question.
Michiel Borkent @borkdude is omnipresent recently, eclipsing Rich and Stu :-) Dustin Getz is promising us so much that I'm hanging to his every published word.
The core team for creating and maintaining the language. I use next.jdbc, aleph and lein every day. Thus I am thankful to everyone involved in those projects.
Arne Brasseur, Nikita Prokopov, and Vlad Protsenko among others for reconsidering UI + repl. And right now Borkdude for making scripting more available to me.
Rich... beautiful language, Bozhidar Batsov... all my tools, Alex Miller... being such a friendly guy, Anthony Grimes... his webrepl got me started in Clojure
Paula Gearon, Jordan Miller, Dustin Getz, and Ray Mcdermott for their generosity and openness sharing knowledge all the core Clojure team what they've created
Borkdude for babashka Alex miller for all the help Technomancy for the inspiration Yogthos for all his libraries Rich hickey for making programming fun again
Thomas Heller: The Machine Borkdude, The Mage Will Acton: The Sniper Daniel Slutsky: The Progressive Shepherd Chris Nuernberger: John Baptist of Data Science
London Clojurians for the organisation of talks and conferences @bbatsov & @borkdude for the great tools/ide @seancorfield for his slack presence and support
Creators of re-frame, shadow-cljs, luminus for making Web dev more accessible. Phimik for answering re-frame questions on slack. Everyone who blogs tutorials
First one that came to mind , Bozhidar Batsov - very active and ongoing CIDER improvements continue to be excellent. Am enjoying using Prelude also. Thanks!
Thomas Heller -- for shadow cljs and his patience, Daniel Compton -- for CT Alex Miler -- for communication Eugene Pakhomov (p-himik) -- for Slack responses
- The community is very friendly and helpful. 2. Extremely smart people who share their work - it's a goldmine for folks seeking intellectual stimulation.
Even very old libraries work fine after years. The language and the ecosystem is very careful about about not breaking things. People are nice and helpful.
The Clojure community feels accessible, with no frills and few egos. I like that I often have direct access to authors of libraries or tools in Clojurians.
All core library developers and all OSS library developers because they make it possible to use Clojure to develop just about anything in an enjoyable way.
Greg Look is an extremely knowledgeable and talented Clojurian who is very generous with his open-source contributions and time commitment to the community
Core team for keeping things so super stable Bhozidar Batsov for cider Michiel Borkent for Babashka Nubank for sponsoring the clojure ecosystem developers
I don't appreciate people in tech directly, I'm very anti-person-cult kind of guy, mostly because of how Silicon Valley works. Sometimes it's a hindrance.
Alessandra Sierra and Rich Hickey - I've been learning a lot with both. They have many pieces of advice about computer science and a good sense of humor.
Who? A single person? I wouldn't want that at all. I appreciate the community itself. Many clever and at the same time pleasant minds have gathered here.
I appreciate Colin Fleming, for his support on the clojurians slack instance. I also recognise Alex Miller and Sean Corfield, again for support on slack.
Tony Kay amazing work on fulcro and other oss projects. Daniel Compton clojurists together and podcast. Jacek Schae tutorials and podcast Alex Miller :)
I don't appreciate clojure community, people are temporal, just testing, not passionate, OR they are too professional to explain it in simple language.
Rich Hickey really opened my eyes for question I had but couldn't really elaborate properly. And also gave answers! I watch and re-watch his lectures.
Tony Kay for working on Fulcro and Wilker Lucio on Pathom work impressed my in 2021. Generally there are many great library authors that I appreciate.
helpful online community, borkude, alex miller, sean corfeld, cider guy(bozighar?), weave jester, luminus team, and datascience group on clojureverse
Rich Hickey is the man, David Nolan has great hair, Tony Key for Fulcro and Fulcro RAD, Wilker Lúcio for pathom, and you, for contributing your time.
Rich Hickey, for obvious reasons. Tony Kay, Jakub Holy, and Wilker Lucio, for Fulcro and Pathom. Bodzhidar Batsov for all of the tools, namely Cider.
There are really talented and nice people around who have the necessary skills and interest to make production quality work, and provide it for free!
Sean Corfield - libraries and comments on various forums Rich Hickey - commentary Eric Normand - excellent re-fram learning resource and blog/podcast
My coworker John Conti for showing me the ropes. Too many lib maintainers to mention, but most recently been appreciating Borkdudes work on babashka
All, and most notable: Alex for providing an out-of-the-box dependency and build tool. All contributors to editor tooling (personally using Calva).
Everyone: they're all genuinely passionate about technology and generally respectful of others while supporting/engaging with dissenting discourse.
Rich hickey, Dave Noland and the rest of core developers of clojure for solving tascendental problems in software development practically for good!
Borkdude, guy who makes Conjure, Stu, Rich, Oakes (is he still active?), all the heroes on the Clojurians Slack who answer questions day and night
I would like to especially mention the community of www.clojuredocs.org where code examples have almost always rescued me from programmer's block.
Colin Fleming's support for Cursive users has been fabulous. It's very easy to reach him, and he's always affable and appreciative of bug reports.
The community is awesome across the board. Specifically: Sean Corfield Alex Miller @hiredman @borkdude @ghadi @pez @practicalli @ericdallo @chrisn
Eric Normand (purelyfunctional, vids, articles). And, like, all of the people working to keep it working, elegant and more capable, day by day...
Open source warriors like borkdude, people who are good at talks like David Nolan (and rich of course), everyone who helps in the slack/community
I appreciate all open source developers, Clojure creators/maintainers, documentation/tutorials/answers writers. It's a difficult question for me.
Zach Tellman: his libraries are still some of the best out there Thomas Heller: he's virtually the solo developer of shadow-cljs, incredible work
borkdude for babashka metosin for malli, muuntaja, reitit seancorfield for next.jdbc thheller for shadow-cljs simuons for the Clojure Bazel rules
- author of web development with Clojure book - author of Clojure for the brave book - author of Calva - Stu - on the code again YouTube channel
Sean Corfield and Alex Miller - for their communication Eric Normand - for all the educational content Michiel Borkent - for bb, sci, clj-kondo
Rich Hickey for Clojure and all the good ideas Alex Miller for his tools and community work the authors of the many great libraries we can use
The Clojure community is full of experienced developers that have done Enterprise before, and many of the ideas are based around pragmatism.
Eric Normand (newsletter and general enthusiasm), Stuart Halloway (snarky tweets), Peter Strömberg, Michiel Borkent, Bozhidar Batsov (tools)
High concentration of incredibly talented, intelligent and kind developers. Usually you find only one of those kinds in a community (see CL)
Rich Hickey for everythign. Thheller for being the worlds most responsive OSS dev. Olical (?) for making conjure and vim a joy to work with
I love Nikita Prokopov's blog (tonksy.me) He has such good ideas and an eye for detail. I like his views on user experiences and UI as well
Clojure core language team, borkdude, Calva dev, vlaaad, Juxt, all the lib devs and the helpful folks on Slack etc., those funding projects
The fact that it is on a human scale, we quickly learn to know each other on Slack, Twitter, etc. The support that the community provides.
john stevenson, runs the london clojurian group and in general helps outs with newcomers a lot - also does clojure bridge and clojure dojo
Everyone in Clojurians Slack is awesome. So many helpful people making themselves available to answer questions and offer their opinions.
The Functional Programming with Clojure podcast. Those guys are awesome. Also Sean Corfield - I've learned so much from his discussions.
I appreciate that Clojure is not huge, but we are passionate about the language and genuinely want to see our fellow Clojurians succeed.
Sean Corfield, David Nolen and Thomas Heller because they have provided very good insights and clarification on Slack in diverse topics.
That there is a bunch of friendly people. Tone is almost never negative. And that the holy next spec version is given time for maturity.
The maintainers, from the Core Languge committers to the people who make the awesome libraries we use to build and ship great products.
Rich Hickey for his vision, perspective, and consistency in serving as the nucleating principle around which Clojure could crystallize.
That it's very open and kind. It seems like it's ingrained that we all help each other and everyone seem to be keen to keep that going.
Sean Corfield - a very smart and knowledgable man with tons of experience that takes some time every day to help newcomers. Incredible!
Sean Corfield, he's answering questions everywhere, all the time. The core Clojure team and many of the library maintainers, of course.
alex miller, borkduded, seancorfield, tengstrand probably loads more they have always helped point me in the right direction many times
Sean Corfield for all the amazing work he does, The Team of awesome folks who created Polylith, and the people who are building Calva!
Niki Tonsky wrote Datascript, which I'm shamelessly cribbing for a golang variant, and is tilting at the cross-platform GUI windmill.
A really helpful community, discussions are (mostly) based around facts and not opinions (except for the "flexible" data model part).
Alex Miller; I have never met him but he is quite the 'peacemaker' in the community. We need more like him and less like Rich or Stu
Pieter Breed, advocating for and using clojure in the South African tech ecosystem, and being willing to take career risks to do so.
It's very active. There are a lot of very clever people producing a lot of amazing things. I made the right bet all those years ago.
Not a specific person, but the community in the Clojurians slack is great! People helping each other out on a daily basis. Love it!
I've found the community incrediibly welcoming and friendly. There's a lot of energy and excitement and great, great developments.
Rich, Daniel Compton, the NuBank team (go Cavalcanti), and the guys on Zulip doing all the machine learning stuff, Dragan Djuric
Everyone taking the time to show and explain concepts patiently and everyone helping to make editing Clojure more user-friendly.
Lee Hinman, the maintainer of clj-http and cheshire, without which I don't know how half of my work would even be getting done.
Rich (the talks!), Stu (code! REBL!), and David Chelimsky (I still refer to his talk on aws-api for inspiration all the time)
Alex miller, he’s just great Eric Normand, learned so much from his videos Paula Gearon, good to see another woman in the space
Thoughtfulness. It is important to consider the needs of other people. After all, it's about "peopleware", not just "software".
Right now the community is too small and most people in it are very busy. Maye be we need to have dedicated Clojure evangelist.
Rich Hickey for BDFL and making sense. Bozhidar Batsov for CIDER and so on. Alex Miller for his gracious patience and clarity.
Peter Taoussanis: Invaluable set of libraries Dmitri Sotnikov: Luminus ecosystem Metosin Team: Another set of invaluable tools
The Clojure community expected me to be competent and curious, which encouraged me to think and experiment while programming.
None in particular, every content creator on YouTube is appreciated and very helpful. I really do love the Clojure community!
Alex Miller for the patient community engagement. Arne Brasseur for striving to create a welcoming place for new Clojurists
All of the Metosin guys! They practically put Finland to the top of the Clojure world and also introduced me to Clojure :)
Generally nice people and the passion that they have makes me feel both welcomed and easy find new and interesting topics
Rich Hickey (duh), David Nolen (cljs work, including recent stuff), Michiel Borkent (babashka), Stuart Sierra (component)
Alex Miller, for being the tireless public face of the Clojure core team, as well as his work on the CLI/tools ecosystem.
The folks who write the documentation. Started out on IBM 370 assembly code & PL/I - so I'm used to & RELY ON good docs.
Recently - Tony Kay, Fulcro Lucio Wilker, Pathom Sean Corefield, Blog, Polylith, Tooling Alex, Consistant work over time
@spacegangster helped me a lot with my projects with PWA, organizes meetups in Russia. @cgrand for building clojure-dart
The community at large is very helpful and full of people that are very enthusiastic about the language and core idioms.
I would have to say Rich Hickey, as his presentations found on YouTube that got me interested on Clojure to begin with.
In addition to everyone on the core team... Daniel Slutsky for his contributions to organizing the scicloj community :)
The community is great but a special thanks to borkdude that develops incredible stuff super fast. Babashka is awesome.
So helpful and friendly. The philosophical tendency -- trying to find the best way to write (and think about) programs.
Michiel Borkent for constantly pushing the limits of where and how Clojure can be applied meaningfully and efficiently.
The core team and the surrounding community members that keep the Clojure ball moving forward, year after year. Thanks!
Thomas Heller for creating shadow-cljs, James Reeves for making Ring, and Alex Miller for all the work on Clojure core!
People are super nice. I never seen a toxic person. I used to see a lot of toxic community members in other languages.
The "thought leaders" have absolutely incredible talks (e.g. hammock-driven development, programming with hand tools).
Thomas Heller, because his creation shadow-cljs works really well, and he is very helpful in the #shadow-cljs channel.
Taoensso for their excellent libraries, borkdude for clj-kondo and Sean Corfield for his involvement in the community.
Sean Corfield for his insightful and friendly communication, as well as his work on important parts of the eco system.
Rich, Stu and Alex of course. But Sean Corfield in particular - the libs Sean maintains aren’t sexy, but are required.
borkdude for bb, sci, clj-kondo, Niki Tonsky for his writing and Datascript, Bbatsov for CIDER, cgrand for ClojureDart
I'm new and bad with names. But I think there is a lot that is cool about the language itself and the core libraries.
Thomas Heller, Peter Stromberg for making cljs much more accessible. Michel Borkent for being amazing and so helpful.
Alex Miller, Michiel Borkent, Thomas Heller, Bozhidar Batsov, Paula Gearon, Ray McDermot and Vijay Kira, many others…
Borkdude, because he's so damn nice and does such interesting things! Alex Miller, because he is so on top of things!
Everyone! thats a cherry on top when working in clojure, everyone seems more professional/mature and want to help out
Friendly, approachable, patient attitudes (especially to beginners) while still being generally extremely competent.
Mauricio Szabo. He helps the community A LOT with tips and tricks about Clojure and software engineering in general.
Borkent, Hauman, and Nolen, for their contributions and engagement. Metosin and similar groups for the same reasons.
I very much appreciate Daniel Compton, his podcast and Clojurists Together meet significant needs of the community.
Nikita Prokopov - quality content, good marketing for the language Michiel Borkent - clj-kondo Tommi Reiman - malli
it is enthusiastic and open to helping out beginners and they have a genuine love and appreciation for the language
I appreciate Peter Taoussanis for the variety and quality of his Clojure work. I am not convinced he is one person.
Alex, Sean Corfield, Michael Borkent, Tommi Reiman, Nikita (Tonsky), and many others on Zulip and Clojurians slack.
I just like fp and Rich Hickey's transducer videos on youtube hooked me. I was also curious about the list syntax.
Nolen, Fikes, Normand, Borkdude, Cornfield, Miller J & A, the guy who writes Cursive, for community and cool $@#^.
I like all the book authors,people at Just, metosin and all people participate in meet-up and gave their thoughts.
Juxt (Jeremy Taylor) - Using the xtdb database and he was very quick & helpful to reach out to help solve problems
All the wise, smart, collaborative, humble people that lead it. (Rich, Stuart, Alex, Sean Corfield, and many more)
Rich, Alex, and others for the immensely important clj/deps work. And borkdude for the sheer output of greatness.
Borkdude, nextjournal folks, Matt Huebert, Rich Hickey, Alex Miller, Sean Cornfield, Huahai Yang, Nikita Propokov
The consistent development of new libraries and wrappers to take advantage of tools developed in other languages.
Not much - the community is far too intimidating or intentionally/unintentionally arrogant and "holier than thou"
Whoever it was who got us on a proper plan for the Clojurians Slack instance. Anyone who writes open source code.
all the community members and contributors deserve praise. but theller especially, for shadow-cljs! it's so nice
Rich Hickey and hole clojure.core team. Also James Trunk for his excelent talks that showed me basics of clojure
All the people who will help you even with stupid questions, it helps to learn and make new stuff while doing it
Community itself, supportive, inclusive. Sean Corfield, Alex Miller because of the work in the beginners channel
The Cognitect team and core Clojure contributors - keep up the great work and thanks very much for your efforts.
Rich for obvious reasons. Alex Miller for his help, books and deref. Guys in the Russian Clojure telegram group.
Rich Hickey, Alex Miller, Stuart Halloway, Eric Normand for presentation/learning materials/impacs on cummunity.
Daniel Slutsky. He reached out to me when I tried to get my foot in the Clojure door and is a wonderful person.
Alex Miller for all hard community work Juxt and Metosin for their libraries Nubank for sponsoring Clojure core
John Practicalli who created a great collection of documentation for moving from basics to slightly past basics
Bruce Hauman – Figwheel. Mike Fikes – CLJS type inference performance improvements. David Miller – ClojureCLR.
Lisp is great, the libraries are high quality, the people are very helpful, and generally, things “just work”.
It is generally a friendly community with a minimum of rude arrogance. I've met many and diverse nice people.
Alex Miller, done a great job for the cli tools, is a good captain for setting the direction of the language.
Eric Normand for sharing thoughtful opinions, Ray & Vijay for open & friendly discussions via the den podcast
All the folks who maintain it because of the thoughtful and deliberate approach taken to grow the language.
The will to use and contribute to great software, and generally be actually awesome without being pedantic.
The help, the kindness, the indefatiguable assistance and smiles. And a good joke about Java now and again.
The approach about retro-compatibility of both Clojure and its lib. The stability of Clojure is a blessing.
Everyone that's active on Slack and other places. Everyone that contributes to OSS and creates novel tools.
Alex Miller - great communicator, smart, clear Daniel Slutzky - tireless in his work for clojure analytics
There are too many to name! I came for the language and stayed for the community (well, and the language).
Alex Miller, Sean Cornfield, Rich Hickey, Christopher Grand, Fogus, and a lot more for their contributions
Jordan Miller - She puts an amazing amount of energy into everything she does. She had been open and kind.
A lot of great minds, this year I would say Borkdude for sci and all the projects that blossomed from it.
borkdude@. Babashka and clj-kondo are amazing tools. Thheller@. Shadow-cljs is an essential tool for me.
News/weekly roundup, amazing libraries and solutions, examples in clojuredocs.org, books, many many more
Rich Hickey, because his talks motivate people to think beyond the obvious and dare to think differently
I appreciate all maintainers who give their time to improve the tools we use in our software. Thank you!
Dmitri Sotnikov (yogsoth) for the work he did with ClojureNorth and the Toronto Clojure scene in general
Eric Dallo and Iizuka Masashi- they've created phenomenal tooling and are incredibly helpful and pollite
Conference speakers, active community members and all who advocate for the use of Clojure at their job.
The community its very helpful and energetic about newcomers and about doing things in a efficient way.
Everyone on the core team. Michiel Borkent, James Reeves, Bozhidar Batsov, Defn podcast, John Stevenson
All active contributors and authors, with corfield and heller as regents and dmitri sotnikov as a vicar
Yogthos and Borkdude. Both have contributed excellent tools and have made Clojure a lot more accessible
responsive and engaged. fun to talk to people who actually care and are passionate about the language.
Everyone. Clojure community is so warm and welcoming. I just wish I could love lisp syntax a bit more.
Rich Hickey, his vision is futuristic ... maybe one day the world will program with his vision in mind
Bozhidar Batsov is a great maintainer, without whom the community's tools would not be where they are.
The core Clojure team for keeping Clojure small and not changing the language features at a high pace.
Sean Corfield. Practicalli. Both provide lots of good resources and are very active in the community.
It’s an awesome programming language once you know your way around a lisp and have environment set up
Alex Miller Shaun Corfield Eric Normand Pez (don't know their real name, the VS Code author) Borkdude
Sean Corfield, willing to help and support tooling created Michiel Borkent, very friendly and helpful
Tommi Reiman, for creating fast, outstanding, and useful spec (malli) and routing (reitit) libraries.
Alex Miller takes the cake. I don't think this guy sleeps. He is always answering questions on slack.
All the people developing great open source tools & libs, esp the core contributors for CLJ and CLJS.
On twitter I follow a few people only and get all my news from them. Can't find their names atm sorry
Borkdude for his amazing OSS work. Daniel Compton and lvh for their work running Clojurists Together.
Rich Hickey - good language design, good overall leadership Sam Aaron - work on Overtone + tutorials
Alex Miller, Sean Corfield, Michiel Borkent - for being so present and active giving a hand on Slack
Rich Hickey, because his talks gave me a fresh perspective on some topics regarding app development.
How people are willing to help another developers also the quality of the explanations and examples
Stability, No Breaking Changes and Presence and being stewarded by very experienced software people
Thomas Heller, he was amazingly helpful when I found a Bug in Rum that I thought was in shadow-cljs
- libs and APIs are stable * people know their stuff, so it's easy to get help on complex questions
David Nolen for his work on Clojurescript, Michael Fogus and Chris Houser for "The Joy of Clojure".
Hickey, Corfield (love his new JDBC), tolitius No time for details: dog is staring at me for a walk
thheller, for creating shadow-cljs, but especially for being so responsive and helpful toward users
borkdude, rhickey, puredanger, ztellman, bhauman, seancorfield, ikitommi, juhoteperi, and many more
borkdude for his great tools and support, Sean Corfield for his support, all the Clojure community
I appreciate the designers, the evangelists, and the nice people who hang out in clojurians Slack.
Very senior people are patient and generous with answering questions and taking care of newcomers.
I appreciate culture level and level of consciousness of Clojure community people! God bless you!
People are great. Seems like kindness, honesty, dedication and generosity trickled down top down.
The core Clojure team and those who hang out on Slack doing a helpful job of answering questions.
How thoughtful and conservative the leadership is. How much people share and write about Clojure.
A self-selecting group of people who like to build stuff and be helpful, that's the secret sauce.
https://github.com/weavejester and https://github.com/borkdude/, I use their tools all the time.
Everyone on the clojurian slack. It manages to be beginner friendly without dumbing things down.
Thomas Heller for building Shadow-cljs. Yehonathan Sharvit for DOP book and propagating Clojure.
Alex Miller, borkdude, the defn guys, and anyone who writes a decent article or book on Clojure.
Ghadi Shayban - he would send me Clojure updates when I was forced to used Java for a few years.
Everyone is ALWAYS nice to you. ALWAYS, no matter how dumb your question or mistake might seem.
Rich has amazing talks, his ideas beyond clojure are amazing and people should give em a listen
Alex Miller is such a champion of a nice guy. I also enjoyed talking to Rich and Stu as well.
A lot of people but can't really come up with any particular names. Everyone is super helpful
bbatsov, his posts are very informative technomancy, very approachable and patient, pragmatic
Rich Hickey: creating a great language Bozhidar Batsov: creating a great REPL tool for Emacs!
The core team and all the contributors for making an amazing language and tooling around it.
Everyone who contributes in the form of open source code, community building, evangelism,...
I appreciate everyone in the community who contributes to making it so vibrant and engaging.
The enthusiasm, Lack of big corporate influence, A sense of exploration among the community.
Thomas Heller - he single-handedly made it worthwhile to use CLJS Borkent - SCI is marvelous
All the minds who are cautious about adding every feature under the sun. Stability is nice.
That people are smart, friendly, open and produce quality products and quality discusssion.
Eric Normand, his course finally got me using the REPL efficiently after years of fumbling.
I appreciate Rich Hickey, Clojure aside I enjoy someone articulating the why of something.
Michiel Borkent (Borkdude) does a lot of interesting work and expands the reach of Clojure
Alex Miller for his Clojure development updates and Bozhidar Batsov for his work on Cider.
olical (conjure), jeaye (orchestra), metosin (malli), day8 (re-frame), technomancy (lein)
The hard work of Rich Hickey and the many other faces and names behind Clojure/Cognitect.
Peter Taoussanis, for providing excellent libraries and maintaining them over many years.
Alex Miller, for his work supporting the community. Tommi at metosin for malli and reitit
I love how responsive library authors are on Clojurians Slack - feels like a partnership.
The approachability and the plethora of communities and the knowledge that shared there.
Open-source developers; anyone who makes installation and getting it up and running easy
Sean Corfield - he’s always there on Slack, patiently helping explain things to newbies.
Rich Hickey for Clojure and keynotes Sean Corfield for libs Alex Miller for strange loop
borkdude and joinr, for being active and always having interesting and useful comments.
Rich Hickey! His talks are amazing and is one of the reasons I found out about Clojure
Simplicity. Nothing is made to look more complicated or far-fetched than it really is.
Stuart Sierra (enjoyed learning from him in a previous role; still reference his blog)
many, many people. it's a shame Rich and Stu seem to have stepped back from it lately.
It's very active (on Slack and Lambda Island discord), and people are always helpful.
The documentation provided by the community. A lot of examples and good explanations.
Michael Borkent does a lot of awesome open source I really enjoy defn podcast as well
Libraries/language maintainers, for being so accessible and helpful i various places.
Alex Miller! And his clones. :) Because, seriously, how does one guy do all of that??
Small, knowledgeable community makes a great filter for evolving tech in other areas.
borkdude, for creating so many interesting new tools and avenues for running Clojure
Heller for shadow-cljs and support. David Nolen for cljs and conf talks. Many others
All the authors of Clojure libraries, thank you for supporting the entire ecosystem!
Sudsy in Tokyo for being a warm presence at meetups. Also Gaiwan, Metosin and Nubank
Sean Corfield, Eric Normand and a lot of others for their experience that they share
So many! Borkdude, pure danger, holyjak, tony Kay... Great contributions, helpful...
Alex Miller, because the guy works endlessly and is very dedicated to the community
Rich and all the others providing a great starting point for us to do what we need.
Incredibly hard working and commited to the ideas and principles underlying clojure
- Rich Hickey: insights - weavejester: libraries - brave clojure: high quality docs
Sean Corfield since he is just a really decent human being and he deserves to know.
Everybody is really devoted to writing good software, that's why they use Clojure.
Rich Hickey, for the obvious reasons Peter Strömberg, Calva Bozhidar Batsov, Cider
Clojure folks are very smart. I feel myself too dumb for Clojure most of the time.
Rich, Stu, clojurists together, thheller, borkdude, wilker, lots of other people!
PEZ! Calva is simply amazing and makes getting one's feet wet with Clojure a joy.
There are too many to mention. A lot of the guys on slack have been really great.
Dominic Monroe, because he mentored me and showed me the true way of Clojure (tm)
Sean Corfield: Some great presentations Michiel Borkent: Babashka is a useful gem
It has been polite and helpful on the few occasions I've asked public questions.
I really appreciate @stuarthalloway, his tweets regarding Clojure are inspiring.
All the people that speak out and tell the advantages of functional programming.
Rich Hickey, Michiel Borkent, and Jacek Schae. For their tools and explanations.
Alex Miller for his helpful responses on the clojurians slack and on Ask Clojure
pez because he developed Calva which made it much easier to start using clojure.
lots of very smart people building a language and ecosystem which is my favorite
Kind, smart, do-things-the-right-way sort of community. Seems to be less litter.
https://github.com/practicalli/ for his easy to understand and practical guides
The people really love Clojure, so they are very helpful in a very genuine way.
Eric Normand, after I started taking his class, I finally really "got" Clojure.
Rich Hickey ( the inventor of clojure, his thoughts is impressive and right :D)
All the project maintainers and people who answer questions / help troubleshoot
Sean Corfield and Alex Miller for their contributions to the library ecosystem.
Too many to mention, this community is full of super kind and competent people.
Alex Miller for his commitment to fairly thankless work. Fogus for being fogus.
People's willingness to help, and a cultural commitment to not breaking things.
Alex miller and Stuart halloway are doing a great job showing how clojure works
Rafael Delboni, introduced me to the language and has some wonderful resources.
Alex Miller, he is very active in the community and answers almost every topic.
David Chelimsky for his great Clojure support and engagement inside my company
people are helpful, friendly. they respect each other. they love the language.
Eric Normand for all the tutorials, the weekly emails and Grokking Simplicity.
Everyone from cognitect, they are really nice, helpful and hardworking people.
Borkdude, and bsless - they love clojure and try to take it to the next level.
Borkdude for sacrificing all 30 hours his day seems to have for the community.
I really like the work of James Reeve and the way he maintains his libraries.
The Core team for making Clojure so strongly backwards compatible and stable!
Michael Broken for his creating Babashka. It is a very practical script tool.
The community seems nice and inclusive, and willing to share their knowledge.
Russ Olsen, Rich Hickey both for the talent of explaining things very simply
All the people who are working hard to develop awesome open source libraries
Deep knowledge, very senior engineers, direct support by library maintainers
It is a rare combination of 1> welcoming 2> deeply experienced and talented.
Alex Miller for community outreach and the work done on Clojure CLI projects
focus on depth of knowledge, no endless churn of variations of the same idea
- Well thought, rigorous Clojure development - Openness, Politeness, Helpful
They are very enthusiasts about the language and to explain it to new comers
Everybody is very friendly and always looking forward to helping each other.
@RobStuttaford for showing that Clojure is production grade for many years.
Bozhidar Batsov, Alex Miller, Michiel Borkent, , Sean Corfield, Rich Hickey
Backwards compatibility support and emphasis to solving practical problems.
Daniel Compton for Clojurists Together Michiel Borkent for Babashka and SCI
Lots of smart people building cool libs and things. Helpful and respectful.
The people in the community really likes to help and are very professional
- friendly, open-minded, inclusive - a good spirit of open-source creation
I really like the curiosity and far reaching ideas the community exhibits.
borkdude not just for his practical tools and teaching how to use them too
Its emphasis on simplicity & sound foundations instead of features & hype.
High level of competence and willingness to share knowledge and experience
Daniel Slutsky - for organizing all of the activities around ML community.
Really enjoy Nikita as he have a frontend background, as it seems as I do
Those behind the scenes keeping libraries, tools and communities running.
ericdallo and borkdude, they are the main support on the clojurians slack
borkdude for his work on bb/nbb etc reborg for his input into clojuredocs
Rich of course... Tommi, Stuart, Allan... there are many who are valuable
Just started using Clojure.. so I appreciate all of the Clojure community
Bozhidar Batsov, borkdude, Robert Stuttaford, Alex Miller, Jacob O'Bryant
Alex Miller. I know you're reading this, thank you for everything you do.
John Stevenson for developing the praticalli tutorial site for beginners.
Very helpful and welcoming, along with a very high signal to noise ratio.
borkdude, Tommi Reiman, Sean Corfield, Joakim Tengstrand, Peter Strömberg
Alex Miller and Eric Dallo, because they are always eager to help me :-)
Alex Miller. He's always there. Available and helpful. Tonsky, Borkdude.
I love the people. Everyone is very eager to help and friendly about it.
they value light weight, single purpose tasks/libs instead of frameworks
Very competent and willing to help even when there is no money in it ;-)
Alex Miller for organizing conferences and managing patches and tickets.
David Nolen. His stewardship of ClojureScript inspires confidence in me.
Willingness to help, and their passion for Clojure and Clojure projects
Clojure core team, shadow-cljs creator, Babaskha creator and many more.
metosin, they provide great libs mainling working as I thought it would
Borkdude's work with making Clojure a more efficient scripting language
Everyone who post in StackOverflow with the resolution of the problems
Rich Hickey because I learn a lot whenever he talks about any subject.
I appreciate the people on reddit, very passionate about the language.
Sean Corfield. For significant contributions to community development.
I honestly don't know. The guy that runs the Clojurians Slack I guess
I really appreciate Greg's effort to improve the LSP Clojure project.
Great teachers, RH as example. Very friendly and not macho code bro's
Alex Miller, Sean Cofield Very active and helpful on Clojurians slack
David Nolen: his use of Computer Science concepts in a practical way
Almost everything, really. Lisp and Smalltalk communities are great.
Everyone on clojurians slack. Special mention goes to Alex and Sean.
Rich Hickey, Alex Miller, borkdude, David Nolen, and several others.
Everybody is really open to helping and making people feel welcomed.
helpful community, few are active, but they're inspiring and helpful
Borkdude, and James Reeves... so many great contributions from both.
Sean Corfield. The answers he gives in the Clojuverse are the best.
The general quality of Clojure developers that elected to learn it.
Sanity and stability over chasing the next framework FAANG creates.
@tonsky. He did a lot for pushing Clojure inside Russian community
Openness and willingness to help people just starting with Clojure
Smart, nice people, Rich is such a nice guy Topics are interesting
Rich Hickey borkdude - For Babashka and his daily support in slack
Borkdude for clj-Kondo, Ivan Pierre for Clojure news for curation.
Everyone willing to answer questions so thoughtfully all the time!
Alex Miller for his tireless work. And I miss Rich's yearly talks.
We have surprisingly prolific ecosystem for such a small community
Love the folks at #clojure. Not at all like the folks in telegram.
So many people. Alex Miller, Stuart Sierra, Stuart Holloway, Rich.
Everyone is so kind, helpful, and awesome! The community is great!
Those who work hard on their communication of ideas or questions.
Bring back more funny and inspirational Clojure talks on YouTube!
Borkdude for enabling the use of Clojure in scripts via Babashka.
I miss the talks by Rich Hickey. I think that they are important.
Alex Miller for improving transparency David Nolen for core.logic
The community is generally welcoming, benevolent and resourceful.
Rich, Stu, Chris Houser, Michael Fogus, Edward Wible, Ambrose BS
David Chelimsky because always is trying to help to any nubanker
Bourke dude for babashka and better than tomorrow team for calva
The folks in #clojure-europe, for the watercooler conversations.
I would give thanks to Rich Hickey for his sweet voice. 몸 건강하세요.
Nate and Christian from the Functional Design in Clojure podcast
Michael Borken for Babaska, Jakob for Biff, Oakes for play-cljc
I appreciate the community itself, as well as the people in it.
Alex Miller - He rocks and probably not paid no way near enough
Everyone who makes clojurians slack a warm and welcoming place!
the clojure team - thanks for all the hard work over the years!
Wilker Lucio - Maximal graph is a great vision. Pathom is cool.
Ivan Grishaev, Fred Overflow, Alex Miller, and many many others
FieryCod, borkdude, Thomas Heller, the cognitect guys of course
High quality of libraries once you get to know how to use them.
Rich, Eric Normand, Stuart Halloway, Alex Miller, Zach Tellman
Borkdude is a hero, Babashka completely changed how I work. :)
Not consumed with social justice nonsense. Focused on results.
The ecosystem is very friendly and the libraries are amazing.
The clojure community stays several years ahead of the curve.
People are not only intelligent but also friendly and helpful
Everyone is always willing to help out if you have questions.
Very friendly and almost instant advice in the Clojure Slack!
Everyone seems nice and the language is stable and productive
A lot of friendly, helpful, knowledgeable, open-minded folks.
Rich Hickey as thought leader Alex Miller as community leader
Sean Corfield for his libs and blog. Borkdude for everything.
borkdude, reitit author, cider author, so many people to name
All the Finnish clojurians for keeping the momentum going :-)
Sean Corfield and p-himik who are extremely helpful on Slack
so many contributors to thank - what a great group of people
Borkdude, Tommi, @pez - absolutely stellar development tools
It's very approachable and full of people smarter than me ;)
The clojurians, they are so responsive to any type of query.
Everyone. Technomancy especially, who helped me get started.
everyone who makes things and writes about their experience.
Everybody I think. I never had bad experience with anybody.
Peter Strömberg - his work on Calva provides a good on-ramp
Flexiana, I'm working there and they are doing great job in
The huge willingness to help and the technology enthusiasm.
Rich Hickey, James Reeves, Peter Taoussanis, Sean Corfield
Borkdude - seems to be relentless with the Babashka stuff!
https://github.com/PEZ/ great repl integration with vscode
Alex Miller for everything, Sean Corfield for build work.
People are smart and (the ones I've come across) friendly
They are very kind, helpfull and passionate about clojure
It would have to be Sean and Tony Kay. I use their stuff.
It's cohesive mindset that software churn is a bad thing.
I appreciate everyone who takes time to help educate us.
Rich Hickey, Michael Fogus, Stuart Halloway, Alex Miller
Eric Normand for all the effort to put content out there
@bborkdude @theller. Valuable open-source contributions.
Clojure core devs, JUXT team, everyone who does testing
Sean Corfield, Borkdude (both behind awesome libraries)
Openness and a broad spectrum of backgrounds and skills
Pez, p-himik, theller, rupert (allstreet), adam renklit
Rich Hickey and Alex Miller, for leadership with class.
Did I talk about Michiel Borkient (@borkdude) already ?
Smart often kind people. Tech that works and is stable.
Rich Hickey, Alex Miller, Michiel Borkent, Eric Normand
Everyone really. The passion is obvious and contagious.
Mr Heller from shadow-cljs and daslu (on clojure verse)
John Practicalli because of his dedication to teaching.
There are countless helpful people in Clojurians Slack.
Knowledgeable, and welcoming people. Small "done" libs.
The people. Helpful. Welcoming. Positive. Open minded.
Kindness, thoughtfulness, and extraordinary expertise.
Open mindset. Collaboration and positive interactions.
The spirit of the people and the support they provide.
Smart, open minded, minimal politics and personalities
Rick Hickey, because he created this precious language
The community is great! It is very open to beginners!
Rich Hickey for coming up with it in the first place!
stable and simplicity on focusing on problem solving.
Amazing slack community, I always found any solution.
Appreciate everyone writing and documenting libraries
youtube channeks,"on the code again" and Misophistful
People are friendly, and their examples are concrete.
The focus on developer productivity and good design.
How open and welcoming the community is to newcomers
I haven't been following the community that closely.
Everyone. We're all helping the language to succeed.
Alex Miller. StrangeLoop conference, genius, friend.
Andrew Rudenko for deepening my knowledge of Clojure
High quality commentary with considerable expertise.
It has the best ideas for the future of programming.
Way too many to name individually - thank you all :)
@hi_codie they enjoy themselves and aren't so haughy
Really smart people. Very eager to help newcommers.
It's very active and the ecosystem is quite stable.
Calva creator, babashka creator, datascript creator
Smart people doing cool things and talking about it
T. Heller Peter Stromberg Sean Corfield Alex Miller
Rich, Alex Miller, Bozhidar Batsov, Michiel Borkent
Sean Corfield -- great libraries and source of info
Michiel Borkent Everyone behind Clojurists Together
Most Clojurists seem to be helpful and interesting.
Friendly, helpful, allows one to be eager to learn
really no hangups. very helpful. reasonably active
The Clojure crew - Rich, Alex, Fogus (and others).
Carin Meier, so great to be able to work with her!
Anyone who helps. I feel grateful for the language
Plenty of smart, competent people eager to help :)
Thomas Heller for his amazing work in Shadow-cljs
Daniel Slutsky, bug batsov, viebel, dragan djurik
Everyone is already so eager to help and so kind.
almost everybody, no nonsense helpfulness of them
Datomic team and open source Clojure contributors
Great responses and openness on slack and github.
Friendly and tolerant. Generous and intelligent.
Rich Hickey: reator of Clojure and ClojureScript
Rich Hickey for his good ideas about simplicity.
Alex Miller for his role in shepherding Clojure.
bbatsov, I couldn't live without my Emacs setup.
People of this community are smart AND helpful.
The friendliness and openness of the community.
Jacek Schae, uidev, lambda island, rich hickey,
Friendly, helpful people - especially on Slack.
Very generous crowd in every sense of the word.
Non toxic, clj core devs participating actively
Everyone I've noticed just seems so damn nice.
all y’all. ❤️🔥 so much. seriously thank you!
The careful and slow evolution of the language
It's easy to approach people in public forums.
Doesn't seem to be toxic. Tries to be helpful.
My work colleagues. I learned a ton from them.
The slack channel is full of beautiful people!
The many open source devs and their libraries.
borkdude and eric dallo -> true open sorcerers
Rich Hickey, the talks are always enlightening
borkdude, corfield, and of course Alex Miller!
Metosin. Thoughtful and high quality libraries
I appreciate how many senior people there are.
Michael Borkent for his inspiring productivity
The replikativ team for their work on datahike
Stuart Sierra - use tons of his work regularly
Generally laid-back approach to work and life.
I appreciate Rich Hickey, because he is wise.
Friendly and highly skilled people in general
People are all very senior and super helpful.
All contributors that made Clojure mainstream
Jack Rusher : Inspiration with lispy feelings
Everyone in the slack are incredibly helpful.
Everyone involved in the Clojure development!
Alex Miller - pretty smart and always helpful
The community is friendly and knowledgeable.
Thomas Heller, Sean Corfield, Daniel Slutsky
Sean Corfield!! Daniel Slutsky! Alex Miller
Responsiveness, friendliness and competence
I appreciate everyone in this community <3
Lee Read (lread) is a fount of positivity.
People are friendly and open to newcomers.
Almost everybody. The community is awesome
Maturity, level of discourse, helpfulness.
This is where everybody writes Rich Hickey
The team at JUXT for building a great DBMS
Love it, made my developer reincarnation.
Amazing people (Sean, Alex..) & others...
people is helpful and lot of cool project
I don't know the community enough to say.
So many good libraries and their authors.
So many who I don't even know their names
The community is welcoming and pragmatic.
Alex Miller. He makes good things happen.
The Clojure community inside my company.
shoutout to Michiel Borkent for babashka
Many of #beginners and #re-frame channel
Creator of honey SQL. That is a good lib
friendly and open to discussing concepts
Community is super friendly and helpful.
They are so supportive and constructive.
Rich Hickey & rest Clojure contributors.
The welcoming and positive community. :)
Eric Normand,David Nolen,Rich Hickey...
Borkdude for continuing work on Babaska
thoughtful but also approachable people
Clojureans are happy souls to be around
Alex Miller, Ray McDermott, Rich Hickey
attracts mostly smart experienced folks
Cognitect guys, borkdude, Sean Corfield
Alex Miller, super active and helpful.
Alan Dipert, for his videos on hoplon.
Eric Normand for his podcast and talks
Rich Hickey, Alex Miller, Chris Houser
The whole Clojure community is awesome
Alex Miller, David Nolen. Many thanks!
Alex Miller, super helpful and patient
Tony Kay. Fulcro is a wonderful thing.
Borkdude. Doesn't need to be said why.
Focus on design and maintainable code.
Mike Thompson, who has built re-frame.
Aphyr, for great help and awesome blog
Friendliness and support for beginners
Alex Miller for his community outreach
Eric Dallo, maintainer of clojure-lsp
People are smart, warm and welcoming.
Eric Dallo for making LSP for clojure
Sean Corfield, Alex Miller, @hiredman
Alex Miller, for keeping it organized
Very open and approachable community.
everyone in general seems to be nice
Rich's talks are fun and thoughtful.
People help you if you ask question.
Daniel Higginbotham, liked his book.
Very responsive, helpful and polite.
Anyone from Cognitect + Eric Normand
Great libraries and kind and helpful
friendly community and @borkdude ;-)
Small community and Support everyone
Alex Miller: always helpful on Slack
Michiel Borkent and Dmitri Sotnikov.
Very easy to get help with questions
Stability and backward compatibility
I love it. Really open to beginners.
The kindness and depth of knowledge
Smart people and a lot of good ieda
maturity, kindness, professionalism
Friendly, helpful and enthusiastic.
RIch Hickey, Stuart Halloway, Joinr
Alex Miller for doing the PR stuff.
Slack community has some nice folks
Focus on simple design and helpful
High level of people. Adventurous.
Stability and no nonsense approach
Mature, thoughtful and always open
Metosin. Great quality libraries.
Rich Hickey for insightful talks.
Documentation and guide creators.
All of the open source developers
Pragmatic approach to programming
Experienced and talented persons.
Language and library maintainers.
Simplicity and data-driven design
Conor White-Sullivan. Visionary.
The dedication of the core team!
You, for gathering useful stats!
Several people, cider, babashka,
Alex Miller - Clojure's cool dad
Very helpful people on the slack
Rich Hickey for obvious reasons.
The passion and ease to get help
Not a lot of deprecating changes
friendliness and professionalism
The desire and pleasure to help
All the great folks on #clojure
- Good people - Good language,
Tommi Reiman. Great libraries.
Rich Hickey & Bozhidar Batsov.
Metosin for high quality libs.
Alex Miller for his dedication
No politics, focused on tech.
Scientists, elegant solutions
Far too many people to list!!
Eric Normand, Michiel Borkent
Borkend makes awesome stuff.
Rich Hickey: he made Clojure
Great and helpful community.
all the library contributors
The Cursive devs are awesome
Borkdude, metosin, cognitect
Lots, its a great community.
super welcoming and helpful
Friendly, but to the point.
they are very collaborative
Welcoming, helpful and fun.
Can get answer pretty soon.
Rich Hickey. He's a baller.
Having a friendly community
Response on reddit is huge.
Friendly and knowledgeable.
Team leader and Rich Hickey
Always friendly to interact
Alex Miller Bozhidar Batsov
Smart and respectful people
The passionate members. ❣️
full documents and samples
Super informed and helpful
The community is friendly.
Not using static typing :)
Russ Olsen - inspirational
Expertise and friendliness
Energetic, friendly people
rich hickey, sean corfield
Too many people to list :)
Bozhidar Batsov is amazing
Everyone who contributes.
The core development team
Rich Hickey and his talks
Rich Hickey, Eric Normand
Puredanger, Sean Corfield
Alex Miller Michael Fogus
Very friendly and helpful
no big fights / drama :-)
Sean Corfield, nice libs.
Rich Hickey, David Nolan
polite and ready to help
Very open and welcoming
Rich Hickey - Visionary
Maintainers for support
friendly and supportive
Alex Miller is killing!
super accessible people
Alex Miller no question
theller for shadow-cljs
borkdude and alexmiller
kind thoughtful people
Defn podcast, Apropos,
lots of people here!!
I appreciate everyone
The room for thought.
rich hicky, his talks
Skill and the passion
Everyone is so great!
Passion and community
Friendly and helpful
Amount of ressources
Focus on simplicity.
Helpful to newcomers
everything, because.
Rich, Stu, Alex, ...
culture of no-change
it's very receptive
Intellectual rigor.
Everyone of course!
To many to mention.
Friendly and open.
all the developers
Friendly and smart
Too many to list!
beginner friendly
everyone respects
lgbt friendliness
bbatsov borkdude
Language itself
whole community
Friendly people
Always teaching
Bozhidar Batsov
Great question!
Phil Hagelberg
Thoughtfulness
Genuine people
very friendly
Mister Miller
Very friendly
It's helpful.
Walmart Labs
It is awsome
Not dogmatic
brotherhood,
defn podcast
uig iuu uy i
Everybody <3
Great people
Newcomers...
Mr. Hickey!
Everything!
open source
Rich Hickey
Rich hickey
Rich Hickey
CIDER devs.
Alex Miller
Simplicity.
Rich Hickey
Pragmatism
Everything
Uncle bob
friendly,
Borkdude!
friendly
Everyone
Borkdude
Borkdude
everyone
friendly
Borkdude
Openess
Tooling
Metosin
Sharing
scicloj
Talks.
Rich..
Rich.
Bork.
Alex
Rich
N/A
Rob
N/A
NA
Na
d
.
["alex" 203] ["miller" 185] ["rich" 169] ["hickey" 125] ["borkdude" 124] ["sean" 116] ["corfield" 103] ["borkent" 73] ["michiel" 65] ["eric" 57] ["babashka" 45] ["heller" 44] ["daniel" 44] ["thomas" 41] ["batsov" 40] ["shadowcljs" 39] ["bozhidar" 38] ["david" 37] ["normand" 36] ["metosin" 31] ["calva" 30] ["nolen" 29] ["cljkondo" 25] ["clojurescript" 24] ["slutsky" 22] ["stuart" 20] ["clojurists" 20] ["fulcro" 19] ["pez" 19] ["fogus" 18] ["tony" 18] ["stu" 18] ["michael" 18] ["kay" 16] ["dallo" 16] ["james" 15] ["strmberg" 15] ["mike" 15] ["arne" 14] ["juxt" 14] ["clojurelsp" 14] ["halloway" 13] ["brasseur" 13] ["wilker" 13] ["cognitect" 12] ["bbatsov" 12] ["tommi" 12] ["chris" 12] ["compton" 12] ["fikes" 12] ["lucio" 11] ["tonsky" 11] ["malli" 11] ["nikita" 11] ["weavejester" 10] ["zach" 10] ["sotnikov" 10] ["thheller" 10] ["ghadi" 10] ["reitit" 9] ["gearon" 9] ["sierra" 9] ["phimik" 9] ["john" 9] ["paula" 9] ["mind" 9] ["datomic" 9] ["practical" 8] ["fleming" 8] ["bruce" 8] ["dmitri" 8] ["technomancy" 8] ["reiman" 8] ["tellman" 8] ["hiredman" 8] ["ray" 8]