Poems similar to: normalize

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

Menu │ Chronological


 -> file: fediverse/292
═══════════════════════════════════════─────────────────────────────────────────────
  normalize majestic tapestries under thicc planes of glass instead of carpet
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════────────────────────────────────┴───────────┘
 -> file: fediverse/328
═══════════════════════════════════════─────────────────────────────────────────────
  normalize glowsticks in unorthodox situations
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════────────────────────────────────┴───────────┘
 -> file: fediverse/312
═══════════════════════════════════════─────────────────────────────────────────────
  normalize playing one game while listening to the soundtrack of another
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════────────────────────────────────┴───────────┘
 -> file: fediverse/39
═════════════════════════════════───────────────────────────────────────────────────
  @user-36 That makes sense to me. I'll have to think about how to generalize
  that, hmmmm... It would only work for numbers that have even square roots right?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════──────────────────────────────────────┴───────────┘
 -> file: fediverse/1452
═══════════════════════════════════════════─────────────────────────────────────────
  normalize deciding, as a group, who to follow
┌─────────┐                                                            ┌───────────┐
│ 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/451
════════════════════════════════════════────────────────────────────────────────────
  normalize hardware based volume controls on your speakers so that your computer
  can't be hacked to play incredibly loud annoying anime music while you're not
  home
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> file: fediverse_boost/451
◀═╦════════════════════════════[BOOST]═════════════════════════════──────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ Take away the elements in order of apparent non-importance               │ │
  ║ │                                                                          │ │
  ║ │  #ObliqueStrategies                                                      │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ similar │                     chronological                      │ different │
  ╚═════════╧══════════════════════════════════════════════════════──┴───────────┴─▶
 -> file: fediverse/3750
═══════════════════════════════════════════════════─────────────────────────────────
  @user-1218

  so true d=(T.T)z
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/1283
═══════════════════════════════════════════─────────────────────────────────────────
  @user-203

  best shape for a state to be ^_^
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: fediverse/6244
═════════════════════════════════════════════════════════════════════───────────────
  numbers are one-dimensional numbers and vectors are multi-dimensional numbers,
  fight me
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════════──┴───────────┘
 -> file: messages/1545
══════════════════════════════════════════════════════════════════════════════──────
  1 is just (number-waves equation for 1)
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧══════─────┘
 -> file: fediverse/38
═════════════════════════════════───────────────────────────────────────────────────
  @user-36 ideally you'd convert to an arbitrary base (in this case 9) and shift
  from there, but shifting two places might work. idk I haven't thought about it.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════──────────────────────────────────────┴───────────┘
 -> file: fediverse/6348
═════════════════════════════════════════════════════════════════════───────────────
  here's a neat function
computer code
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════════──┴───────────┘
 -> file: messages/258
═══════════════════════════════════════════─────────────────────────────────────────
  Give different regions different starting cosmetics @legiontd
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: fediverse/46
═════════════════════════════════───────────────────────────────────────────────────
  @user-36 neat thanks

  when I said 1-1 = 1/10 I meant 1/1 in decimal except the denominator is in base
  1 meaning it's represented as 10 (since 10 in base 1 equals 1 in base 10. Or
  pretty much any other base.)

  I'm trying to figure out why 00 is undefined. There's a lot of math notation in
  that wikipedia article and I'm working through it bit by bit... I feel like
  there's a bug in the code of the universe and I'm trying to understand it.
  Like... why is dividing by zero undefined? That seems like a bug to me.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════──────────────────────────────────────┴───────────┘
 -> file: messages/1094
══════════════════════════════════════════════════════════════════════──────────────
  record the angle of each of my joints when I'm dancing and use that as
  initialized training data for an allm or machine learning task
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════════════════════─┴───────────┘
 -> file: fediverse/37
═════════════════════════════════───────────────────────────────────────────────────
  This would normally just be a weird way to divide except it allows you to
  divide by zero, which is kinda cool.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════──────────────────────────────────────┴───────────┘
 -> file: fediverse_boost/298
◀═╦════════════════════════[BOOST]══════════════════════════─────────────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ Define an area as 'safe' and use it as an anchor                         │ │
  ║ │                                                                          │ │
  ║ │  #ObliqueStrategies                                                      │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ similar │                     chronological                      │ different │
  ╚═════════╧═══════════════════════════════════════════════─────────┴───────────┴─▶
 -> file: fediverse/1224
═══════════════════════════════════════════─────────────────────────────────────────
  @user-883

  sure that would help! I've used it to convert video files to a smaller size for
  uploading to websites, but that's about it
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: fediverse/950
══════════════════════════════════════════──────────────────────────────────────────
  @user-192

  multidimensional arrays aren't too hard, it gets a bit more complicated when
  you need multidimensional *slices*, but once you get your head around it it
  comes easier.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: fediverse/30
════════════════════════════════────────────────────────────────────────────────────
  @user-33 sup
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════───────────────────────────────────────┴───────────┘
 -> file: fediverse/2606
════════════════════════════════════════════════────────────────────────────────────
  ┌───────────────────────────────────────────────────┐
  │ CW: re: politics-fascism-sexual-assault-mentioned │
  └───────────────────────────────────────────────────┘


  @user-249

  sup
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/573
═════════════════════════════════════════───────────────────────────────────────────
  already spotted a bug. Should be for(1000 / MAX times) in the last example.

  EDIT: Or, even better, increment that loop by +MAX instead of +1 each time
  through.
┌─────────┐                                                            ┌───────────┐
│ 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/45
═════════════════════════════════───────────────────────────────────────────────────
  @user-36 Question - how do you do those cool superscript and subscript
  notations?

  Also: I don't think base 1 falls apart with negative exponents, for example
  consider 1^-1 ----- it would evaluate to 1/10 in this system, which is not 1/1.
  Another example, 1^-3 would evaluate to 1/1110, which seems accurate to me.

  As for 0^0, I guess I think it does equal 1? Bear with me:

  for any number n raised to an exponent e, you can write it like this:

  1 * n * n * n ... with as many "* n"s as you have n's. for example:

  1 * 3 * 3 * 3 = 9
  or
  1 * 5 * 5 * 5 * 5 * 5 = 625

  in each case there's 3 or 5 instances of "* n" tacked onto the end. I don't
  know the math notation for that.

  now, when you raise something to the power of zero, it looks like this:

  1

  because there's zero "* n"s added to the end.

  For negative exponents of course you divide instead of multiply, which is why
  it ends up looking like a fraction.

  So, it makes sense to me that 0 ^ 0 would equal 1, because it'd look like this:

  1

  while 0^1 would be

  1 * 0
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════──────────────────────────────────────┴───────────┘
 -> file: fediverse/438
════════════════════════════════════════────────────────────────────────────────────
  consider: the shape of a sine wave
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> file: fediverse/583
═════════════════════════════════════════───────────────────────────────────────────
  I love how the gnu C documentation lists this particular page as number 6.66
An excerpt from the GNU C documentation. The page describes how to use binary constants in C code using a prefix of '0b', essentially instead of using the integer 42 you might write '0b101010'  This particular page is from chapter 6, page 66. The joke, of course, is that using binary numbers in C code in this way is demonic in some way (traditionally the number 666 is regarded as the "devil's number")
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘
 -> file: fediverse/36
═════════════════════════════════───────────────────────────────────────────────────
  consider:

  x = 13 / 3, what is x?

  step 1: translate 13 into base 3
  step 2: digit shift once to the right
  step 3: store underflow as remainder
  step 3: translate back to base 10

  x is 4 remainder 1
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════──────────────────────────────────────┴───────────┘
 -> file: fediverse/5168
════════════════════════════════════════════════════════════────────────────────────
  this is one of the first scripts I wrote

  I can't believe I put the --no-ls AFTER the argument, ha, what a noob.

  ah well if it works it works and I can't refactor now because I built it into
  random scripts and I'd be fixing errors all the time.
script 1:  #!/bin/bash  # sort by filetype would be nice  alias cd="cd-improved"  function cd-improved(){      if [ "${1}" = "..." ] ; then         builtin cd .. && builtin cd ..     elif [ "${1}" = "...." ] ; then         builtin cd .. && builtin cd .. && builtin cd ..     elif [ "${1}" = "....." ] ; then         builtin cd .. && builtin cd .. && builtin cd .. && builtin cd ..          elif [ -d "./${1}" ] ; then         local target_dir="./${1}"      elif [ "${1}" = "cdir" ] ; then         local target_dir="$(tail -n 1 '/home/ritz/scripts/.cdir-target')"         echo ${target_dir}       else         local target_dir="${1}"     fi      if [ ! "${2}" = '--no-ls' ] ; then         builtin cd "${target_dir}" && ls -v --color=auto     else         builtin cd "${target_dir}"     fi          # if the qcd function is defined     if declare qcd > /dev/null; then         quick_cd -d DEFAULT         quick_cd -a DEFAULT     fi }    script 2:  #!/bin/bash  function cdir(){        if [ "$#" -eq 0 ]; then       pwd | cat >> ~/scripts/.cdir-target    elif [ "${1}" == "-l" ]; then       cat ~/scripts/.cdir-target    fi      }
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════───────────┴───────────┘
 -> file: fediverse_boost/319
◀═╦═════════════════════════[BOOST]══════════════════════════────────────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ Change nothing and continue with immaculate consistency                  │ │
  ║ │                                                                          │ │
  ║ │  #ObliqueStrategies                                                      │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ 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/1353
╔══════════════════════════════════════════────────────────────────────────────────┐
║ ┌───────────────────────────────────────────────────────┐                        │
║ │ CW: generic-content-warning-something-related-to-math │                        │
║ └───────────────────────────────────────────────────────┘                        │
║                                                                                  │
║                                                                                  │
║ warning, possible psycherwaul on the horizon.                                    │
║                                                                                  │
║ ========= stack overflow =========                                               │
║                                                                                  │
║ the straight lines are the tangent lines to the curves in a higher dimension.    │
║ if you have a way to calculate backwards from this type of tangent line to the   │
║ values of the equation, you can theoretically calculate any prime number. with   │
║ a simple equation.                                                               │
║                                                                                  │
║ well, I say simple, but that's only because I haven't written it yet. I can't    │
║ even pass calc 1. I'm too generalized I can't complete any task, only apply      │
║ myself to strange ones. Hence why capitalism optimizes away from me, and toward  │
║ people who can get degrees. T.T                                                  │
║                                                                                  │
║ https://www.desmos.com/calculator/mt6hasfcvm                                     │
║                                                                                  │
║ "what the heck that's a lot of traffic going to this one website, what's up      │
║ with that? hmmm interesting we need a                                            │
║                                                                                  │
║ ================= stack overflow =                                               │
║                                                                                  │
║ "dark physics" wild, what a coincidence what a flurry, weird how it all feels    │
║ so happenstance                                                                  │
║                                                                                  │
║ interesting that there'd be a theory, a coincidence and a [mirri? strange]       │
║                                                                                  │
║ well, it's probably n                                                            │
mathematical graph showing several results plotted on a two dimensional field/plain.  there are two types of patterns shown to be occurring with a simple algorithm (pattern for application of numbers toward a pre-defined desired result [approach])  see second picture for equations  the first type of equation is a series of straight lines angled out from a central radial point. They create a cone outward from the origin with gaps between them with increasing density as approaching the floor.  the second type is a smooth arcing projection, like the rippling radiations of the gravity waves of a planet as it courses through space, or perhaps the bending and weaving of a river as it traverses first this way then that.  alternatively, they show a cross-section of a 3 dimensional bundle of fabric folded over itself with a certain rotational pattern that it moves. like the mouth of a clam, except pointed outward rather than in one direction (away from the pearl (or black hole) of the clam  it's quite possible that nothing really happened on the moon before man. Perhaps it's just a rock floating in orbit. Or perhaps it deserves our respect and our trust, our honest comportment.  ... this isn't about the moon, though.  right so this graph is a description of why we need two dimensional numbers. We technically already have them too, some people call them "imaginary" numbers or "lateral" numbers but they're there, they make sense. Why not more? It's just a construct, nothing more.  okay. ah nuts well anyway here's the equations:  y equals x divided by one point five y equals x divided by three point five y equals x divided by five point five y equals x divived by seven point five y equals nine divided by seven point five y equals eleven divided by point five  (you should be able to notice the pattern by now)  the second type of equation is this:  y equals x where x is greater than two, according to this equation: negative sign multiplied by pie times x divided by two multiplied by two  and then a copy of that previous equation, except with 3 instead of 2, then 5, then 7, then 11, then 13, etc. a self propagating algorithm.  ... anyway it's designed to show where the next prime number is. if you look at the graph every number is hit by the algorithm *except* the prime numbers. which is a new one is started.  so, the beginning of the equations begin with 2, because 1 is the first prime number. it's the first number there ever can be, of course it's prime.  next we start a line with two. the next number. the one that comes after the first. it starts a new equation, something rhythmic and predictable, which I've decided to be negative sign of pie x over two. then I multiply that whole thing by two, because it makes the image look cooler.  also by the way, regular sign instead of negative sign also works. so does anything cyclical and rhythmic with these types of behaviors, like cosign or whatever.  oh yeah, tangent lines should travel through an arc on the curve,
╠═════════╗                                                            ┌───────────┤
║ 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/3324
══════════════════════════════════════════════════──────────────────────────────────
  @user-246

  If I follow correctly, the reason it's not is because you're dividing zero by
  two? meaning the magnitude of infinity would be zero.

  ... chat, is infinity just... zero, viewed from a different perspective?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/315
═══════════════════════════════════════─────────────────────────────────────────────
  normalize building games with a built-in virtual machine that plays all
  previous versions of the game for free
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════────────────────────────────────┴───────────┘
 -> file: fediverse/3748
═══════════════════════════════════════════════════─────────────────────────────────
  @user-203

  I've been trying to get it to work with raylib but I'm having difficulties with
  the C interoperability T.T

  https://www.raylib.com
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/276
═══════════════════════════════════════─────────────────────────────────────────────
  ┌──────────────────────┐
  │ CW: mathematics      │
  └──────────────────────┘


  why the heck would -11/2 be defined but 1/0 not be? seems kinda sus to me.
  maybe it's just... not reducible, the same way that 5+i isn't?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════────────────────────────────────┴───────────┘
 -> file: fediverse/346
════════════════════════════════════════────────────────────────────────────────────
  @user-246 or is it 010010 which == 18 in binary?
┌─────────┐                                                            ┌───────────┐
│ 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/582
═════════════════════════════════════════───────────────────────────────────────────
  @user-431

  I made an alias that overwrites cd so I don't have to do this. The important
  line is line 27, you could probably accomplish something similar like this:

  alias cd="cd ${1} && ls -v --color=auto"

  I also set it up so I can change more than one directory up using ... or ....
  or .....

  also I have a few shortcut scripts, cdir and qcd. cdir creates a quick way to
  drop a bookmark wherever I'd like, while qcd can make permanent bookmarks. Also
  qcd makes it so whenever I open a new terminal it opens to the last directory I
  was in, which is nice if you need a new terminal to do something in the current
  folder and you don't want to have to walk alllllllll the way back.
A BASH script that overwrites the built in "change directory" command to auto magically list the contents of the directory you've moved into after moving.  here's the content of the script:  #!/bin/bash  alias cd="cd-improved"  function cd-improved(){      if [ "${1}" = "..." ] ; then         builtin cd .. && builtin cd ..     elif [ "${1}" = "...." ] ; then         builtin cd .. && builtin cd .. && builtin cd ..     elif [ "${1}" = "....." ] ; then         builtin cd .. && builtin cd .. && builtin cd .. && builtin cd ..          elif [ -d "./${1}" ] ; then         local target_dir="./${1}"      elif [ "${1}" = "cdir" ] ; then         local target_dir="$(tail -n 1 '/home/ritz/scripts/.cdir-target')"         echo ${target_dir}       else         local target_dir="${1}"     fi      if [ ! "${2}" = '--no-ls' ] ; then         builtin cd "${target_dir}" && ls -v --color=auto     else         builtin cd "${target_dir}"     fi          # if the qcd function is defined     if declare qcd > /dev/null; then         quick_cd -d DEFAULT         quick_cd -a DEFAULT     fi }
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘
 -> file: fediverse/40
═════════════════════════════════───────────────────────────────────────────────────
  @user-36 so what you're saying is I need to come up with an easier way to
  change bases? Or at least a way to digit shift in a different base than what
  you currently have. Sounds complicated.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════──────────────────────────────────────┴───────────┘
 -> file: fediverse/3559
══════════════════════════════════════════════════──────────────────────────────────
  @user-1209

  like... var = x?? that doesn't make sense. Or like, 5 = var x? that feels
  *wrong*

  in programming = is assignment, not equality, which tripped me up for a bit.
  But if you read it left to right it's like X equals 5. Got it, now I know that
  X is the same as 5. Right?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/1869
═══════════════════════════════════════════════─────────────────────────────────────
  oh dear, Mastodon formatting makes that script look weird. Here's the script in
  picture form so you can reference and fix it:

  I would edit the original post with backslashes and such but I'm exactly out of
  characters teehee
a screenshot of some BASH code
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: fediverse/44
═════════════════════════════════───────────────────────────────────────────────────
  @user-36 So, you're saying the tally system doesn't make sense, and instead
  what I suggested for base zero is instead base 1?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════──────────────────────────────────────┴───────────┘
 -> file: fediverse/3787
═══════════════════════════════════════════════════─────────────────────────────────
  arithmatic control flow

  If A, then B. Else C
a picture of a programmatic implementation of arithmatic control flow
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/4904
═════════════════════════════════════════════════════════───────────────────────────
  @user-1751

  proportion ally, there are more.
┌─────────┐                                                            ┌───────────┐
│ 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: fediverse/1359
═══════════════════════════════════════════─────────────────────────────────────────
  normalize making a new account when you forget your password instead of
  changing it because once changed there's no way to verify the authenticity of
  the user aside from trusting an outside source like an email provider which by
  the way is basically skywriting
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: fediverse/5217
═════════════════════════════════════════════════════════════───────────────────────
  a float is a number between 0 and 1 like 0.5

  they don't store the exact valyue, they just guesstimate

  for some reason computers are designed such that 100% is represented as
  `1.175494351 E - 38: 3.402823466 E + 38` ->source/microsoft/learn/"cpp
  (lol)"/type-float

  ... which is weird because, that's such an arcanely obscure number, who's gonna
  remember that? meaning you gotta go to their website everytime, called
  google.com, and search through microsoft for the answer to life's common
  mysteries.

  emphasis on common

  so yeah you gotta write a conversion library which turns every single instance
  of e to the whatever into a 100 and all the other numbers get converted too.
  but you gotta do it without doing any hardware division, because that one's too
  expensive. it's gotta be a true natural doubling representative, except,
  without doubling the hard-drive space, leading to a distribution of only one
  half of the results of the metghoid. [[ type ohhhhhhs ab ound] ]

  I swear I'm not an LLM I just think embiggeningly
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════──────────┴───────────┘
 -> file: fediverse_boost/296
◀═╦════════════════════════[BOOST]══════════════════════════─────────────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ External post: https://zoner.work/notes/a8bxy364hl860ccx                 │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ similar │                     chronological                      │ different │
  ╚═════════╧═══════════════════════════════════════════════─────────┴───────────┴─▶
 -> file: fediverse/2738
═════════════════════════════════════════════════───────────────────────────────────
  @user-1340

  BTM - it's like TOP, but... bottom

  https://github.com/ClementTsang/bottom
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/445
════════════════════════════════════════────────────────────────────────────────────
  @user-339

  I'd be interested in an analysis which expressed the percentage of time each of
  these individual items correspond to... each tool we create may reduce the
  effort required to perform a particular task, but said task might be valuable
  not necessarily for it's output but rather for the knowledge we gained by
  solving the problem.

  normalize solving problems that have already been solved because you want to
  learn how they work. normalize expressing the lessons you've learned in a
  summarized way that others may digest. normalize trancending the limitations of
  our forms and expanding beyond the capabilities of our humanity.

  for what is the purpose of life if not to grow?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> file: fediverse/2886
═════════════════════════════════════════════════───────────────────────────────────
  @user-1209

  display scaling accomplishes a similar goal through a different mechanism. You
  might find that the visuals are sharper, however you will need to configure
  every program to use this functionality (if it's present, which it's not in
  most programs) - for OS level things this is usually a good option.

  Changing the resolution will change the size of ALL visuals on your computer,
  but they might be fuzzier (but if you're blind as a bat, why would you care
  about fuzziness? It's all fuzzy!)

  increasing the font size can also make it easier to read, which both of these
  options are doing in a sorta round-about way.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/296
═══════════════════════════════════════─────────────────────────────────────────────
  ┌──────────────────────┐
  │ CW: re: mathematics  │
  └──────────────────────┘


  @user-211 I drew this picture recently and I don't really get it anymore but I
  think it's about placing your perspective at the origin and viewing every
  direction as a different dimension?

  side note, but if zero has a positive and negative side, do you think infinity
  has a positive and negative side as well?
math diagram explaining an argument for the viewing of 3d math dimensions from a particular perspective, like "front" or "back" or "north" or "south" or "forward" or "backward" etc  also complaining about the image editing program I was using  root negative one over one equals zero  could go in any direction, tbh  the numbers closest to zero are the most useful. they're just an abstraction we build upon the world. thank you, sh  then some absolute nonsense that I can't even read at this scale and I can't be bothered to zoom in on because I suck and am lazy and am focused on other things.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════────────────────────────────────┴───────────┘
 -> file: fediverse/2084
════════════════════════════════════════════════────────────────────────────────────
  I love it when words align like this
picture of some source code which is aligned in an aesthetically pleasing way, like when every fork in the drawer is nestled together or a pile of folded clothes are placed on-top of one another rather than being a jumbled mess
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/6439
══════════════════════════════════════════════════════════════════════──────────────
  large mountain ranges look exactly the same as small mountain ranges when
  viewed at a distance instead of on a map. don't fall in
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════════════════════─┴───────────┘
 -> file: fediverse/1072
══════════════════════════════════════════──────────────────────────────────────────
  @user-782 @user-783

  modern problems require blunt solutions
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: 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"
a processor temperature gauge. I kinda wish it showed a colored progress bar that showed the relative height from average room temperature all the way up to "almost unbearable" but instead all it has is the digit temperatures.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════────────┴───────────┘
 -> file: messages/278
════════════════════════════════════════════────────────────────────────────────────
  "if we make this part of the program a compressed binary instead of plain text
  we could save on network costs by 5%"

  NO bad software developer, go back to Linux
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════───────────────────────────┴───────────┘
 -> file: fediverse/3326
══════════════════════════════════════════════════──────────────────────────────────
  @user-246

  It's interesting to me that we can divide by infinity, but not zero. I feel
  like it's true that dividing by zero would equal infinity (or maybe zero too
  lol) but I don't know how to prove it T.T
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/3737
═══════════════════════════════════════════════════─────────────────────────────────
  Nix the complexity.
┌─────────┐                                                            ┌───────────┐
│ 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/1510
════════════════════════════════════════════────────────────────────────────────────
  number of tabs open: 15 thousand

  number of tabs in regular use: 5

  EDIT: average distance between tabs: 15
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════───────────────────────────┴───────────┘