Configuration is not a set of toggles, it's not a YAML file.
Sometimes it's more applicable to configure the system by switching out elements and rebuilding.
It's great that software engineering has developed amazing facilities for text-based configurations, but often application of those is supreficial and lacking.
https://www.youtube.com/watch?v=d_s0FS06WNQ
Awesome lecture on the history of post-apollo and how we could have been assembling stuff in low Earth orbit, to then send it places.
Even though I hate firmware / driver bugs, I love #glitchart more. So...
Worth it.
TLDR:
If you suspect that someone is trying to cover up with a three-letter acronym and then fails to properly define it, ask them about its fundamental properties and alternatives to it.
If they can't answer satisfactorily, they likely don't understand the subject themselves.
In this long-toot: a recipe to detect and deal with "anagram-bullshiters" even if you don't know anything about the problem domain within which they're trying to sell you something.
I noticed that #haskell people and #science people are giving abstractions specific names that are nouns. Sometimes semantic: "functor, bifunctor, lens, prism", sometimes borrowed: "monoid, magma", sometimes of loose semantic power: "monad, joker and clown".
Or was it clown and joker?..
#java people and #engineering people love abbreviations. Just today whilst studying #syseng, I got tripped up by "StRS vs BRS vs SRS". Not because I can't tell stakeholder requirements from system requirements or business requirements, but because I simply got lost in the abbreviations.
But I observed an interesting thing: when you ask a haskeller to explain a monad, a lens or a bifunctor, it's very easy to call #bullshit: they won't be able to give you a concrete answer (no matter how long or #eli5-esque), while engineering bullshiters have that fallback of just spelling out an anagram they learned and explaining it word by word. This is a red flag, but maybe a person is simply bad at explaining or defining stuff?
What I suggest to be able to determine if you're facing an anagram-bullshiter or not is to ask these questions:
1. How would one use XYZ?
2. In which situations is XYZ applicable / usable / optimal?
3. What are the alternatives to XYZ and in which situations are they applicable / usable / optimal?
Even if you know nothing about problem domain, you should now have a reasonable amount of information to determine if the person is pretending to be more knowledgable than they are.
My 5-line Vim plugin (https://github.com/jeffkreeftmeijer/vim-numbertoggle) reached 500 stars on GitHub, and that must surely mean something. It took 15 days short of 9 years(!)
https://star-history.t9t.io/#jeffkreeftmeijer/vim-numbertoggle
https://www.youtube.com/watch?v=sk6YUGFRMwI&t=20520s probably the best #RTS games I played in a good while.
I have completely missed #theintercept turing to shit:
https://en.wikipedia.org/wiki/Reality_Winner#Role_of_The_Intercept
Kindergarten tradecraft.
#mastodon is very stable in terms of memory consumption!
But I'm thinking about what we're really doing here in #fediverse and I'm comparing it with, let's say, resource footprint of #circumlunar community (Zaibatsu / ... / Soviet) and realise that their footprint is kind of zero.
Everyone is on one of the three manually federated servers, using UNIX / pre-UNIX tools to communicate with each other, with the only non-UNIX tool being IRC.
Somehow it doesn't take 2GiB of memory and somewhat constant CPU load for #sundogs to exchange bytes.
I get that to host huge instances like mastodon.social, it makes sense to have #pgsql, but it feels like individual instances should be able to be cohosted on the same machine.
I'm committed to explore using file system and files for #doauth persistent storage backend.
But that also brings me to a dilemma of whether or not to use #elixir for the rewrite or to use #rust, to decrease footprint.
Obviously, #elixir will yield more stable, fault tolerant code with easier replication. #Rust, however will reduce excess footprints to 0 at a cost of longer development time (I'll need to benchmark current #tokio-based HTTP servers and see if I need to write my own dead simple server that doesn't use generics / isn't bloated), and it can easily eat up a month of my time.
Maybe it's all non-issue, especially if there's just one BEAM machine launched per host and we plug our applications into it (as intended)...
I think that the fact that I'm heavily leaning towards #elixir as the main production technology even though "close-to-metal" argument is important to me is a clear sign I should use it for production in #doma.
Insightful gzip/lzip/zstd benchmarks comparing compression/decompression throughput and compression ratios:
https://lists.gnu.org/archive/html/guix-devel/2021-01/msg00097.html
(Click on the PNGs at the bottom.)
That https://doma.dev guy
#lean #elixir #typescript #react #nix
In my non-existent free time I design and run #TTRPG
If you use tools made by genocide-apologists, you are a genocide-apologist.
#lemmy users aren't welcome here.