A one way to address that is via tooling (e.g. to visualize state across time) but maybe there’s something more fundamental to be solved here? Or is it more about current tooling capabilities?

You can gain significant impact multipliers by focusing human attention on a single goal. And not many things do that better than throwing money at a problem.

However with individual's reach extended, the complexity and frequency of collaboration only increases so naive approaches get overstretched and, eventually, break.

Comments URL: https://news.ycombinator.com/item?id=39466317

Points: 2

# Comments: 0

Any recommendations? All I could find is https://github.com/FoundationDB/awesome-foundationdb#layers - not sure how complete and up-to-date that list is.

I think we can agree that it's not that hard to find ANY job as an experienced developer. However it's much more difficult to find a great, satisfying job. For that you need to navigate around a lot of corpo-bullshit type of projects, and Clojure has served me well as a useful filter in doing that. My reasoning is that Clojure is niche enough that when company is using it, you can assume that it's due to a deliberate technical choice, and not just because of its popularity. That tells me two things that are symptomatic, in my opinion, of a healthy tech company culture: - tech decisions are made by engineers, not by top-level executives, - their conclusions and bets align with mine because we all see and agree on Clojure's edge over more popular solutions.

Admittedly, there's always a risk that someone just followed the hype and got out of their depth but I think this risk is relatively small, because Clojure's no longer a new kid on a block and choosing a tech stack is a major decision and usually done by senior tech leadership, hopefully less hype driven.

Of course, Clojure is no silver bullet and it's just a tool that gives you enough rope to hang yourself. Messy codebases are just as possible as in other languages, especially when the team is new to lisps that are very different from mainstream languages, but that's a nature of software development - you learn with the experience. I do cringe when I look at the Clojure code I wrote when I was just starting and wasn't fully grasping Clojure's way of thinking, but the more I use it, the more I come to appreciate how powerful it is.

Great intro that made it click for me: https://www.youtube.com/watch?v=vK1DazRK_a0 (Solving Problems the Clojure Way - Rafal Dittwald, 2019)

Having said that, no software project is ever complete and so isn't Clojure as an ecosystem. The tooling is constantly evolving and new patterns are emerging. What's great about Clojure open-source community is that everyone seems to share the desire to harness complexity and Rich Hickey has convinced each one of us at some point that the way to do it is through simplicity https://www.infoq.com/presentations/Simple-Made-Easy/

Even within Clojure's community there's a diversity of approaches, and I think it's necessary to improve and evolve. The more recent trend, I've noticed is that the community is converging at Data Oriented Programming that's applicable in other languages as well, but has always been at the core of Clojure's mindset that is especially well suited for it.

Dropping some links relevant about DOP: https://youtu.be/8Kc55qOgGps?t=4175 (Rafal Dittwald, “Data Oriented Programming” 2022) - whole talk is valuable, but long so I'm linking to the most juicy snippets) https://blog.klipse.tech/dop/2022/06/22/principles-of-dop.ht...

Moreover, Clojure has already grown past the threshold of being just a niche toy and has sufficiently big market that it won't die off anytime soon. When you study history of programming languages, you'll notice that it's enormously difficult thing to do for an emerging player, especially without big corporate backing. And Clojure is as grassroot as it gets: https://clojure.org/about/history

Clojure's job market is great, there's no shortage of offers, even for newcomers and it has been the top paying lang in stackoverflow surveys for years https://survey.stackoverflow.co/2022/#section-salary-salary-...

However, the most important part is that Clojure is a very powerful piece of technology that made me reevaluate what software engineering really is. You can efficiently use Clojure for both backend and frontend with easy access to libraries from JVM and npm so you will never run into the problem, common in other niche langs, of too few libraries. Nevertheless, Clojure's own ecosystem is filled with many great, cutting-edge ideas that you wouldn't find working so well elsewhere. The community is very welcoming, growing and diverse with people coming from all different programming backgrounds - all sharing the disillusionment with other programming languages and determination to find and build a better way.

https://jobs-blog.braveclojure.com/2022/03/24/long-term-cloj...

Clojure has been a perfect fit for my needs, very similar to what you describe, and neither Rails nor JS have been able to match that.

With Clojure/Clojurescript you get:

- sane, single lang for both backend and frontend (much more seamless than JS/node),

- REPL-Driven-Development - immediate feedback loop translating to huge productivity boost,

- a very refreshing approach to programming,

- access to both two largest ecosystems JVM, npm and of course clojure's own amazing libraries,

- vibrant and diverse community, converging people from all different programming backgrounds,

- much, much more.

Rails and Django are a bit tied to 2005ish MVC paradigm and while it's reliable and gets job done, it comes with compromises on flexibility and user experience - making it hard to be competitive in 2022 as a solo founder. Clojure on the other hand is known for empowering single/few developers to outcompete much larger teams.

Seriously, forget about Rails and Django and just focus on Clojure.

In the time-stressed and client-diverse environment of synchronous text conversations punctuation becomes redundant.

[1] https://calva.io/ [2] https://github.com/borkdude/clj-kondo/blob/master/doc/editor...

Low code platforms, at their core, allow you to define the software with data (from predefined components usually through UI) and that's how they enable super productivity, until you hit a wall.

Data Declarative programming paradigm could potentially achieve the same levels of productivity without its limitations but it's very difficult to get the right implementation.

The most interesting development in this area I had found, is Fulcro Rapid Application Development Tools [1] - a fullstack clojure framework that's performant, declarative and extensible. RAD is still alpha but it bases on battle-proved Fulcro. Once you hit the limits of declarative RAD you can easily extend it with regular Fulcro components which are, in their essence, a cheap abstraction over React/React Native components - offering industry standard performance.

[1] https://github.com/fulcrologic/fulcro-rad

Global Universal Basic Income and Global Carbon Tax.

Global GDP [1] = $142000bn

Human population [2] = 7.8bn

GUBI = $100 * 12 months * 7.8bn = $9360bn

$9360bn / $142000bn = 6.59% of global GDP

6.59% is below the common tax rate. If it could end all wars forever, wouldn't it be worth it?

Can you survive on $100 per month? Barely anywhere so people would still work but it would be a big step towards rebuilding trust among humanity.

We can only avoid violent dystopia if we solve communication and resource distribution problems.

[1] https://www.google.com/search?q=global+gdp

[2] https://www.google.com/search?q=human+population

You don't know that - you just base it on your theory.

Of course, every idea gets perverted by current political system, but the problem is often not the idea itself. Huge appeal of UBI is that it's simple hence easier to control. Taxes were supposed to be simple too and yet they got overcomplected to serve the special interests. The danger of abusing UBI for political gains is as real as it happened with taxes, but it doesn't mean the idea is inherently bad - we just have an inefficient and harmful government system and fixing it should be a priority if we want anything nice like properly implemented UBI. Another Yang's idea, Ranked Choice Voting could at least mitigate some of the issues like political bipolarity.

The beauty of UBI is that government mandated minimum wage, with all its drawbacks, wouldn't be needed anymore. People would be able to refuse shitty job offers and not starve. Ultimately, employers would have to raise wages but not because of the law but because of workers' better negotiation position.

I've been riding this ride through most of my career, working remotely for western startups mostly from Poland. In the end, I don't care how "fair" your compensation policy is - it all comes down to the best alternative offer.

It's a data-driven full-stack application programming system centered around graph-based UI and data management implemented in Clojure [4].

While React lets you be declarative about your UI, Fulcro lets you be declarative about your entire system - both backend and frontend.

Check out this discussion too: https://news.ycombinator.com/item?id=21743720

[1] https://fulcro.fulcrologic.com/ [2] https://github.com/wilkerlucio/pathom [3] https://github.com/edn-query-language/eql [4] https://clojure.org/

It's more like:

Pathom vs GraphQL-based API (vs REST)

and

Datalog vs SQL (vs NoSQL)

The mainstream is in the process of migrating from REST to GraphQL, but I think Pathom could be the black horse in this race. Just watch the last part of Wilker Silva's The Maximal Graph talk to see the potential: https://youtu.be/IS3i3DTUnAI?t=2080