My entire business is built on Clojure and ClojureScript, and it would not have been possible without these languages. I am always slightly worried by this kind of news, because it means that the main Clojure team is now dependent on a single institution. But it could be good news as well, depending on how things go.
Until now, I've been getting nothing but excellence from the Clojure team: not just great tools, but also great thinking behind them. I appreciate what I've gotten (for free!) until now, and hope that the trend will continue :-)
Would love to hear what you learn from engaging on any expectations you have for roadmap. I wrote separately that I see a bright (very bright, complete game changer) future for the toolchain in finance, but finance is a special ecosystem where general purpose languages with goofy syntax become niche- sometimes very large niche, but still niche.
Niche is fine. I don't know why people are obsessed with languages becoming dominant, or enjoy calling languages "dead". I don't need everyone to use Clojure. In fact, I'd rather prefer that my competitors use something else, because it gives me an edge over them.
I don't have "expectations", I think "hopes" is a better word here. I hope to continue to profit from the core team's thinking and be able to use the tools they create and ideas they generate.
Platform war phenomenon (like Xbox vs Playstation) emerge from winner-take-most effects with a high upfront investment, so you want to make sure you pick a winner and then once invested you want to help them win. A good example of what happens when you lose is the Nintendo Wii U which had like 8 games made for it.
I mean, that may be true to a point in the long run/true outside of webdev.
But the dev who intimately knows Spring & Java/Kotlin is gonna be far ahead of you for the first 9 months, given that there's so much out of the box functionality. They'll be going through a nice paint by numbers scenario for most of the heavy lifting whilst you have to expound effort in creating what's done.
Understand the argument- it's language vs ecosystem- but Clojure leverages the JVM ecosystem in a first class manner. Spring is very productive, to be sure, but I still find that in terms of LOC, Clojure requires less for simple cases, and much less for hard cases, and Clojure practices- like REPL-driven development- themselves are more productive/faster iteration.
Your comment misses alot of nuances about Clojure. Most Clojure devs I know were already senior devs in one or more languages, and were very capable of dealing with any missing "out of the box" functionality.
Besides, by sitting on top of the JVM you have access to alot of mature libraries, and it's extremely easy to do a wrapper in clojure.
What the spring & other frameworks have as an advantage is a predefined set of opinionated choices about logging, error handling, validation and so on that would give you a couple of weeks advantage at top. What they don't have is an expressive language as clojure.
If what you're comfortable with is Spring or Drupal or Rails and those work for your use case then more power to you
At the same time it's true there are products like roam research that are fundamentally harder to achieve in a cookie cutter environment
This talk kind of eludes to why that is https://youtu.be/rI8tNMsozo0 but it's worth learning there's many mature pieces of tech in this community that are astounding
If you need boring.lib then reach into Java/JavaScript with the easiest interop I've ever used
Interesting view. What are the 'out of the box functionalities' which Clojure is lacking? Keep in mind Clojure provides Java interop and with clojurescript js interop. The clojure ecosystem has also pretty great libraries to work with.
For example take a look at fulcro or re-frame, also metosin works on some really great libraries and there is much more.
> What are the 'out of the box functionalities' which Clojure is lacking?
None, because for anything Clojure doesn't have, you just lean on the JVM (or JS for Clojurescript). Sure, the syntax isn't as pretty and there are some abstraction mismatches, but in my experience, you create thin wrappers to hide this and move on.
ClojureScript with shadow-cljs has really good error messages
Clojure's errors require getting used to because they can be verbose but the patterns emerge after some use, that said most beginner errors can be caught before runtime with clj-kondo
Usually you hear skepticism the other way around (that Clojure's productivity advantage over Java style languages in a project could diminish over time as static typing advantages can be more pronounced in the twilight years of the apps lifespan).
I suppose a question for you would be how has your business supported clojure(script)? It seems to me to be a case of a business that has benefited from clojure - and wants to be invested in its future - doing something about it. It cost something to provide what you built your business on :)
A while ago I started to set aside an R&D budget that goes towards developers writing open source, specifically Clojure and ClojureScript libraries, and tools like magit or CIDER. The amounts are still small (this is not an enterprise business), but I'm increasing them regularly.
I want to see a stable, long-term ecosystem with maintainers that are getting paid for their work.
I am about to (next two or three months) launch a company/product that is heavily built on Clojure(script) too and I was actually thinking about this exact thing just this week! There are a number of libraries that I rely on that I would love to give back to, both as a thanks for the work so far, and to fund future development. I'm not in a position to do so yet, but its something I very strongly hope to do in the not-too-distant future, if things go generally well.
I founded operatr.io. Our product, static site, and licensing systems are entirely built in CLJ/CLJS. JVM, brower, lambda, etc.
Like JWR I feel there's absolutely zero chance we could have built this product as effectively in my previous primary JVM languages. Clojure is just a better toolset, no comparison.
We recently enquired with Github about sponsoring as an organisation (rather than me using my personal account) and have been added to the waitlist for the alpha of organisation-sponsoring. Once that starts we'll contribute financially to the developers in our space who enable our business.
Also as a habit I send personal emails to open source contributors simply to thank them in person.
Good luck with your launch!
P.s. I'm very excited for the team at Cognitect. It's hard to start a consultancy, hard to launch a product, there are no guarantees of success, and they deserve all of it.
You could sign up at https://www.clojuriststogether.org/ They do a pretty good job sponsoring both new-ish and critical projects within the clojure ecosystem
Yes, I do plan to! Thanks for reminding me. I do want to look into contributing to a few specific projects that I rely on too, though. Or at least look into hiring the authors for a contracting gig (at least one author of well known libraries does this). I’m not yet financially in a position to do this, but I’m hopeful.
I think even small contributions make a lot of sense, especially if you gradually increase them over time. This is not to gain fame, it's to contribute and support sustainable development. My contributions are spread thin and the amounts sometimes look silly ($5 or $10 per month for a developer), but I believe they do make a difference and I intend to slowly increase them all as finances allow.
I'd suggest looking at Clojurists Together, Github Sponsors and direct sponsorships through PayPal subscriptions.
I look at it as an R&D expenditure (and it goes into my financials as such).
From my standpoint as a one man show, it's invaluable to be able to write the web client and backend in the same language, to share code between them... and have that one language NOT be JS. Clojurescript with Rum/Citrus or Reagent/Reframe deliver on the promise of React/Redux with much less fuss and overhead.
Editing JSX is a pain in comparison to the Hiccup syntax used more often in CLJS, e.g. [:div {:class shiny} "some stuff" [:button "OK"]] - with the structural editing in any good Clojure editor you can cut, paste, entire blocks of tags, or slurp a tag from outside your div into it, or spit one out, all with a few keystrokes, never stopping to find some closing </div> tag.. I guess some JSX IDEs might do this, but it's really nice that the HTML is represented as just another piece of data, not some weird chimerical syntax bolt on.
With Figwheel or ShadowCLJS hot reloading is instantaneous and doesn't even interrupt your webapp. If they're written properly, functions and the app state are not conflated at all, so you can modify any function in your app's rendering or behavior and as long as they aren't incompatible with the runtime state, it will just pop right into your browser. Illustrated well in this video where the author is interactively re-implementing Flappy Bird: https://youtu.be/KZjFVdU8VLI?t=277
I feel particularly strongly about this having started out doing front end work primarily in cljs but recently being falling into using React/Redux for a contract and being REALLY strung out by the tedium of working with them.
My opinion is that clojure has a confluence of just right abstractions and language choices that allows you to be very very succint while still very readable which in turn makes the language very expressive. I can name a few features: immutability, multimethods, protocols, transducers, lazy sequences, macros, and a very small and sturdy core. All of these features exist in some other language, but the combination of them together is what makes clojure great IMHO.
Besides, experienced clojure devs just see things differently and end up writing lots of nice libs that capture the essence of the feature the lib is providing. Think datomic (immutable database), reagent (interface to react), honeysql (data-as-sql), "dependency injection" (mount/component & others), pull/query-based UIs (om.next and its spiritual successor, fulcro) and so on.
Most things in Clojure can be found in other languages. However, Clojure has an especially stable and coherent design story, and is quite a bit better thought out than the other languages I've programmed in professionally. The pieces just work together really well, and there isn't a lot of "extra stuff" that only a die-hard specialist would know, or need to. (I currently work at a financial institution, not Nubank, that uses Clojure heavily.)
A few other high points:
- macro-based metaprogramming, familiar to any Lisp-er; macros are essentially functions which write code for you, which allow one to create extremely concise constructs to reduce repetition in code;
- functional programming: probably the hardest thing to get one's head around if coming from a more mainstream language, FP reduces mutable state to a minimum, eliminating one of the biggest source of programming defects and making programs significantly easier to reason about. Additional concurrency-safe state primitives in Clojure makes concurrency a trivial addition to many programs;
- hosted on the JVM, giving interoperability with Java libraries and significant ease of deployment compared to other dynamic languages (I recently went back to Python to roll out a small web service and was amazed at how much more painful the deployment/devops story was compared to our Clojure services).
These are some of the benefits we leverage; other people here more qualified than me have enumerated others. (Plus Datomic, whose philosophy aligns fully with Clojure, though I have yet to use it in production.)
On a personal note, one final attribute I appreciate is structural editing: as a Lisp, Clojure code is data, a feature which one's editor can make use of to allow operations that would be alien to non-Lispers, such as: absorbing nearby expressions or expelling them; splitting them; sorting and reordering; and writing your own automated refactorings without having to write parsers for the language in question. Treating code as data structures rather than strings of characters allows for speed in writing and refactoring code that is hard to give up once you get used to it.
Lisp + immutability is the right foundation for symbolic/logic programming, datalog, declarative programming, graph programming. None of this is really feasible in other langs due to bad ergonomics and no coordinated ecosystem buyin. Haskell lacks platform portability and Scala 2 is just too complicated to think clearly about anything high level.
I hope at least some of those languages get enough adoption to become viable production choices. I feel, apart from Elixir, Gleam has the most “popularity potential” right now.
In video compression, the advantage of a new standard over an old one is never a single "critical feature". It's a combination of small gains, single percentage points that accumulate to make a huge difference. If you look at H.264 vs MPEG-2, there is no single defining "critical feature", and yet you can get roughly twice as much video into the same bandwidth.
It's similar with Clojure. Are transducers "critical" or revolutionary? Not at all. And yet they facilitate building composable and reusable pipelines, which helps me with modeling a complex problem domain. Is core.async "critical"? Hardly. And yet it allows me to build reliable asynchronous data flows.
Clojure is a practical language, designed by someone with decades of experience in building complex systems.
I used to enjoy programming in Common Lisp, then saw a talk by Rich Hickey which intrigued me. I gave Clojure a try (this was about 8 years ago I think) and (much to my surprise) it turned out it works really well. It also turned out that a coherent concurrency story is important, and that programming with mutable data is not a very good idea after all, so I abandoned CL completely.
Over the years, I got many fantastic gifts: ClojureScript, transducers, core.async, spec — and more. I'm very happy with the choice. I also think my business would not have been possible without Clojure and ClojureScript: the leverage I have because of them lets me run a single-founder self-funded business.
That’d have been 11 years ago. I know because my earliest Clojure project on GitHub hearkens back to July 2009, and I jumped onto the bandwagon after hearing enthusiastic opinions of yours.
Not sure whether I ever had the opportunity to properly thank you, but let me say so now. Thank you, jwr.
It's very simple: it's a solo-founder business. I would not have been able to tackle the complexity of modeling the problem domain, writing server-side code, writing client-side code, and maintaining the whole thing. I would have needed a team, and this SaaS has a growth curve (line, to be precise), which isn't fast enough to get to a team quickly.
This particular business really would not be possible without the reduction in incidental complexity that Clojure+ClojureScript brought.
Until now, I've been getting nothing but excellence from the Clojure team: not just great tools, but also great thinking behind them. I appreciate what I've gotten (for free!) until now, and hope that the trend will continue :-)