Poems similar to: version

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

Menu │ Chronological


 -> file: bluesky/30
═══════════════════════════════════════════════════════════════════════─────────────
  box castle version 8.62
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════┴───────────┘
 -> file: fediverse/278
═══════════════════════════════════════─────────────────────────────────────────────
  version 0 from scratch
  version 1 when complete
  version 2 when rewritten
  version 3 when overhauled
  version 3.5 when investors aren't satisfied
  version 5 when redefined
  version X when misapplied
  version Y when redefined
  version 10 to be happy
  and version 11 when re-engineered.
┌─────────┐                                                            ┌───────────┐
│ 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: fediverse_boost/334
◀═╦═════════════════════════[BOOST]══════════════════════════────────────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ compiler errors per revolution                                           │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ 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/2865
═════════════════════════════════════════════════───────────────────────────────────
  omgggggg just let me play the game, package manager T.T
a bunch of terminal output text for building kernel modules quite redundantly
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/1960
════════════════════════════════════════════════────────────────────────────────────
  Source code is like, the worst way to view code, but I can't think of anything
  better, so whatever
┌─────────┐                                                            ┌───────────┐
│ 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/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: fediverse/1691
═══════════════════════════════════════════════─────────────────────────────────────
  "I don't know what I was doing with this line of code so I'm going to delete it
  and fix it later"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: fediverse/653
═════════════════════════════════════════───────────────────────────────────────────
  there's a difference between *designing software* and *using software*. Some
  things can be made, and then saved for another day when their implementations
  may be accomplished more ethically. It's okay to say "let's leave this as
  'okay' and work on the next thing we've chosen."

  Check out this piece of C code I wrote last night:

  it doesn't compile, it's not finished, but I wrote it as-is

  [pretend like it was called "main.c" instead of "main.txt" - had to change it
  because mastodon thinks it's an invalid file]

  [actually .txt didn't work, try .png]

  [hmmm it realized it wasn't a valid png file, okay try screenshotting the code,
  there's only 300 lines]

  [sure glad there's only 300 lines]

  [too bad it won't let you send .zip]

  [won't let me name it main.png, presumably because they already have a
  failed-verified version on their machine. will rename to main-src.png instead]
sorry, when I pasted the source code in it was negative fourteen thousand, six hundred and thirty one characters. Phew that's too many.  basically it's a C source code file with a lot of comments left in... odd locations. They details ideas the author has had about the tech industry and all of creation, and with it a song is woven of truth and liberation. We'll see where life brings us, but we know it's just ours for a moment, so let's carry forth on our own torms [terms, but pronounced as "dorms" for some reason?]
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘
 -> file: 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
An installation script for the Chapel programming language.  I don't imagine it'd be very useful to hear the program read out-loud, but if it would be interesting to hear, then feel free to ask.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: notes/most-difficult-for-an-mortal
═════════════════════════════════════════════════════════════════════════════════───
  To choose to follow the command "stay history"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧═════════──┘
 -> file: fediverse/5590
═══════════════════════════════════════════════════════════════─────────────────────
  vibe coding is just writing comments in increasing detail until the generated
  code matches what you need.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════────────┴───────────┘
 -> file: fediverse/5034
════════════════════════════════════════════════════════════────────────────────────
  github is overrated.

  git is underrated.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════───────────┴───────────┘
 -> file: fediverse/5936
═══════════════════════════════════════════════════════════════════─────────────────
  updated version
 High Prevalence Themes (>10%) - resistance (35%): Dominates political content across all analyses - technology (30%): Consistent technical discussions and digital culture - isolation (25%): Pervasive loneliness despite digital connection - identity (20%): Strong focus on neurodivergence and gender fluidity - systems (18%): Systematic thinking about organization and infrastructure - connection (15%): Yearning for authentic human bonds - chaos (12%): Stream-of-consciousness fragmentation throughout - digital-resistance (12%): Technical activism and crypto-anarchism  Medium Prevalence Themes (5-10%) - transcendence (10%): Mystical elements and spiritual seeking - digital-loneliness (10%): Online isolation paradox - economic-anxiety (9%): Financial stress and capitalism critique - survival (8%): Basic needs and resource management - neurodivergence (8%): Autism, ADHD, masking behaviors - direct-action (8%): Street-level political organizing - programming-philosophy (7%): Deep thoughts on coding craft - gender-fluidity (7%): Trans experience and identity exploration  Low Prevalence Themes (<5%) - creativity (5%): Artistic expression and generative art - gaming-culture (6%): Video games as culture and art form - mutual-aid (6%): Community care and resource sharing - fragmented-consciousness (5%): Plurality and multiple selves - technomysticism (4%): Digital spirituality and AI consciousness - environmental-awareness (3%): Nature connection and ecology
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════────┴───────────┘
 -> file: fediverse/6137
════════════════════════════════════════════════════════════════════────────────────
  sometimes, comments need to go on the left side of text. Like for parts of the
  script which should be user-editable, the fields should all be right-aligned to
  the farthest required bit of text. Instead of [picture A] it should be [picture
  B]
an example script written in the bash computer language that has all the variables hidden behind comments on the left. makes it very hard to try new variables. the same picture, but the variables are moved to the right.  now it's easier for the user to update them since they don't have to use their mouse.
┌─────────┐                                                            ┌───────────┐
│ 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/6385
══════════════════════════════════════════════════════════════════════──────────────
  interpreted programs allow you to change variables at run-time from remote.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════════════════════─┴───────────┘
 -> file: fediverse/1277
═══════════════════════════════════════════─────────────────────────────────────────
  @user-913

  If you switch "Application" for "Program" it's still just as bad
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: fediverse/1696
═══════════════════════════════════════════════─────────────────────────────────────
  smartphone_max_battery_life = int_to_percent(100 - update_count);
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: messages/965
═════════════════════════════════════════════════════════════════───────────────────
  paste the error into the text file to better diagnose. Don't put it in a
  comment. It will remind you to clear the bug before compiling.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════──────┴───────────┘
 -> file: fediverse/1934
════════════════════════════════════════════════────────────────────────────────────
  @user-1109

  do it in a random color each time! Here's my implementation for viewing txt
  files colorfully:
some bash computer code which first picks a random color, and if the color is a bad combination (like, black front and black back, meaning you can't see the lines of the letters) then it redoes it and tries to pick a better one randomly. It'll keep trying until it gets a correct combination but honestly there's only like one or two bad ones that don't look so great
┌─────────┐                                                            ┌───────────┐
│ 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: messages/939
════════════════════════════════════════════════════════════════────────────────────
  oh see yeah now it's running on linux
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════════───────┴───────────┘
 -> file: fediverse/2484
╔═══════════════════════════════════════════════───────────────────────────────────┐
║ @user-1271                                                                       │
║                                                                                  │
║ I can help with that.                                                            │
║                                                                                  │
║ I recommend looking at Ollama, which runs an HTTP server on your local machine   │
║ (hope you have a decent graphics card)                                           │
║                                                                                  │
║ then, script some behavior you'd like to implement using Lua and the LuaSockets  │
║ library. Also dkjson to handle the json parts.                                   │
║                                                                                  │
║ then, all you have to do is construct a prompt based on the variables and        │
║ desired input/output and push it into a json packet and send it to the HTTP      │
║ server. It's less complicated than it sounds.                                    │
║                                                                                  │
║ what you want it to do and your implementation for it is the hard part. But      │
║ perhaps this project of mine will get you started:                               │
║                                                                                  │
║ (I can copy-paste it too if you'd like)                                          │
║                                                                                  │
║ just... don't make a chatbot. chatbots are useless to work on because there's    │
║ already so many of them.                                                         │
║                                                                                  │
║ much better I think to use the LLM to process arbitrary information with an      │
║ unpredictable form into more predictable patterns which can be utilized          │
║ programmatically.                                                                │
║                                                                                  │
║ Feel free to ask any questions. Do keep in mind that training LLMs is            │
║ unethical, but using them is whatever.                                           │
some lua code illustrating a VERY simple Ollama generation function.
╠═════════╗                                                            ┌───────────┤
║ similar ║                       chronological                        │ different │
╚═════════╩════════════════════════════════════────────────────────────┴───────────┘
 -> file: fediverse/4259
═════════════════════════════════════════════════════───────────────────────────────
  source code should be like a story

  "here's why we did what we did with our architecture"

  and as it's being written, it may be altered in many different places at once -
  git style.

  parts of it could rhyme,

  if they wanted to show parts that were really difficult but easy to summarize
  because it's mostly just a lot of boring work y'know like writing getters and
  setters and doing the testing pre-deploy environments

  ,,, they could selectionize
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════──────────────────┴───────────┘
 -> file: fediverse/848
══════════════════════════════════════════──────────────────────────────────────────
  ┌──────────────────────┐
  │ CW: gentoo           │
  └──────────────────────┘


  wrote this in an hour, used a local LLM to generate the regexes.

  haven't tested it yet because I'm not on gentoo rn, so don't run it. which is
  why I shared the code as an image.

  if you really want the text of it then check out the visual description of the
  image.
#A script written in bash. It is used to update the Gentoo type system to the most recently written functionality. Should not be used more than once a day, and the program written here must be specifically configured to act against that functionality. However, should the user persist in their attempts to break that rule, they simply have to flip a particular switch.  #!/bin/bash  function gentoo-update(){    RED='\033[0;31m'    NOC='\033[0m'     if [ "$#" -eq 0]; then       date | cat >> ~/scripts/.gentoo-update-target           LAST_UPDATE_DATE="$(tail -n 1 '~/scripts/.gentoo-update-target' \       && echo "${LAST_UPDATE_DATE}"                                      \        | sed -r 's/\b(\d{4}-\d{2}-\d{2})\b/\1/g'                                   THIS_UPDATE_DATE="$(date)"                                      \       && echo "${THIS_UPDATE_DATE}"                                      \        | sed -r 's/\b(\d{4}-\d{2}-\d{2})\b/\1/g'        if [ ${LAST_UPDATE_DATE} = ${THIS_UPDATE_DATE} ]; then          printf "don't sync more than once a day! ${RED}  a witch will curse you >: (${NOC}\n"       else          echo "syncing..."          echo "${LAST_UPDATE_DATE}"             | cat            >> ~/scripts/.gentoo-update-target          emerge --sync       fi     elif [ "${1}" == "-l" ]; then       cat ~/scripts/.gentoo-update-target     elif [ "${1}" == "-f" ]; then       echo "okay but it's your funeral buddy. or worse."       energe --sync     fi  }
┌─────────┐                                                            ┌───────────┐
│ 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: 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: 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/4967
═══════════════════════════════════════════════════════════─────────────────────────
  um I mean:

  There are some pieces of software where you think "oh cool, what did they
  update?" and then there are some like "oh god... What did they update?"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════────────────┴───────────┘
 -> file: fediverse/704
═════════════════════════════════════════───────────────────────────────────────────
  Is my formatting pretty or does it make you angry?
screenshots of C and Lua code that have strange formatting. The style is designed such that the readers eyes "flow" across the code like the gradual descent of water down a sloping riverbed, following a logical progression from top left to bottom right (generally) while returning to the left side whenever a new operation is performed or something is repeated.  This particular picture is of a simple if check:  if a creature's rank is equal to "four" or "two", then the creature is a rare monster type. Otherwise, they are not a rare monster type. Lua code to determine whether or not a character in a video game is available to be ambushed by a randomly generated monster.  There are several checks applied, checking things like "is the character sitting down" or "are they underwater", in which case a message is printed to the log and no further action is taken.  If all of the checks pass, and the character is free to be ambushed, then it runs the "spawnAndAttackPlayer()" function. A long string of "if" statements checking whether individual bits in a very small data structure are set. There's nine of them total, and they are arranged in a grid - this project was for a tic-tac-toe game, where there are nine total squares to play in. Setting up some location variables for a player unit. It starts by setting an X, Y, Z, and O for orientation value to a player's current location. Then it steps through and sets them to more accurate values. The reason for this ordering is so that if the function to find the more accurate value fails, it can fall back on the player's current location instead.  The interesting formatting is due to the layout of the "set" operations - they are ordered in a two dimensional grid rather than a top-to-bottom list like how most people would organize it.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘
 -> file: fediverse/3065
═════════════════════════════════════════════════───────────────────────────────────
  ┌────────────────────────────┐
  │ CW: complaining-about-tech │
  └────────────────────────────┘


  I feel like if I wanted to keep every single one of my games playable I'd have
  to boot them up at least once every 3 months or so.

  That's EXHAUSTING. Linux is supposed to "just work" - so why does everything
  break every time you run an update?

  WHY can't I just... maintain a copy of old software if it's still in use? Or
  like, include all the installation steps that check for dependencies (and
  install them if necessary) into the "launch game" script?

  Backwards compatibility for a single season ago is apparently too much. I've
  written a few scripts for it but you can only do so much when the game files
  aren't on github -.-
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/3301
══════════════════════════════════════════════════──────────────────────────────────
  "this program that used to work doesn't anymore because, uh, your video drivers
  are out of date."

  ... okay but if I didn't update this program either, then why would it matter
  if my video drivers are out of date? wouldn't they be working off of the same
  [rulings/requirements]?

  the "best practice" of updating your software all at once instead of one-by-one
  is a disaster for our humankinds consequences or whatever
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/3774
═══════════════════════════════════════════════════─────────────────────────────────
  don't forget to check the checksum of the checksum generator!
┌─────────┐                                                            ┌───────────┐
│ 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: fediverse/5386
══════════════════════════════════════════════════════════════──────────────────────
  @user-670 @user-1815 @user-1816

  literally nobody has contributed to the one github repo I have

  ever. I got like, one comment from some guy in China or Taiwan. It's been up
  for like, 4 or 5 years and it's on my website. /shrug I guess most people
  bounce off after reading the splash screen /shrug

  to me, a FOSS project feels static because I don't believe in centralization
  and I also don't have the bandwidth or need to work on it. /shrug
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════════════─────────┴───────────┘
 -> file: fediverse/6348
═════════════════════════════════════════════════════════════════════───────────────
  here's a neat function
computer code
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════════──┴───────────┘
 -> file: messages/949
════════════════════════════════════════════════════════════════────────────────────
  like if everyone was a package manager repository
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════════───────┴───────────┘
 -> file: fediverse/2884
═════════════════════════════════════════════════───────────────────────────────────
  ┌──────────────────────┐
  │ CW: tech-paranoia    │
  └──────────────────────┘


  every time I update my system, it breaks.

  kinda makes me think they do that on purpose so that you spend all your time up
  to date and that way they can quickly patch in and out security flaws fast
  enough that nobody notices.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/849
╔═════════════════════════════════════════─────────────────────────────────────────┐
║ wish there were ascii characters that took up more than one line of code         │
║ vertically.                                                                      │
║                                                                                  │
║ wonder if we could use a sorting algorithm, or markup language, or something     │
║ like that to organize less structured data along user-customizable rules. Like,  │
║ a code editor that worked with your ideas, rather than the strict expression of  │
║ your text. You could pretty much write in any language, even pseudocode, and     │
║ the LLM behind the scenes would translate whatever you wrote into whatever       │
║ result you needed. Writing Rust, but need to fit in with C code? No worries      │
║ it'll translate for you. As long as the end result is functionally the same,     │
║ which could be verified by running two separate VMs that ran interpreters every  │
║ time you saved. And as long as their translation layers matched completely,      │
║ then odds are they're the same. And if not, well, the programmer can always      │
║ debug it. It's not like this would be running on something that needed to        │
║ perform in the moment? Like, improv instead of tragedies, or battles instead of  │
║ strategies                                                                       │
Image attachment
╠═════════╗                                                            ┌───────────┤
║ 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/2011
════════════════════════════════════════════════────────────────────────────────────
  @user-883

  nvim is nice because you can make addons or plugins or whatever in Lua, which
  is the easiest language in the world.

  I think VSCode sucks - it's literally a web browser that views your own code,
  and it's made by Microsoft so it probably SENDS it to them too. Probably.

  I like nvim because it's just Vim except you can use more plugins (the ones
  written in Lua)
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: messages/1171
════════════════════════════════════════════════════════════════════════────────────
  build it into the filesystem...
┌─────────┐                                                            ┌───────────┐
│ 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: messages/770
═══════════════════════════════════════════════════════════─────────────────────────
  There are some pieces of software where you think "oh cool, what did they
  update?" and then there are some like "oh god... What did they update?"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════────────────┴───────────┘
 -> file: fediverse/3822
═══════════════════════════════════════════════════─────────────────────────────────
  @user-1582

  I think that's what happened, in addition to... whatever this input/output
  error is. No clue what to do about that. Maybe my SD card is dying, I've
  flashed over it like, 10 times now haha 😅
ls: command not found  /bin/ls -bash: /bin/ls: Input/Output error
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: 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 │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: messages/937
════════════════════════════════════════════════════════════════────────────────────
  wonder if there's a patch or workaround
┌─────────┐                                                            ┌───────────┐
│ 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: messages/676
══════════════════════════════════════════════════════──────────────────────────────
  AI generated documentation from git pushes with comments automatically stripped
  out.

  Leave so many comments! Format them however you want! It doesn't matter because
  they don't need to be human readable. They must simply be readable by the
  machine.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════─────────────────┴───────────┘
 -> file: fediverse/4172
═════════════════════════════════════════════════════───────────────────────────────
  this is what I got so far for a messaging client that uses SSH

  ... so you need someone's public key in order to talk to them
a picture of a notebook page that shows an initial design for a SSH based messaging client
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════──────────────────┴───────────┘
 -> file: fediverse/3214
══════════════════════════════════════════════════──────────────────────────────────
  @user-1484

  Oh, right, I don't use Mac or Windows so I didn't know how they implement it.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: notes/20260913-212428.txt
══════════════════════════════════════════════════════════════════════════════════──
  My similar-different has had a bug in the computer code that makes it all
  shuffled. And it shows the same ~1000 poems over and over. I should fix it.
  I'll fix it tomorrow. Sorry. I've known that its been messed up for like, a
  month, but I didn't fix it because I was shy.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧══════════─┘
 -> file: fediverse/3226
══════════════════════════════════════════════════──────────────────────────────────
  if your man page is longer than a list of options and their usage and a
  paragraph or twenty of how to use the software... then you need to abstract,
  and break your code into multiple purpose-built applications.

  do one thing, and do it right. alternatively, do one set of things, and do them
  concisely.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/1762
═══════════════════════════════════════════════─────────────────────────────────────
  This was the first bash script I ever wrote.

  It's been updated a little, it was a bash alias first, but this is what it
  looks like now.

  Kinda shows what kinds of problems I needed to solve most.
A bash script that plays a random episode of Adventure Time from a terminal.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: fediverse/1773
═══════════════════════════════════════════════─────────────────────────────────────
  ┌─────────────────────────┐
  │ CW: programming-is-easy │
  └─────────────────────────┘


  Need to install a program from Github? Follow these simple steps:

  step 1: make an empty text file

  step 2: put this at the top: #!/bin/bash

  step 3: put this on the next line: set -euo pipefail

  step 4: mkdir -p the directory you want to install it to

  step 5: rm -dr the directory you want to install it to

  step 6: mkdir -p the directory you want to install it to

  step 7: git clone the project

  step 8: this is the hard part - go through each of the steps listed in the
  readme and configure the installation to the needs of your system. Put them in
  the bash script one-by-one.

  step 9: save the file, it doesn't need an extension like .txt or .sh,
  extensions are for windows noobs

  step 10: chmod +x the file and then ./the file!

  step 11: fix it when they change their installation instructions...

  Need a run script? Easy! Write it as a function below your update script, then
  echo the bottom half of the update script into a file named "run" that's placed
  in the project directory.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: messages/971
═════════════════════════════════════════════════════════════════───────────────────
  vimcoders can be vibecoders too. it's just about what language you want to use
  to talk to the computer, right?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════──────┴───────────┘
 -> file: fediverse/5902
═══════════════════════════════════════════════════════════════════─────────────────
  if you want to train debug skills to a computer, just train them on every stage
  of the git commit tree.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════────┴───────────┘
 -> file: fediverse/2862
═════════════════════════════════════════════════───────────────────────────────────
  I don't like package managers...

  [then don't use them]

  oh right 4head
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/1474
═══════════════════════════════════════════─────────────────────────────────────────
  @user-882
Image attachment Image attachment
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: fediverse/1692
═══════════════════════════════════════════════─────────────────────────────────────
  @user-246

  Yeah plus the second time around you're likely to make something better than
  whatever incomprehensible hack you did the first time.

  More time working on the project == more context which means you might even
  have solved the problem twice already and now just have to copy-paste something
  that's more robust than your previous one-liner.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: messages/19
══──────────────────────────────────────────────────────────────────────────────────
  https://www.masteringemacs.org/article/the-emacs-27-edition-of-mastering-emacs-o
  ut-now
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═────────┴────────────────────────────────────────────────────────────┴───────────┘