Profile picture
, 11 tweets, 2 min read Read on Twitter
We're a very young business, iterating fast through features, being very careful about writing maintainable code. We have full stack Node apps and full stack Clojure apps. This is a short thread on the difference technology (or would it be language?) choices have made for us.
In the case of the clojure apps, in almost every case, we're able to update underlying libraries very easily, with no breaking changes. Generally, there are way less external libraries used in our Clojure code base. When we reach for them, there are fewer options to pick from.
Our Node apps are easy to change, or write new features for. But.... Dependency updates are a horrible nightmare of broken APIs, dead libraries, and "totally re-written from the ground up"'s. One example of a shining beacon of exception here is react. (there may be others).
I find myself wondering why this is. Could it be that technology choice is about more than just syntax, code style, availability of libraries, IDEs, and the like? Perhaps there is also a big impact from things like culture, philosophy, behaviour, etc.
What drives the difference in behaviour of different communities around technologies? I often hear people say that language choice shouldn't matter, and that "you can do that in language x too". I feel from a feature perspective, this is generally true for different languages.
Yet, the resulting landscapes between Node and Clojure are hugely different. A few examples incoming.
When I want to do something in Node, I find myself looking for a library first, and finding many options. Lots of new ones, and also lots of abandoned ones. Clojure drives me to build things myself first, and reach for libraries as a secondary behaviour.
Clojure library options are fewer, for the same / similar features. Perhaps 2 or 3 choices. Often just 1. These tend to be simple, and very stable. It took some getting used to initially, that they seem not to be updated often, because they are just "complete".
It feels like in the Node world, there is a culture of improvement through replacement. E.g. Vue instead of React. The Clojure world feels more like, improvement through collaboration on existing things, with focus on respecting APIs that are out there.
I'm completely excluding things in alpha / beta phases of development in all cases here. The odd things is... Sometimes, the SAME individuals are working in both "camps". So, why are behaviours different? What's driving differences in approach in different languages?
I've used Node and Clojure here because those are the two we're using. I wonder how much of this would be true in other tech stacks / languages. My conclusion is that language choice matters, and is about more than syntax and where stuff can run. How do we bottle the rest?
Missing some Tweet in this thread?
You can try to force a refresh.

Like this thread? Get email updates or save it to PDF!

Subscribe to Dom Parry
Profile picture

Get real-time email alerts when new unrolls are available from this author!

This content may be removed anytime!

Twitter may remove this content at anytime, convert it as a PDF, save and print for later use!

Try unrolling a thread yourself!

how to unroll video

1) Follow Thread Reader App on Twitter so you can easily mention us!

2) Go to a Twitter thread (series of Tweets by the same owner) and mention us with a keyword "unroll" @threadreaderapp unroll

You can practice here first or read more on our help page!

Follow Us on Twitter!

Did Thread Reader help you today?

Support us! We are indie developers!

This site is made by just three indie developers on a laptop doing marketing, support and development! Read more about the story.

Become a Premium Member ($3.00/month or $30.00/year) and get exclusive features!

Become Premium

Too expensive? Make a small donation by buying us coffee ($5) or help with server cost ($10)

Donate via Paypal Become our Patreon

Thank you for your support!