The Importance of Community

post-thumb

I have a list of things to write about that I keep adding to and not writing. Two of the notes I have written are:

  • The power and weakness of Clojure
  • Why not Common Lisp?

As I sat thinking about what to write, I realized that what hinders the popularity of both languages is a lack of community. I don’t mean the people necessarily doing meetups and conferences, though they are part of it. Instead, I mean the mass of people constantly working on undifferentiating programming problems so that everyone doesn’t have to build everything themselves.

If Clojure couldn’t tap into JVM/JS/CLR communities, it would suffer the same fate as Common Lisp, another powerful language that few use. The language itself is a little better at some things than CL, and a little worse at others. The fact that it can pull libraries from three of the most popular runtimes to ever exist (If you count CLR) is what makes it better.

In Common Lisp, you might sit down to write something that interacts with AWS. An official SDK doesn’t exist, so you’ll find one someone got about 60% done. You’ll start to hack on it and consider taking it a little further before life gets in the way and you end up abandoning it. Someone else will come along later and find the husks you and the others left behind. It happens over and over for everything you can imagine.

The package management system and build tools are all weird. Async web servers require event-driven frameworks, all of which are in various stages of incomplete. SDKs kind of exist for some things. There are partial solutions to all of these problems out there, but you can’t confidently use them without becoming their maintainers. Everyone rolls their own because no one can agree on how to do anything. Few ideas have enough gravity to coalesce.

The requirement that you roll every library your project might need crushes all your inspiration unless you live to roll half-implemented libraries that suit your exact use case. That is what defines most lisp programmers. If I had limitless time, I’d sit down and write as much of what I think needs to exist as I could. I think it’s a beautiful language that people would use if they didn’t have to write everything, but I don’t have the time. No one does.

Clojure deals with this fundamental problem by letting you drop into the JVM. Need that AWS SDK? Pull in the Java one. Need a web server? Grab your favorite Java one. It will run on an actively maintained event framework that has run under production load for a decade and is constantly tuned by the smartest people on earth. Need to target the browser or mobile? Want to run on Node? Clojurescript’s got you.

It’s pretty great, but it is also what makes Clojure unpopular. It means that you have to know the underlying virtual machine to use Clojure/script in anger. You’re going to have to know how to troubleshoot JVM issues, npm package problems, dependency conflicts, etc. Consequently, it’s a language for people who have been at it long enough to pick their battles, and they choose to battle the virtual machine and the problem domain, not the programming language. It’s for people that have decided that not everything is a class, you only need one null, and mutability isn’t worth the hassle. It is hostile to new developers because it requires a lot of expertise right out of the gate. It isn’t apparent to new developers why it even exists because they haven’t gotten deep enough into the shit to understand that everything is kind of terrible, and you take the wins where you can. This means that more experienced and opinionated people that haven’t moved into management primarily make up Clojure’s pool of developers. It’s a smaller pool and relegates a lot of projects to personal ones or to places where said developers have a strong influence over company strategies. It’s a much smaller community, but it gets wins from other larger ones.

Common Lisp and Clojure allow individuals and small groups to be insanely productive, but we live in an age where it’s effortless to lean on the works of HUGE groups as an individual or small group. Javascript/Typescript is an absolute disaster of a language/ecosystem. Yet, you can be insanely productive because armies of people are helping you solve all of the undifferentiated problems.

If I want to start a project in Typescript, it will download half of the internet to get the libraries necessary for it to work, and it will rot if you ignore it for three days, but it will work. Most of the time will let me focus on my problem domain instead of plumbing. That is incredibly fun and inspiring. Of course, in Typescript, my builds will randomly quit working, or I’ll blow 4 hours chasing a weird bug around. I’ll find out that npm did something fucking stupid or that I needed a different config in one of my 1600 dotfiles, but that is a day of inspiration crushed, not a whole dream.

Armies of people are solving all of the problems that they and everyone else have so that developers can focus on whatever interests them. That’s the community that matters. If you want to focus on your problem domain, you’re probably going to either want to be a part of a giant community or at least ride in their wake.