clojure-news-feed VS hotwire-rails

Your question is interesting to me. As a software architect, I study various tech stacks and programming languages. I concentrate mostly on open source and microservice architectures. I usually start with implementing the same feature identical rudimentary news feed microservice. Over time you start to see the similarities and differences between the various implementations. I blog about this over at https://glennengstrand.info and the source code can be found in https://github.com/gengstrand/clojure-news-feed

You are looking for a decision on what programming language and tech stack to learn next based on career mobility. Here are some questions to consider.

What kind of company are you most interested in working for? Think about the size of the company. Is it in a growth market or is profitability more important? Is it a technology company? Does the CEO view technology as a profit center or a cost center? Do they have a CTO? If they do, then who does the CTO report to, the CEO, the CIO, or the COO?

What kinds of programming languages and tech stacks are on the career pages for the kinds of companies that you are most interested in? Different kinds of companies tend to cluster around different tech stacks. There are other factors to filter for such as how deeply do they embrace remote work or commute distance to where you currently live or are willing to move to.

These are lagging indicators. They are going to be more accurate than leading indicators but that also might indicate that whatever you learn next based on these factors might have a shorter shelf life.

Finally, you should ask yourself what about your current programming language do you like? Try to pick something that you would also like. The Go programming language was originally invented as a better C and is enjoying some marketability right now. Maybe that would be something to look at.

I have a github repo where I implement a feature identical microservice in various tech stacks. I started that repo with a Clojure version that used community provided wrappers. See https://github.com/gengstrand/clojure-news-feed/blob/master/... as an example of calling Cassandra. Recently, I added another implementation with Clojure that just called the Java drivers directly. See https://github.com/gengstrand/clojure-news-feed/blob/master/... for that version of the same call. In the end, I decided to forego wrappers and make the calls directly because you end up with fewer dependencies and are more likely to be able to use latest versions of everything.

I have been exposed to many different tech stacks over the years. This https://github.com/gengstrand/clojure-news-feed repo contains the code used to evaluate thirteen different stacks which is what I can share publicly. What I can say is that the best choice of tech stack depends on what is being called for. Is this for an early stage startup or an intrepreneurial greenfield project? Is this for an MVP or just the next component in an already formalized microservice architecture? What are the skillsets of the developers that you will have access to? Have you reached agreement that you can throw it all away and start over or are you expected to have to live with the choice of tech stack for the life of the product? Are you mobile first? These are all important questions that very much shape the decision.

Applications generated with Rails 7 will get Turbo and Stimulus (from Hotwire) by default, instead of Turbolinks and UJS. Hotwire is a new approach that delivers fast updates to the DOM by sending HTML over the wire.

For Ajax-y stuff, I am really excited by the new crop of "HTML-as-a-Service" or "HTML-over-the-wire."

https://htmx.org/

https://hotwired.dev/

For all the turbo/stimulus/hotwire mix, you want to add a new feature just for the sake of adding it? or do you have a use case that fits the feature? if you have then you probably already have an implementation with a different technology (stimulus reflex? some custom websockets or ajax implementation? something with anycable?) and you have to check how to migrate from that technology to hotwire. If you just want to use the feature with no real need for it to practice then just pick any tutorial from the internet (like the intro in the official website https://hotwired.dev).

I was recently interested in similar topic. Here are 3 similar solutions I found:

* https://htmx.org/

* https://unpoly.com/

* https://hotwired.dev/

My personal preference is Unpoly (the idea of "layers" is awesome). But the best explanation of concept as a whole (HATEOAS, keeping app state on server using partial page updates, etc) is at HTMX homepage, and in these essays:

* https://htmx.org/essays/hateoas/

* https://htmx.org/essays/locality-of-behaviour/

At the end of 2020 the Basecamp team released a collection of Javascript libraries called Hotwire. Modern web stacks have popularized javascript-rendered front ends and JSON transmissions. Hotwire's primary motivation is to reduce the Javascript footprint and allow application front ends to be created in primarily HTML. It pairs very nicely with the Ruby on Rails ideology and is often demonstrated in that context. I aim to write a series on how Hotwire can be used in any application to simplify development and reduce the need for heavy Javascript downloads. Hotwire currently consists of two javascript libraries: Turbo and Stimulus. The first part of this series introduces Turbo.

I've been doing that a while until I just got sock of the JS spagetti and often duplicated code and went full on Angular CSR and never looked back. That being said, I've been seeing a lot recently about Laravel's Livewire and Symfony and Ruby on Rail's integration with Hotwire (stimulus+turbo).