Poems similar to: dependency

The 64 poems closest in meaning to this word, arranged to spread the colours (progress bar shows chronological position)

Menu │ Chronological


 -> file: fediverse/5282
══════════════════════════════════════════════════════════════──────────────────────
  I wonder why someone hasn't yet written a "meta-package-manager" which
  installed from many different sources and correctly configured each
  installation to be able to efficiently find exactly where the requisite
  libraries are installed, even if they're installed for a different system.
  Then, when running, every time it encountered an error, it moved one more
  dependency over to the native package manager until eventually everything is in
  order.

  ... or something like that, truth be told I'm a junior
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════════════─────────┴───────────┘
 -> file: fediverse/5560
═══════════════════════════════════════════════════════════════─────────────────────
  ┌───────────────────────┐
  │ CW: cursing-mentioned │
  └───────────────────────┘


  dependencies would be fuckloads easier if applications put their files in
  ~~standard locations.~~ actually it's better if they are at abstract locations
  - meaning it can be user defined for each file.

  then, have some "sensible default" setting the user can configure which says
  "if an application wants to store a, say, config file, where would it put it?"
  and you'd say "oh in the ~/configs directory" then the install wizard would say
  "yes yes very good, and now where should I store user interface templates?"

  then the user is like... "wat" because they don't know how the software works
  yet.

  this solves 90% of all software dependency issues because all you have to do is
  keep a file with all the directories for each program. then, search through the
  file every time you need a dependency connection.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════────────┴───────────┘
 -> file: messages/949
════════════════════════════════════════════════════════════════────────────────────
  like if everyone was a package manager repository
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════════───────┴───────────┘
 -> file: fediverse/5487
╔═════════════════════════════════════════════════════════════─────────────────────┐
║ if I click a .exe link on a website, it should just...                           │
║                                                                                  │
║ automatically download the file and open it up in wine or the                    │
║ whatever-windows-uses.                                                           │
║                                                                                  │
║ why is it cumbersome literally just, let me download the source-code repository  │
║ to someone's computer and let them compile it themselves without even thinking   │
║ about it                                                                         │
║                                                                                  │
║ "you mean like, package manager hooks into a website?"                           │
║                                                                                  │
║ yes, but, instead of implemented one-by-one, it should use a protocol so each    │
║ package manager only has to implement the downloading scheme *once* and it'd be  │
║ able to read from any locations that output the correct API calls or whatever.   │
║                                                                                  │
║ the developer could even do it themselves. such is the joy of open-source        │
║ computing - if you like a service or product, you can make it work with your     │
║ own. What else is there to work on but the ultimate computing product?           │
║                                                                                  │
║ aka... everything that anyone's ever been known?                                 │
║                                                                                  │
║ "girl you are loco what's your plan for the fight you continue to demand"        │
║                                                                                  │
║ oh idk um probably just wait until someone asks me to speak                      │
║                                                                                  │
║ "do that~"                                                                       │
╠═════════╗                                                            ┌───────────┤
║ similar ║                       chronological                        │ different │
╚═════════╩══════════════════════════════════════════════════──────────┴───────────┘
 -> file: fediverse/1123
══════════════════════════════════════════──────────────────────────────────────────
  @user-835

  kinda feels like that type of work, the kind that people rely on, is more
  important than... whatever they were having you work on at work-work.
  (assumption on my part)

  and if that important work is not provided for, in the allocation of resources
  applied toward the developer who is developing security developments that
  develop required functionality for the development of people's
  communication/interactions, then perhaps resources should be allocated for
  resolving those difficulties.

  Or maybe not idk I'm broke, shows how much I know about money
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: fediverse/650
═════════════════════════════════════════───────────────────────────────────────────
  why don't we just demand backwards compatibility of our software as a
  requirement?

  ah because that would reduce demand. Nevermind that it's more flexible,
  nevermind that we could accomplish so much more with it - it's expendable
  [expensive] because it reduced market penetration. Not because of the
  technology, because of the deluded and self-perpetuating
  mechanicosmic-mechanicommunication that designed our lives. It's name is
  capitalism, and it thrives where we survive, so that's good enough to
  maintain-em? Sure why not. Brb sleeping for 8 hours. Or playing games.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘
 -> file: fediverse/3085
═════════════════════════════════════════════════───────────────────────────────────
  a package manager that downloads from any package manager

  to switch between if something goes wrong
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: messages/455
════════════════════════════════════════════════────────────────────────────────────
  I don't understand why modern software isn't error correcting. We shouldn't
  have any bugs in this day and age.

  For example, if you're missing a dependency then why doesn't your program try
  to, I dunno, download that dependency to the program's installation directory
  and use it there? Seriously there are very few problems that are unsolvable!
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: messages/1280
═════════════════════════════════════════════════════════════════════════───────────
  all things come with strings attached. how else would they be interconnected?
  if A then B...
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧═──────────┘
 -> file: fediverse/5191
════════════════════════════════════════════════════════════────────────────────────
  do you love linux or do you just love fixing dependency errors?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════───────────┴───────────┘
 -> file: fediverse/1118
══════════════════════════════════════════──────────────────────────────────────────
  ┌──────────────────────────────────────────────────────────────────────────────┐
  │ CW: re: Product warning: Aveeno products have been reformulated, now harmful │
  │ for people with allergies                                                    │
  └──────────────────────────────────────────────────────────────────────────────┘


  @user-820

  the reason they do that is because they want to alienate you as a customer.

  your needs are too specific, they are not that of the majority where they
  derive their profit. so they dismantle the operational functionalities
  necessary to provide the product that you are adapted to, that best suits your
  needs. In doing so, they perhaps save some money, you can't tell of course. why
  would they tell you why they're hurting you by depriving you of a product you
  depend on?

  how cruel
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: messages/679
══════════════════════════════════════════════════════──────────────────────────────
  What if we paid people to administer a database of people who needed mutual aid
  so we could keep track of them, organize them, and care for them?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════─────────────────┴───────────┘
 -> file: fediverse/4772
═════════════════════════════════════════════════════════───────────────────────────
  @user-1692

  I usually write everything down in a script that way when I call it from an
  external service all I have to do is point at the file

  sorta like... hacking environmental options into a config file

  like... I don't write an ffmpeg command every time I want to record my screen.
  I just type "screen-record" and then it'll do the thing that I figured out how
  to do a long time ago.

  ... oh no there's an error, I wonder what changed out from under my feet.

  huh it's wine, that one's always confusing to debug. Let's see... "could not
  open program.exe" uh-huh. Well, why not? is there a dependency issue? something
  miscompiled or configured? no? it's just... broken? you don't get to use that
  program today? huh that's weird. that's linux for ya I guess.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════──────────────┴───────────┘
 -> file: fediverse/4728
════════════════════════════════════════════════════════────────────────────────────
  every time a software project changes it's installation method I have to update
  my install and update scripts which I wrote explicitly so I don't have to go to
  their website and tell the world that I'm thinking about using this particular
  piece of software
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════───────────────┴───────────┘
 -> file: fediverse/6385
══════════════════════════════════════════════════════════════════════──────────────
  interpreted programs allow you to change variables at run-time from remote.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════════════════════─┴───────────┘
 -> file: fediverse/1247
═══════════════════════════════════════════─────────────────────────────────────────
  so wait is there any guarantee that the "releases" on github actually have the
  same code as that which is in the repository? Or could they just... put their
  own binary, with it's own strange rules and vulnerabilities, or am I just
  fearmongering?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: bluesky/21
══════════════════════════════════════════════════════════──────────────────────────
  the main product that github offers is the assurance that the code displayed on
  your monitor is the same as the one running on your computer.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════════─────────────┴───────────┘
 -> file: fediverse/5211
═════════════════════════════════════════════════════════════───────────────────────
  ┌──────────────────────────────────┐
  │ CW: most-of-this-post-is-made-up │
  └──────────────────────────────────┘


  My computer has an extended password where you have to type the things that
  most people put in ~/.bashrc in order to get the system fully operational

  people say "why does it take half an hour to turn your computer on" because I
  keep forgetting the somatic typing components, beatrice. dear, please give me a
  moment, I'll have netflux up and running in - ... oh yes thank you, I would
  have typed netflix in wrong. that helps, and explains this error here where it
  says it can't find "netfucks"

  I was like... WHY ISn't this listed in the dependency repository??

  [hackers just clone your hard drive megabyte by megabyte every time you start a
  particular program or use a piece of the system utilities like finder or
  un-win-rar, so having a longer password won't help]
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════──────────┴───────────┘
 -> file: messages/110
════════════════════════════════════════────────────────────────────────────────────
  The best way to program computers is to organize them according to their
  relations. Like, when x increases by 4 then y increases by 2 - basically, a
  math equation that you can continuously solve by calculating more and more
  comprehensively and deeply.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> file: fediverse_boost/416
◀═╦═══════════════════════════[BOOST]════════════════════════════────────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ If you can, try to reduce how dependent you are on evil organisations    │ │
  ║ │ to get by day-to-day                                                     │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ similar │                     chronological                      │ different │
  ╚═════════╧════════════════════════════════════════════════════────┴───────────┴─▶
 -> file: fediverse/1871
═══════════════════════════════════════════════─────────────────────────────────────
  I think all software should have config files

  or accept as many command line arguments as necessary to achieve all the
  functionality of a config file without requiring a standardized setup

  or accept a config file as a command line argument, to allow for multiple
  different implementations

  or whatever you can throw together in your spare time because software is
  either open source or it hates you.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: fediverse/5034
════════════════════════════════════════════════════════════────────────────────────
  github is overrated.

  git is underrated.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════───────────┴───────────┘
 -> file: fediverse/307
═══════════════════════════════════════─────────────────────────────────────────────
  normalize building a library that's just a wrapper around solutions you've made
  to common problems from the past that can be imported into every project you
  work on
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════────────────────────────────────┴───────────┘
 -> file: messages/69
════════────────────────────────────────────────────────────────────────────────────
  https://blog.discord.com/how-discord-stores-billions-of-messages-7fa6ec7ee4c7
  https://news.ycombinator.com/item?id=20178267
  sendinblue
  open source google docs alternative
  https://hackea.org/notas/index.html#
  https://thenftbay.org/description.html
  https://digital-strategy.ec.europa.eu/en/library/study-about-impact-open-source-
  software-and-hardware-technological-independence-competitiveness-and
  https://joinup.ec.europa.eu/collection/open-source-observatory-osor/document/com
  plex-singularity-versus-openness

┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═══════──┴────────────────────────────────────────────────────────────┴───────────┘
 -> file: messages/948
════════════════════════════════════════════════════════════════────────────────────
  [a while later]

  what if every instance of the OS acted as a git repo for all the other people's
  programs
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════════───────┴───────────┘
 -> file: fediverse/1940
════════════════════════════════════════════════────────────────────────────────────
  @user-579

  Yeah if there isn't a package in the package manager XBPS then I usually just
  install it from source. Which is ALSO something you can automate with a quick
  and easy script! Just put all the notes from the README on Github or whatever
  into a file named "update" and put that one level above the project directory!

  For any installed program my file hierarchy usually looks like:

  program-name
  - run (script)
  - update (script)
  - files (directory to clone into)
  - configs (point the program here)

  I find that this kind of organization makes it MUCH easier to keep my packages
  configured and installed as I'd like. Using a package manager is hard because
  they're all specific per distro, but using this distro-agnostic approach always
  seems to work better 9/10 times I find.

  And if another program needs a library that you manually installed, just
  symlink where it's looking to point to where you're installed! Or vice versa I
  guess.

  I use DWM so I don't have a desktop like KDE or anything like that
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: messages/10
────────────────────────────────────────────────────────────────────────────────────
  https://www.reddit.com/r/learnprogramming/comments/n0vm6e/im_just_now_understand
  ing_gitgithub_and_i_feel/
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘─────────┴────────────────────────────────────────────────────────────┴───────────┘
 -> file: fediverse/5839
══════════════════════════════════════════════════════════════════──────────────────
  @user-1074

  good code isn't always easily read. sometimes the architecture is more
  important.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════════════════─────┴───────────┘
 -> file: fediverse/2862
═════════════════════════════════════════════════───────────────────────────────────
  I don't like package managers...

  [then don't use them]

  oh right 4head
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: messages/128
════════════════════════════════════════────────────────────────────────────────────
  Opt in usage tracking that distributes a pool of money (single donation or
  recurring charitable subscription) to each of the open source software projects
  that a particular user uses
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> file: fediverse/1141
══════════════════════════════════════════──────────────────────────────────────────
  @user-858

  hang on something doesn't add up
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: fediverse/4056
════════════════════════════════════════════════════────────────────────────────────
  teachers didn't want you not using Wikipedia as a source because it might be
  unreliable

  The knowledge they might have is good, but that's not the point

  they didn't want you to use Wikipedia because they didn't want there to be one
  single repository of information.

  If everyone's working with the same kind of training data, nothing new ever
  really gets done
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════───────────────────┴───────────┘
 -> file: fediverse/1504
════════════════════════════════════════════────────────────────────────────────────
  @user-1013

  posting any kind of link to externally hosted content (even a miniature DNS
  like link shorteners) is risky because you don't control the data you're
  sharing / pointing to.

  If you can, try and remember to download videos you like. Save songs that
  resonate with you. Take screenshots of important tweets that other people make.
  Then, you can share them when they're thoroughly divorced from the context in
  which they were made, and in doing so share information to a group of people
  who might not otherwise have heard the words you're sharing.

  Like posting Mastodon links on Facebook - can you imagine!
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════───────────────────────────┴───────────┘
 -> file: fediverse/6394
══════════════════════════════════════════════════════════════════════──────────────
  I wish I had a project manager who managed me and like 4 other me's to work on
  our own individual projects without me needing to know about or work with the
  other me's
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════════════════════─┴───────────┘
 -> file: fediverse/1941
════════════════════════════════════════════════────────────────────────────────────
  @user-579

  I've never actually used xbps-src, I usually just compile it using the same
  tooling that the people who made the program use. If your project doesn't have
  a make file then it's probably not ready for distribution yet. That's like, the
  first thing I write! Though I don't use make, I just use BASH and chain
  together compiler commands and whatnot
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/5213
═════════════════════════════════════════════════════════════───────────────────────
  what if we had hackathons for fedi friends if none of them had a more important
  active project
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════──────────┴───────────┘
 -> file: fediverse/1493
════════════════════════════════════════════────────────────────────────────────────
  Thin clients are great if you can rely on network connectivity. Like if it's
  wired with ethernet.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════───────────────────────────┴───────────┘
 -> file: messages/1203
════════════════════════════════════════════════════════════════════════────────────
  Programmers are lazy, this is well known. So why would i trust by default that
  anyone would read open source code looking for security exploits or malicious
  code? I trust an LLM for that more than a human. At least your own LLM can
  digest the entire project or library at once.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧───────────┘
 -> file: fediverse/5398
╔═════════════════════════════════════════════════════════════─────────────────────┐
║ @user-192                                                                        │
║                                                                                  │
║ step one, doesn't it suck how we have to mount drives                            │
║                                                                                  │
║ part two, gee I sure wish networking was easier than building packets in C and   │
║ pushing them over IP/TCP                                                         │
║                                                                                  │
║ section three, what if every user logged in to the same system of environments   │
║ and kept all their data to themselves while contributing compute to various      │
║ valuable processing processes like windfall calculations and population density  │
║ administrations                                                                  │
║                                                                                  │
║ book four, I wish I didn't have to type -p now when telling my computer          │
║ goodnight, I should write a script that solves that in like 4 lines two of       │
║ which are empty                                                                  │
║                                                                                  │
║ what about five, where they talk about sourcing functions?                       │
║                                                                                  │
║ I like to use recursion - calling my own functions inside of my own bash scripts │
║                                                                                  │
║ "something something modularity" okay docker bro like I'd really package up      │
║ anything that I'm working on                                                     │
║                                                                                  │
║ I mean really who really cares about how I set up the infrastructure of my       │
║ system. it's gonna be unique to each person's memory of setting it up anyway,    │
║ so why bother with "standardization"                                             │
╠═════════╗                                                            ┌───────────┤
║ similar ║                       chronological                        │ different │
╚═════════╩══════════════════════════════════════════════════──────────┴───────────┘
 -> file: fediverse/364
╔═══════════════════════════════════════───────────────────────────────────────────┐
║ okay here's an idea, waterfall project management where the program is           │
║ developed one tiny piece at a time while being streamed to the entire company.   │
║ Everyone would submit answers which could be upvoted / patched / rewritten as    │
║ the main viewer cycles through each aspect of the project, checking for updates  │
║ to it's design that were suggested by developers or whatever. Basically, one     │
║ person (or one team) gets to write the actual source code, while everyone else   │
║ is just offering suggestions. You could break it up by specialty, but the whole  │
║ point is that everyone gets a complete picture of how the program (and           │
║ organization) is structured. Which should give the employees more power to       │
║ generate value for the company. All around a good deal I think? Especially if    │
║ the main viewer took time to explain each and every part so that every viewer    │
║ had the chance to understand.                                                    │
║                                                                                  │
║ the reason why order is important is that our actions ripple through eternity.   │
║ we must set a good example for all the baby aliens, don't you think?             │
╠═════════╗                                                            ┌───────────┤
║ similar ║                       chronological                        │ different │
╚═════════╩════════════════════════════────────────────────────────────┴───────────┘
 -> file: messages/507
══════════════════════════════════════════════════──────────────────────────────────
  Trust me, but don't depend on me. I will let you down, for I am just a person,
  and people pin their hopes upon people and are defeated when they fall.

  Trust, but verify. Trust, do not depend.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: messages/1247
═════════════════════════════════════════════════════════════════════════───────────
  you can even design it as you go, making it do slightly adjacent uses in
  addition to what it currently does. for example:
  https://github.com/gabrilend/r-mail is a reference implementation with some
  ideas for how to design some specific parts. make sure you go through it
  yourself though, so you understand how it works. don't worry, the source-code
  files are numbered like the table of contents [chamber of commerce] in a story
  or book.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧═──────────┘
 -> file: messages/324
═════════════════════════════════════════════───────────────────────────────────────
  The difference between front-end and back-end programming is whether or not you
  want to design abstractions or use them. Backend is all about creating abstract
  things that are networked together, while front end is about putting them
  together in a way that suits the user. Front end is collage, back end is pencil
  drawing.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════──────────────────────────┴───────────┘
 -> file: fediverse/3663
══════════════════════════════════════════════════──────────────────────────────────
  @user-1582

  It depends on the size of the file, copying a thousand lines of config file
  probably isn't that big of a deal, but copying a million lines in a log file
  just to pass it as an argument to... pad it to the left, or whatever, that'll
  DEFINITELY slow down your execution speed!

  Much better to pass by reference, usually...
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: messages/1347
═════════════════════════════════════════════════════════════════════════───────────
  look, I just want to live in a world where people can sell a hand-knit sweater
  for thousands of dollars to someone who bought it for 50$. Is it so odd that
  "supply and demand" can be measured differently on the "supply" and "demand"
  side?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧═──────────┘
 -> file: fediverse/1034
══════════════════════════════════════════──────────────────────────────────────────
  @user-192

  be careful, recursion can cause stack overflows.

  better to run function pointers from a loop. That way you can operate as long
  as necessary. Just make sure you don't get in an infinite loop...
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: fediverse/3086
═════════════════════════════════════════════════───────────────────────────────────
  a package manager that hosts mods to games
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/379
════════════════════════════════════════────────────────────────────────────────────
  someone should make an application that runs locally and keeps track of every
  post, comment, picture, etc that you ever made on the internet. Then, if any of
  them are ever deleted, it notifies you so you can stop using whatever service
  mishandled the data that you trusted them to safeguard.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> file: messages/264
═══════════════════════════════════════════─────────────────────────────────────────
  Don't write self documenting code! Force people to read the documentation so
  they know how to use it
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: fediverse/5189
════════════════════════════════════════════════════════════────────────────────────
  computer programming essentially boils down to putting the right values into
  the right datastructures at the right time and in the right order.

  If you count a function call as a datastructure, which I do, because I have
  opinions.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════───────────┴───────────┘
 -> file: fediverse/3754
═══════════════════════════════════════════════════─────────────────────────────────
  @user-1071

  You know, that makes sense! Finance plus signing things. Their operations are
  probably more... paper based and contractual than programmatic.

  When I think of devops I think of my time spent as a contractor for a large
  tech company...
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/3705
═══════════════════════════════════════════════════─────────────────────────────────
  what is the point of modular power supplies if they can't use cables from
  another power supply?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/1870
═══════════════════════════════════════════════─────────────────────────────────────
  why would I want other people using my computer? They don't know how to use my
  computer! They might break something or mess something up or automatically
  read/edit my files that are stored in standard locations through the usage of a
  script which automagically scans and ransomwares machines on the internet who
  store their files in specific standardized locations! no thank you.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: notes/algorism-neighborhood-distribution-network
═══════════════════════════════════════════════════════════════─────────────────────
  Algorism is a system designed to work for any level of organization. It scales.
  It accomplishes this by abstracting individual needs into communal needs at a
  certain level of size or complexity, and in doing so it enables people to take
  responsibility both for their individual lives, but also the lives of the world
  around them. This increased level of "stake" that people "hold" in their lives
  will encourage them to develop their surroundings in a healthier way, thus
  leading to a safer, saner, and more productive society for all.

  How is this accomplished? There are many aspects to Algorism, and this note is
  an examination of one particular facet - specifically, the requisition system
  which delivers goods and services to entities larger than a single individual.

  It may be best illustrated with an example. Consider a neighborhood - or, even
  simpler, a suburban street, lined with houses. There may be 20-50 families on
  that street, depending on it's length, so let's say there's around 30. These
  families hold a common cause together - they all want their surroundings to be
  generally pretty nice, clean, and decent. They may share many other things
  besides, but these are things that most people can agree on.

  These 30 families need supplies and infrastructure in order to have a good life
  lived in their small little "town". Some common ideas for unification activities
  include knocking down the backyard fences and letting them relish the shared
  safe space for children, gardens, and nature. This is an example of a cultural
  method for building a "good life" for them, however they need to have some sort
  of "economic" method of good-life-building as well. The reason I say this is
  because no matter what level of complexity you reach, there are always economics
  involved, for an individual distributing blood cells to each of it's fingertips
  all the way up to families sharing the food on the serving plate at dinner. Go
  up higher and you have perhaps neighborhoods sharing commonly used tools or
  resources, then cities and states and countries sharing people, talents, and
  brotherhood.

  Economics are a symptom of systems, not power. Power is coercive, it compels
  others to obey thine will or else face retribution, but systems do not require
  power in order to function. A system could be as simple as "you scratch my back
  I scratch yours", which is a simple way that our ancestors learned about basic
  cooperation. Systems can scale of course, and they need not be comprised solely
  of verbal, mental, or legal agreements - computer systems, economic systems,
  spiritual systems, systems of math or physics, all of these things are based on
  the philosophical discipline known as "logic". Logic is fallible of course, it
  is certainly possible to create systems of logic which are completely unsound
  or invalid and which fall apart upon being used for the first time. However,
  when considered with a scrutinous eye for detail, and referenced to the results
  of the real world and it's endless permutations, logic can be an excellent tool
  for developing organization and structure. Both of which are invaluable for all
  humans when they seek to cooperate or coordinate.

  If thirty people who lived near each other wanted to cooperate or coordinate on
  the goal of "building a good life", they might reach for a logical method of
  developing their surroundings toward how they feel is most suited to their needs
  and demands. In order to do so, they'll need supply and infrastructure. The
  question of acquiring such supply and infrastructure is ultimately up to them,
  but the Algorist way of doing so is to utilize the queue system.

  This system is related to queues as typically understood only in name and in
  technicality, for the additional structures built on-top of the queues are more
  than sufficient to differentiate it. When you, dear reader, hear the idea that
  you'd have to wait in line in order to get your food at the cafeteria, you may
  shudder and think about how you'd prefer anything else. After all, that's how
  they did it in the Soviet Union, and there are plenty of horror stories about
  how it took 10 years to buy a car, or how the factories were graded based on
  weight so they'd sneak lead into all their lamps or whatever in order to seem
  like they were doing well. They gamed the system, in a word.

  However, America in 2025 is not as simple as the USSR in the mid-1900s. We have
  computers now. We do not need to coordinate using paper and pencil. This enables
  us to create things like web-UIs for Amazon, a world-wide distribution network,
  or to build SQL databases full of every record we could imagine and store it on
  a computer the size of a brick. There is no end to the power that computers may
  bring to us, but with great power comes great responsibility, and the pragmatic
  programmer will work tirelessly to reduce complexity of scale.

  A queue is a system where the entities who are to be served, delivered, or
  otherwise operated on are placed in line, and those which are placed first are
  focused on with priority over those that entered the queue later. There are
  many types of queues but this is the one we will use for this note. Using this
  basic definition, we can see that there are many opportunities to implement
  additional mechanics
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════────────┴───────────┘
 -> file: fediverse/4844
═════════════════════════════════════════════════════════───────────────────────────
  working on open source software projects is praxis
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════──────────────┴───────────┘
 -> file: notes/open-source-flaws
════════────────────────────────────────────────────────────────────────────────────
  the flaw with open source software is also it's greatest strength.
  it is open, so it can be observed by practically unlimited perspectives.

  however, it lacks follow-through. a larger, more concerted effort, can often
  bring greater and more efficient results.

  the trick is in the balancing, and ideally you'll never falter -
  but it's best when you all get along.

  new ideas, new frames of mind, and more of us kept together.
  if one splinters off, the rest are at fault,

  and you don't want to lose your finger

  so why fight at all? why not focus on our own times? and then together we are
  one

  in sight of our homes, is when we're most alarmed, because houses are not for
  your homeless

  yet together they might
  have strength for the fight
  that ever bears down on our shoulders

  x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x
   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x
    x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x
     x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x
      x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x

  There was something else, but I can't remember. Something about open source
      software that was important enough to get me to write this note. Somewhere
      along the first line I lost it, or rather felt I needed more context, and
      then when the context was finished the original intent was lost. It's hard
      because when I go for the conclusion first and justify it with context,
      then the conclusion doesn't make sense and the context meanders. I'll try
      harder next time. These notes are my life's work.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═══════──┴────────────────────────────────────────────────────────────┴───────────┘
 -> file: fediverse/875
══════════════════════════════════════════──────────────────────────────────────────
  @user-192

  block input/output TO the protocol? versus the other one which blocks the
  input/output protocol
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: fediverse/2566
════════════════════════════════════════════════────────────────────────────────────
  ┌──────────────────────┐
  │ CW: re: mh+, nix     │
  └──────────────────────┘


  @user-1286

  I totally agree! Every time I install new software I write an "update" and
  "run" script so that I can easily use software that I haven't touched in a
  while.

  once I started doing that the usability of my system went way up. Unless they
  change the installation requirements, grrrrrrr
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/2423
════════════════════════════════════════════════────────────────────────────────────
  does anyone know of any fedi software that lets you link to a particular post
  and read forward on a person's timeline from there? Or back I guess, but
  chronological viewing specifically.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: messages/1514
════════════════════════════════════════════════════════════════════════════────────
  just because someone is giving you what you need doesn't mean they'll help you
  when in need.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧════───────┘
 -> file: fediverse/1241
╔══════════════════════════════════════════────────────────────────────────────────┐
║ https://rsc.vet/wiki/index.php?title=Open_RuneScape_Classic_Wiki                 │
║                                                                                  │
║ this is the project I was referring to, I think. Can't see how to host on their  │
║ website so maybe I was wrong - it might need a bit more configuration than I     │
║ made it seem.                                                                    │
║                                                                                  │
║ that's the way WoW private hosting is, like you gotta compile the project and    │
║ stuff.                                                                           │
║                                                                                  │
║ did you know that every time you include a library in a project you're           │
║ necessarily including all of the functionality that they have access to? Well,   │
║ all that which you import. But once a function has been written for a            │
║ functionality then there's no reason to write it again. Unless you're            │
║ refactoring of course.                                                           │
║                                                                                  │
║ phew, sounds like a lot of spaghetti - YEAH IT IS. Spaghetti is fucking          │
║ awesome, it's DELICIOUS OMG ahem I mean if you have collective seminars where    │
║ you discuss the functionality that's relevant to certain parts that you and      │
║ your team are working on, you can more easily be adept at applying them.         │
║                                                                                  │
║ phew, sounds like a lot of thinking, not enough writing. Well, write then!       │
║ Ideas are more spark when currently writing. : ) : )                             │
╠═════════╗                                                            ┌───────────┤
║ similar ║                       chronological                        │ different │
╚═════════╩═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: fediverse/3504
══════════════════════════════════════════════════──────────────────────────────────
  I have too many packages.
the output of neofetch for Ritz Menardi's computer.  OS: Void Linux x86_64 Host: X299 AORUS Gaming 3 Kernel: 6.6.46_1 Uptime: 1 hour, 32 mins Packages: 1757 (xbps-query), 30 (flatpak) Shell: bash 5.2.21 Resolution: 2560x1440 WM: dwm Theme: gnome [GTK2], Adwaita [GTK3] Icons: Adwaita [GTK2/3] Terminal: st Terminal Font: Hack Nerd Font Mono CPU: Intel i7-7820X (16) @ 4.300GHz GPU: NVIDIA GeForce GTX 1080 Ti Memory: 4268MiB / 31794MiB
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/6106
════════════════════════════════════════════════════════════════════────────────────
  ┌─────────────────────────────────────────────┐
  │ CW: wild-unhinged-absurd-thoughts-mentioned │
  └─────────────────────────────────────────────┘


  what if closed source computing is actually better?

  computer programs should be dumb
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════════════───┴───────────┘
 -> file: fediverse_boost/237
◀═╦══════════════════════[BOOST]════════════════════════─────────────────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ External post: https://fedi.rrr.sh/users/pearl/statuses/1139066556106800 │ │
  ║ │ 17                                                                       │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ similar │                     chronological                      │ different │
  ╚═════════╧═══════════════════════════════════════════─────────────┴───────────┴─▶