-> 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.
┌─────────┐ ┌───────────┐
│ 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 │
╚═════════╧═══════════════════════════════════════════─────────────┴───────────┴─▶
|