=== ANCHOR POEM ===
════════════════════════════════════════════════════════───────────────────────────
 @user-203 
 
 That's what the GPU is for!
 
 Too bad programming GPUs is unnecessarily arcane.
 
 I've recently been into this programming language called "Chapel" because it
 abstracts away most of the complexity surrounding multiprocessor code (unless
 you want to go deeper and more specific, in which case it allows you to do so)
 
 https://chapel-lang.org/blog/posts/intro-to-gpus/
 
 Also distributed computing, which is totes the future, just sayin'
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

=== SIMILARITY RANKED ===

--- #1 fediverse/4523 ---
════════════════════════════════════════════════════════════───────────────────────
 If anyone has need of an easy-to-use distributed computing programming
 language, or if you're interested in easy-to-implement GPU computing for
 parallelizing large amounts of simple tasks, check out the Chapel programming
 language.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘

--- #2 fediverse/3577 ---
════════════════════════════════════════════════════════───────────────────────────
 ┌─────────────────────────┐
 │ CW: computers-mentioned │
 └─────────────────────────┘


 I love writing installation scripts like this!
 
 If you want to install something on Linux but you have difficulty, talk to me
 and I'll write you a script like this. I might even make it fancier.
 
 This one installs a programming language that is useful for parallel computing
 across multiple clusters of computers which could be useful if you want to
 leverage multiple CPUs and GPUs with ease to compute tasks which are far
 beyond a normal computer.
 
 https://chapel-lang.org/download.html

┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #3 fediverse/6438 ---
══════════════════════════════════════════════════════════════════════════════─────
 why would you gatekeep content by keeping us from easily using LLMs some
 people aren't technical and still need to write computer programs because
 that's how you enlighten a people is empower them with new tools
 
 "I've never heard of that programming language, but luckily I can fit all of
 it's documentation in my context window."
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════════────┘

--- #4 fediverse/3587 ---
════════════════════════════════════════════════════════───────────────────────────
 ┌─────────────────────────────┐
 │ CW: re: computers-mentioned │
 └─────────────────────────────┘


 I realized that script was bugged, so... here's a better one. Plus a fun run
 script too!#!/bin/bash
 set -euo pipefail
 
 DIR="/home/ritz/programming/chapel/language-files"
 VER="2.1.0"
 FIL="chapel-${VER}.tar.gz"
 URL="https://github.com/chapel-lang/chapel/releases/download/${VER}/${FIL}"
 NUM_THREADS="16"
 
 touch     ${DIR}/files
 rm    -dr ${DIR}/files
 mkdir -p  ${DIR}/files
 
 wget --output-document ${DIR}/${FIL} ${URL}
 
 tar xf ${FIL} --directory=${DIR}/files
 rm ${FIL}
 
 cd ${DIR}/files/chapel-${VER}
 
    export CHPL_LLVM=system
    source ${DIR}/files/chapel-${VER}/util/setchplenv.bash
 
    make -j${NUM_THREADS}
 
 
    echo "now testing, to validate LLVM configuration as suggested in the docs:"
    chpl "./examples/hello3-datapar.chpl"
    ./hello3-datapar
 
    echo "the chapel programming language is now fully installed! Have fun!"
 
 cd -
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘

--- #5 fediverse/5291 ---
═════════════════════════════════════════════════════════════════════──────────────
 the most important skill I can think of for a linux software engineer is the
 ability to connect multiple systems together and turn windows and macintosh
 devices into Linux devices so that datacenters can be built out of whatever's
 on the around.
 
 there's this programming language I like called Chapel for distributed
 computation computing which is also cool, if you're more of the programming
 type.
 
 networking security I believe often has hardware solutions, so getting the
 crypto-graphy boys and the PCB girls together to work on some jams is a good
 and productively useful gathering of insightful events
 
 "but ritz computers should only be used to solve problems that people have,
 not make more problems!" ah yes but have you considered that problems find
 you, and the computers help you work through them
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════════════════─────────────┘

--- #6 fediverse/617 ---
═════════════════════════════════════════════──────────────────────────────────────
 So much of computing is just... handling the quirks of hardware and presenting
 it to the user (programmer) in a way that is sane and makes sense, instead of
 the arcane and [nebulous/confabulous/incomprehensible] way that physical
 nature demands our absurdly potentialized computational endeavors be.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #7 fediverse/6215 ---
════════════════════════════════════════════════════════════════════════════───────
 hi does anyone have any good resources on risc-v?
 
 I found this:
 https://dramforever.github.io/easyriscv/#shift-instructions
 
 and this:
 https://projectf.io/posts/riscv-cheat-sheet/
 
 but I'm missing a big gap - specifically, how to move from syntax to
 deployment. I need details on how to implement the software and get it running
 on the actual hardware.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════════════──────┘

--- #8 fediverse/608 ---
═════════════════════════════════════════════──────────────────────────────────────
 @user-453 
 
 Now if only we could convince them that they could use those GPUs to build low
 income housing or cure cancer or something useful...!
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════─────────────────────────────────────┘

--- #9 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 │
╘═════════╧╧═════════════════════════════════════════════════════──────────────────────┘

--- #10 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 │
╘═════════╧╧══════════════════════════════════════════════════════════════════════─────┘

--- #11 fediverse/1597 ---
════════════════════════════════════════════════════───────────────────────────────
 hey a couple months ago there was this really cool visual programming language
 posted here that was like, windows aero themed and it was super cute - does
 anyone know what that was called or have a link to it?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═════════════════════════════════════════════──────────────────────────────┘

--- #12 fediverse/5689 ---
═══════════════════════════════════════════════════════════════════════────────────
 why don't we make large arrays of vram that are slightly slower because
 they're farther on the circuit-board from their host and their reception at
 the processing section has to be gated such that they all enter to be
 processed at once.
 
 like that one infinite scrolling XKCD cartoon where the things move from one
 screen to the other simultaneously assembly line style.
 
 [fail safes. https://xkcd.com/2916/#xt=7&yt=35 ]
 
 if we all feel like we're doing nothing, we'll all grow tired of it and decide
 to do some prevailing. gosh I wish I wasn't so useless is code for

┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════════════════════───────────┘

--- #13 fediverse/3299 ---
═══════════════════════════════════════════════════════────────────────────────────
 what if we could record and playback certain timeframes of our CPU and RAM
 status and use it for debug purposes
 
 like running some code in a VM every time you wanted to show a youtube video
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════════════───────────────────────────┘

--- #14 fediverse/2622 ---
══════════════════════════════════════════════════════─────────────────────────────
 what kind of linux user are you if you don't even like reading terminal
 output? it's USEFUL and INTERESTING information!
 
 WHY ELSE WOULD THE PROGRAMMER OUTPUT IT???
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #15 fediverse/1246 ---
═══════════════════════════════════════════════────────────────────────────────────
 @user-883 
 
 hehe if I don't understand how it works it's difficult for me to use things.
 My Linux friends get so exasperated with me because I'm like "cool script
 gimme like 2 days to figure it out" and they're like "bro just use these
 flags" and I'm like "no"
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘

--- #16 fediverse/3802 ---
═════════════════════════════════════════════════════════──────────────────────────
 what if we got together and adopted a new open source project every month and
 just collectively worked around the clock to learn and work through the
 important problems facing it
 
 or even like, cleared out the backlog of stupid pointless boring tasks that
 would allow the developers to work on something better
 
 call it the wandering parade of development 
 
 could give us some experience organizing small, short-term projects to
 accomplish specific goals and tasks in an ad-hoc way that relied less upon
 procedure and more on "I think so-and-so knows something about that, they were
 looking into those files and posted a breakdown of how they work yesterday"
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧══════════════════════════════════════════════════─────────────────────────┘

--- #17 fediverse/2638 ---
══════════════════════════════════════════════════════─────────────────────────────
 I really do believe that you can write any computer program you'd like with a
 combination of Lua, Bash, and C.
 
 Bash to start the program and enable updates / configuration, Lua to handle
 the scripting and ordering of events, and C (or Rust) to execute performance
 intensive sections. (often in their own threads)
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════════════────────────────────────────┘

--- #18 fediverse/707 ---
══════════════════════════════════════════════─────────────────────────────────────
 @user-524 
 
 Sometimes when I feel overwhelmed with all the boilerplate I just start coding
 and making stuff. Doesn't matter if it works, doesn't matter if it says /*
 FIXME */ all over the place, doesn't matter if it includes header files that
 don't exist yet, as long as you're hacking out the mechanics of whatever
 operations you need to perform then you can figure the rest of that stuff out
 later. The creative urge doesn't last forever, which is why projects get
 abandoned, but with discipline you can keep bringing yourself back to fix all
 the /* FIXME */'s and the compiler errors.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘

--- #19 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 │
╘═════════╧╧════════════════════════════════════════───────────────────────────────────┘

--- #20 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 │
╘═════════╧╧══════════════════════════════════════════════─────────────────────────────┘