=== ANCHOR POEM ===
══════════════════════════════════════════════════════─────────────────────────────
80% of the complexity in modern computing is from the graphics stack.
the other 20% is from networks.
the last 40% is in avoiding race conditions with multithreading.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘
=== SIMILARITY RANKED ===
--- #1 fediverse/4118 ---
═══════════════════════════════════════════════════════════────────────────────────
all modern software should be written in a multithreaded way, change my mind
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧════════════════════════════════════════════════════───────────────────────┘
--- #2 fediverse/3737 ---
════════════════════════════════════════════════════════───────────────────────────
Nix the complexity.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘
--- #3 fediverse/5247 ---
════════════════════════════════════════════════════════════════════───────────────
the hardest problem in computer science is figuring out why users do what they
do.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════──────────────┘
--- #4 fediverse/988 ---
═══════════════════════════════════════════════────────────────────────────────────
4/20
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘
--- #5 fediverse/989 ---
═══════════════════════════════════════════════────────────────────────────────────
┌──────────────────────┐
│ CW: 3/20 swearing │
└──────────────────────┘
3/20
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘
--- #6 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 │
╘═════════╧╧═══════════════════════════════════════════────────────────────────────────┘
--- #7 fediverse/1810 ---
═════════════════════════════════════════════════════──────────────────────────────
some people hear words like "datastructures" and "object-oriented programming"
and think they're made up terms that don't mean anything important.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧══════════════════════════════════════════════─────────────────────────────┘
--- #8 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 │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘
--- #9 fediverse_boost/5147 ---
◀─╔═══════════════════════════[BOOST]═════════════════════════════───────────────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ Need that E2EE fedi right now │ ║
║ │ │ ║
║ │ i'd be at least 70% more feral │ ║
║ │ │ ║
║ │ and feel cozier opening up and sharing │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐ ┌───────────╣
║ similar │ chronological │ different ║
╚═════════╧═════════════════════════════════════════════════════───────┴───────╝─▶
--- #10 fediverse/4900 ---
════════════════════════════════════════════════════════════════───────────────────
if you wanna trick systems administrators just put a bunch of sleeps in your
code so your computer programs don't use up all the mainframe's resources all
at once
[statements dreamed up by the practically deranged]
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═════════════════════════════════════════════════════════──────────────────┘
--- #11 fediverse/2640 ---
══════════════════════════════════════════════════════─────────────────────────────
┌──────────────────────────┐
│ CW: capitalism-mentioned │
└──────────────────────────┘
capitalism is like if your thread allocator gave 90% of the work to 10% of the
threads in the pool and your tech lead claimed it was more efficient because
the remaining 90% of threads would have the results of the program "trickle
down" to them somehow
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘
--- #12 fediverse/247 ---
═══════════════════════════════════════════────────────────────────────────────────
@user-195 parallel is when two programs run simultaneously, like two parallel
lines (threads) that never touch.
concurrent is when the two lines are split up into chunks and the program
switches between them - like this: -----_----
enter alternate universe
parallel is when two programs operate on the same axis - usually time - and
never interfere with each other. the OS will switch between them as
appropriate to make sure they never intersect. Sorta like this: -----_----
concurrent is when two programs are executed simultaneously, primarily
constituting computation correlated with collective contents of coordinated
collaboration between contextually related coroutines.
It's simple, even a beginner could figure it out.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧════════════════════════════════════───────────────────────────────────────┘
--- #13 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 │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘
--- #14 fediverse/4474 ---
════════════════════════════════════════════════════════════───────────────────────
@user-1268
if you know how to program in C this is a good resource for building
networking applications:
https://beej.us/guide/bgnet/
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘
--- #15 fediverse/4527 ---
════════════════════════════════════════════════════════════───────────────────────
@user-1600
Yes! The ease of use for GPU programming is lovely. Like I said all I need is
a use-case, I've downloaded as much reference material as I think I'd need to
be able to hack together something fairly quickly if I needed it. That's all I
have the mind-space to focus on lately haha
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘
--- #16 fediverse/6269 ---
═════════════════════════════════════════════════════════════════════════════──────
what if the secret to LLM computation is to just not reduce the fractions and
keep it all in english language ram
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════════════─────┘
--- #17 fediverse_boost/668 ---
◀─╔═════════════════[BOOST]═══════════════════───────────────────────────────────╗
║ ┌────────────────────────────────────────────────────────────────────────────┐ ║
║ │ heroism levels are 86% and steady │ ║
║ │ │ ║
║ │ (86%) ■■■■■■■■□□ │ ║
║ └────────────────────────────────────────────────────────────────────────────┘ ║
╠─────────┐ ┌───────────╣
║ similar │ chronological │ different ║
╚═════════╧═════════════════════════════════───────────────────────────┴───────╝─▶
--- #18 fediverse/4826 ---
═══════════════════════════════════════════════════════════════────────────────────
the fact that linux software by default shares libraries causes 90% of the
difficulty that new and medium skill users of linux face.
disk space is cheap. spend more on hard drives and double the software size.
make redundancy that prevents software failures but doesn't slow down the
machine.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧════════════════════════════════════════════════════════───────────────────┘
--- #19 fediverse/5637 ---
═══════════════════════════════════════════════════════════════════════────────────
a program's heartbeat is the alternating "heated up processor" spikes and the
"low temp processor"
[drawing a sine wave with such a tool would enable the viewer to combine
infinitely many decision-matrix-trees. Each of which
co-operatively-co-determine the nature of the entity which percieves. indeed
the combination of many such waves could fourier transform to a lower
resolution (but still locally computationorted) waveform would still enable
the application of that which is stored in storage]
"ohhhhh strange square brackets are computer"
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════───────────┘
--- #20 fediverse/404 ---
════════════════════════════════════════════───────────────────────────────────────
a preprocessor directive that tells the compiler to ignore all warnings on the
next line
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═════════════════════════════════════──────────────────────────────────────┘
|