wake me up when Rust fixes its’ supply chain attacks susceptibility (solid stdlib and rejecting external crates, including transitive deps

In Clojure, -> is used for inserting the piped argument at the head position in the arguments of whatever it is passed to, while ->> is used for inserting it at the tail. This approach is great for working with immutable data in a series of approachable transformations, which I believe is one reason why so many Domain-Specific Languages for generative programming are written in that language, aside from its interactive REPL. Additionally, there is no need to worry about excessive copying, as this is generally well optimized.

This can be particularly useful with HoneySQL, which is more of a DSL for SQL rather than a typical ORM tool. For example:

(defn apply-filters [query filters]
"applies WHERE clauses to a query"
  (reduce (fn [q [column value]]
            (helpers/where q [:= column value]))
          query
          filters))

(defn build-dynamic-query [{:keys [table columns filters sort-by limit]}]
  (-> {}
      (helpers/select columns)
      (helpers/from table)
      (apply-filters filters)
      (helpers/order-by sort-by)
      (helpers/limit limit)
      sql/format))

;; Result - a super readable function call that resembles a natural language 
(build-dynamic-query 
  {:table :products 
   :columns [:id :name :price] 
   :filters {:category "electronics" :in-stock true}
   :sort-by [:price :desc]
   :limit 20})

Anything that can run C++ should be able to run Rust if you use the LLVM backend, perhaps except when a watch uses musl libc and you rely on some glibc-only call in your program. afaik the only physical devices shipping with musl are car infotainment systems based on l4 kernels and networking hardware (OpenWRT).

Anything that can run C++ should be able to run Rust if you use the LLVM backend

personally I’d sum it up this way: it is usually enough to abstract two parts of your code: the repetitive stuff and the stuff that can be separated from external dependencies like db or network. That should be enough to ensure readability and that you can test it properly and not have to deal with rewriting half your codebase when you decide to change an external dependency.

Funny how he is actually now a fan of Clojure yet the examples in his book are actually full of mutating data and side effects. And Rich Hickey also stressed that tests are no silver bullet.

Removed by mod

fr the system is in such a deep terminal crisis that talking to people in their 20s feels like talking to pensioners since in countries like the US or UK the life expectancy is declining due to not being able to afford healthy food, stressful and precarious work, mental health crisis and addictions, worsening healthcare, climate change, moldy cramped housing, proliferation of larger and thus more dangerous cars, new zoonoses etc. etc.

typescript is a linter

wonder when Rust will saturate it’s niche as a C/C++ replacement, I’d guess 3-6 years would be when we might start to see some stabilization.

Trump says you won’t need to vote if he wins. But here’s the thing: It’s not just Democrats who should worry. Trump’s chaos could destroy the whole rigged system - Republican and Democrat. He might seem like an undertaker of the American democracy, but in doing so he will drown his own ship, too. But we need to help him steer it into the iceberg of organized social anger instead of isolated floes made of any expectations his mostly temporarily deluded and desperate voters may have or some single-cause activisms or culture wars that will only benefit him. Those will be shattered within the first few months of his term, as he won’t have COVID to use as a convenient excuse for his failures to not only address, but at least not make worse the organic crisis of the system, like Genocide Joe has had.

EDIT: I’m not saying this to fucking endorse him or passivity. What I mean is that the world does not end at the ballot box and we need to reckon with the possibility of his victory and that there are countless other means of resisting him other than just depositing all our hopes in the Democrats. And that even though resisting Trumpism will not be an easy task, the instability and disappointment that a presidency of establishment’s populist enfant terrible, in an era that breeds virtually no statesmen of great stature, is bound to engender, has the potential actually make it easier.

Why does it have to always be a hype that is a literal kick in the eye of gamers? Previously it was shitcoins, now it’s hallucination engines… I’m afraid what’s up next.

Discord as the 2nd most desired sync comm. tool with 71% admire score

fucking zoomers

a webpage that simulates a systemd shutdown when that one stupid service won’t stop?

I need to disagree with you on AI. We did not fail at it. Not because LLMs are good. But because any program processing arbitrary data, even a stupid simple calculator is AI – a machine performing work that human brain can do, ideally with the added benefit of maximized determinism and greater speed. If you reduce this generalistic term I believe is so overly broad we should cease to use it to LLMs, then these criteria seem to have been thrown out of the window since they are usually heuristic balls of python mud.
So having established that it is all just software that processes arbitrary data, let’s go back to the basics of software design. Huge amounts of money and working hours have been thrown into the erratic attempts to create a software that can do everything at once. GPT extensions are fucking dystopian and here is why – we had a tool for that for decades that does it much more better, without imposing digital handcuffs on the user and burning the planet – IT’S CALLED AN OPERATING SYSTEM AND PROGRAMS.

General-purpose AI is a lie sold to you by monopolistic surveillance capitalists for whom it is a dream come true since making a decently reliable LLM requires prohibitively large resources but the endless stream of data much larger and contextualized than was the case for search engines thrown at it compensates that quite well, a pipe dream in terms of achieving what it is aimed to achieve with it’s current design and a nightmare to build and test.

So if we discard this term as a meaningless overly broad buzzword it is since computation on non hardcoded data is what we’ve designed computers that are not just state machines for, let’s talk about what makes Lisp is so good at data-driven programming:

1. Functional programming is generally more deterministic since you have immutable persistent data structures everywhere. This also makes it quite good at implementing safe, reliable concurrency.
2. This determinism is furthered by the homoiconicity – the fact that the boundary between code and data is the outcome of using S-expressions and has powerful implications for eliminating so many data conversion bugs and complexities, all while usually not using static typing (!) and also for the language’s extensivity and building DSLs
3. Very simple syntax, again thanks to S-expressions - just (function arguments...) basically.

I think Eich understood that when he initially wanted to port Scheme to the web browser, after all html does have lispy semantics, but office politics in the heyday of Java forced him to give up on this idea and we’ve ended up with this goofy counterintuitive mess that bred hacky workarounds instead of the extensivity we could’ve had if he did so - take a look at Hiccup templating DSL and decide for yourself if this or jsx are simpler ways of writing out stuff to the DOM.

premature optimization is a root of all evil.

also when those morons decide to do ‘microservices’ but end up creating glorified SOA with one messy DB where half the tables are not even used by anything, updates in place are the standard and there is nothing like one team per service, but instead everyone is expected to navigate millions of lines of spaghetti code with poor documentation, barely any reuse and inconsistencies all across the board with this oh too-fucking-common entity service anti-pattern.

and so much fucking coupling that you better start deploying your dev cluster just right after waking up so it maybe is up and running by the time your daily is over.

Fun fact, I used to work at a company where a lot of projects use Elixir and a bulk share of my coworkers have been outspoken critics of microservices precisely because OTP manages to power fault tolerant and scalable systems but not by insane levels of complexity like kubernetes does but by CoC that rarely gets in your way.

I only use vscodium for things that are not that well supported by neovim, in my case it’s only Scala basically, but I guess I’m just to lazy to properly configure metals. I use Sway as my desktop and I don’t want to go into configuring DPI just for vscodium or switch to gnome to not ruin my vision even further when using it. This is what I like about terminal-based editors - the whole Ui scales with a single key combination. Speaking of which I also consider the combinations provided by many Neovim “distributions” (and my workflow ;p) way more ergonomic than emacs-y finger gymnastics of vscode and the likes, since I just hit the space twice and type a command alias without moving my fingers from where they should be on the keyboard instead of memorizing gazillion combinations working little by little towards giving me a carpal tunnel.

if you want even more frictionless experience and save a few megs of ram check out wezterm, it does a pretty good job of integrating multiplexing into terminal. also it’s very extensible as it’s configurable with lua.

on a side note, I had some stability issues with vscode-neovim where it’d crash it in worst cases.

it’s a feature not a bug, still simpler than chaining 10 iterators where half of them also requires a callback parameter. Clojure even disallows nested % iteratees.

if JS tried not only to use Lisp-like semantics but also Lisp-like syntax then probably we’d still be using it untyped