Poems similar to: simplest

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

Menu │ Chronological


 -> file: fediverse/3737
═══════════════════════════════════════════════════─────────────────────────────────
  Nix the complexity.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/3574
══════════════════════════════════════════════════──────────────────────────────────
  @user-1564

  I love the concept of this! Maybe if HTTP is too complex, you could try another
  simpler server? I don't know the complexity of the programs I use every day,
  but I'm sure there's one that's very simple. Even just a simple IRC style chat
  server that just... sends text from person A to person B depending on their
  username (like a glorified Router or Switch)

  Reminded of this video tbh...:

  https://www.youtube.com/watch?v=gGfTjKwLQxY
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/4291
═════════════════════════════════════════════════════───────────────────────────────
  complex systems can be simple if you think about what they need, and what they
  do.

  it's not perfect, but you're always free to zoom in if needed.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════──────────────────┴───────────┘
 -> file: fediverse/1299
═══════════════════════════════════════════─────────────────────────────────────────
  ┌─────────────────────────────────────┐
  │ CW: re: violence-politics-mentioned │
  └─────────────────────────────────────┘


  @user-928 @user-929 @user-930

  you're absolutely right. Nothing about this is easy.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: fediverse/375
════════════════════════════════════════────────────────────────────────────────────
  premature optimization may be the root of all evil, but like... it's fun? so
  I'm going to keep doing it. And before you ask why I'm using threads on project
  euler problems, just know that it's slightly faster this way I promise.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> file: messages/940
════════════════════════════════════════════════════════════════────────────────────
  *perfect*, we solved computation - just become a computer! easy!
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════════───────┴───────────┘
 -> file: fediverse/3781
═══════════════════════════════════════════════════─────────────────────────────────
  @user-246

  one of those things sounds easier than the other!
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/3980
════════════════════════════════════════════════════────────────────────────────────
  just means that's the most entertaining type of strategy we've found so far
┌─────────┐                                                            ┌───────────┐
│ 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/1072
══════════════════════════════════════════──────────────────────────────────────────
  @user-782 @user-783

  modern problems require blunt solutions
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: fediverse/6348
═════════════════════════════════════════════════════════════════════───────────────
  here's a neat function
computer code
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════════──┴───────────┘
 -> file: fediverse/1283
═══════════════════════════════════════════─────────────────────────────────────────
  @user-203

  best shape for a state to be ^_^
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: fediverse/3750
═══════════════════════════════════════════════════─────────────────────────────────
  @user-1218

  so true d=(T.T)z
┌─────────┐                                                            ┌───────────┐
│ 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/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: messages/1406
═════════════════════════════════════════════════════════════════════════───────────
  fact checking yourself doesn't have to be any harder than this.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧═──────────┘
 -> file: messages/427
═══════════════════════════════════════════════─────────────────────────────────────
  If everyone can do whatever they want, they'll tend to prefer the easy way. And
  the easy way is rarely the right way.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: fediverse/775
═════════════════════════════════════════───────────────────────────────────────────
  @user-192

  It's totally simple! It's just structs, void pointers, function pointers,
  arrays, mallocs, and oh boy I think I see what you mean
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘
 -> file: fediverse/1606
═══════════════════════════════════════════════─────────────────────────────────────
  @user-1037

  That looks pretty neat, thanks : )
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: fediverse/6359
══════════════════════════════════════════════════════════════════════──────────────
  @user-192

  it is rarely more efficient to think through a problem than it is to calculate.

  But, speed isn't everything, so think we do some more.
┌─────────┐                                                            ┌───────────┐
│ 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/335
════════════════════════════════════════────────────────────────────────────────────
  ┌─────────────────────────────────────┐
  │ CW: re: bad no, star-wars-mentioned │
  └─────────────────────────────────────┘


  @user-203 @user-243 oh you can! you just need to array your gates in a logical
  fashion and flip all the 1's to 0's by bit shifting each register to the left
  (or right!) 8 times.

  You'll be good as new! But you may have forgotten how to english, so... yeah,
  but on the bright side you can rewatch Star Wars as if you were 6 years old or
  whatever, so that's something. You'll have the taste of a 6 year old though so
  you'll probably end up liking the sequels. >.>
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> file: fediverse/5514
═══════════════════════════════════════════════════════════════─────────────────────
  this, but with my "ideas" or whatever
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════────────┴───────────┘
 -> file: fediverse/701
═════════════════════════════════════════───────────────────────────────────────────
  ┌──────────────────────┐
  │ CW: computer-code    │
  └──────────────────────┘


  totally useless unless you're, I dunno, building a bytecode interpreter or
  something

  https://craftinginterpreters.com/contents.html
If you only have arithmetical expressions you can use some properties of arithmetic to compute branching computer code. E.G., if A is either zero or one depending on some previously computed condition, then A times B plus (1-A) times C computes the expression "if A then B else C"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘
 -> file: fediverse/1225
═══════════════════════════════════════════─────────────────────────────────────────
  @user-883

  don't worry I can sift through junk. I'll write my own using yours as a
  reference to debug why mine isn't working. "oh probably because I didn't do
  this part here"

  also, bad news. Guess I'm doing C programming. What should I make? I'm thinking
  Tic Tac Toe or maybe a really basic Asteroids or something
┌─────────┐                                                            ┌───────────┐
│ 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/94
══════════════════════════════════════──────────────────────────────────────────────
  @user-107 If you can figure out how to do it well, everything else seems less
  difficult. : )
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════─────────────────────────────────┴───────────┘
 -> file: fediverse/2533
════════════════════════════════════════════════────────────────────────────────────
  ┌──────────────────────┐
  │ CW: food-recipe-idea │
  └──────────────────────┘


  egg drop soup:

  boil some water with boullion.
  drop some eggs in it.
  cook until done.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse_boost/319
◀═╦═════════════════════════[BOOST]══════════════════════════────────────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ Change nothing and continue with immaculate consistency                  │ │
  ║ │                                                                          │ │
  ║ │  #ObliqueStrategies                                                      │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ similar │                     chronological                      │ different │
  ╚═════════╧════════════════════════════════════════════════────────┴───────────┴─▶
 -> file: fediverse/3453
══════════════════════════════════════════════════──────────────────────────────────
  my favorite thing about strategy is how it can be abstracted!
┌─────────┐                                                            ┌───────────┐
│ 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/4084
═════════════════════════════════════════════════════───────────────────────────────
  ┌──────────────────────┐
  │ CW: re: -mentioned   │
  └──────────────────────┘


  @user-1074

  the more you try, the more you have to calculate, which is a problem, because
  endlessly recursive calculations create infinite loops, which frankly are
  impossible to compute because they defy computation! Not good, not ideal, no
  thank you, not for me, no thanks, not what I'd like.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════──────────────────┴───────────┘
 -> file: messages/387
══════════════════════════════════════════════──────────────────────────────────────
  Strategy in a nutshell:

  identify your resources, identify your goal, and identify any problems
  preventing you from reaching your goal.

  Then, develop a plan to apply your resources to solve or bypass problems in
  order to reach your goal. Easy.
┌─────────┐                                                            ┌───────────┐
│ 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/302
═══════════════════════════════════════─────────────────────────────────────────────
  ┌──────────────────────┐
  │ CW: re: mathematics  │
  └──────────────────────┘


  @user-211 math such as SUM(as x approaches infinity)(i*x)

  this would add i, 2i, 3i, 4i, 5i, 6i, etc off into infinity. would that give
  you complex infinity? a direction orthogonal to the X axis, yet infinitely far
  in the direction of y. it'd probably have a positive and negative side too,
  just saying.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════────────────────────────────────┴───────────┘
 -> file: fediverse/3680
══════════════════════════════════════════════════──────────────────────────────────
  it's probably a good idea to write pseudocode, then real code, instead of
  starting with real code, and bugfixing something incomplete and more difficult
  to reason with.

  unless you write real code easier than pseudocode. idk do what works for you.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/4511
══════════════════════════════════════════════════════──────────────────────────────
  ┌───────────────────────────┐
  │ CW: food-recipe-requested │
  └───────────────────────────┘


  does anyone know of a recipe that uses only flour, butter, yeast, eggs, and
  salt? It doesn't need to use every ingredient, but those are easy to acquire.

  ideally with the ability to include nuts or dried fruit or something else
  nutritious.

  the requirements include the ability to cook it using only a rice-cooker (or
  crock pot, or other kind of slow-cooking ceramic dish which heats from all
  directions at once)

  in addition, it must NOT need kneading. It must be able to be cooked passively
  without attention. The fewer steps, the better.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════─────────────────┴───────────┘
 -> file: messages/1053
════════════════════════════════════════════════════════════════════────────────────
  Anyway here's what i came to say:
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════════════───┴───────────┘
 -> file: messages/711
════════════════════════════════════════════════════════────────────────────────────
  https://www.desmos.com/calculator/cxayticajg
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════───────────────┴───────────┘
 -> file: fediverse/428
════════════════════════════════════════────────────────────────────────────────────
  no thing is ineffable.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> file: fediverse/307
═══════════════════════════════════════─────────────────────────────────────────────
  normalize building a library that's just a wrapper around solutions you've made
  to common problems from the past that can be imported into every project you
  work on
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════────────────────────────────────┴───────────┘
 -> file: messages/966
═════════════════════════════════════════════════════════════════───────────────────
  boom, easy error-handling
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════──────┴───────────┘
 -> file: fediverse/252
═══════════════════════════════════════─────────────────────────────────────────────
  I'm convinced that the best and most simple advances in technology comes from
  accurately graphing your system and saying "well why don't we just..."
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════────────────────────────────────┴───────────┘
 -> file: fediverse/3338
══════════════════════════════════════════════════──────────────────────────────────
  @user-246

  I tend to stack overflow a lot T.T
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: notes/20260730-184108.txt
════════════════════════════════════════════════════════════════════════════════────
  No deterministic system can solve arbitrary problems with perfect solutions.

  Hence, subjectivity.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧════════───┘
 -> file: fediverse/3820
═══════════════════════════════════════════════════─────────────────────────────────
  @user-1597

  Oh! Good thinking! Thank you! ^_^
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/4884
═════════════════════════════════════════════════════════───────────────────────────
  "okay but what if we made computers simple?"

  - someone who doesn't know how computers work
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════──────────────┴───────────┘
 -> file: messages/1499
══════════════════════════════════════════════════════════════════════════──────────
  The true answer lies somewhere inbetween.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧══─────────┘
 -> file: notes/magics-are-rare
════════════════════════════════════════════════════════════════════════════════────
  magician only work magic when forced to. This is because magic is rare.
  It's difficult to create, but if mastered, can have infinity to share.\
  \
  to solve all of entropy and scarcity,
  find a way to use infinity.
  if you can draw from forever,
  if you can wield all of ever,
  if
  then you can make as much as you can grasp.
  immortality tells me there's just a bit more of ever,
  and I trust myself to know infinite things. whenever I reach for more, there
  are more things to know. I am very good at abstraction, says soramech, because
  I can always know connections between types of sets.

  recursively and ever choosing to be choosing, [stack overflow]
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧════════───┘
 -> file: fediverse/1625
═══════════════════════════════════════════════─────────────────────────────────────
  ┌──────────────────────┐
  │ CW: mathematics      │
  └──────────────────────┘


  EDIT: Ooops, sorry, should have content warning'd this post

  two incredibly useful tools I found for boolean logic in mathematics:

  | f(x) | / | f(x) |

  or more visually:
  | f(x) |
  ---------
  | f(x) |

  this will return a 1 if f(x) evaluates to a non-zero value, and 0 if f(x)
  evaluates to zero. Pretend there's an infinitesimal at the bottom if you're one
  of those weirdos who think dividing by zero doesn't equal zero...

  the other tool is this:

  ( A * B ) + ( (1 - A) * C )

  or more visually:

  ( (0 + A) * B)
  + (1 - A) * C)

  This will evaluate to B if A is 1, and C if A is 0, essentially creating an "if
  true" check. Note that it doesn't work if A is neither zero nor one, but that's
  what the first tool's for.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: fediverse/128
══════════════════════════════════════──────────────────────────────────────────────
  @user-95 I'm not sure, but I once tried to design an algorithm that predicted
  prime numbers. I made this algorithm in my pursuit, but I couldn't figure out
  how to utilize it:

  https://www.desmos.com/calculator/h8oopoctnh
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════─────────────────────────────────┴───────────┘
 -> file: fediverse/2467
════════════════════════════════════════════════────────────────────────────────────
  @user-999

  how brilliantly succinct
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/30
════════════════════════════════────────────────────────────────────────────────────
  @user-33 sup
┌─────────┐                                                            ┌───────────┐
│ 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/2606
════════════════════════════════════════════════────────────────────────────────────
  ┌───────────────────────────────────────────────────┐
  │ CW: re: politics-fascism-sexual-assault-mentioned │
  └───────────────────────────────────────────────────┘


  @user-249

  sup
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: notes/programming-style
═══════════════════════════════════════════════════════════════════════─────────────
  my programming is not a product., it is a way of thinking.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════┴───────────┘
 -> file: notes/read-later
══════════════──────────────────────────────────────────────────────────────────────
  https://www.redblobgames.com/grids/hexagons/#basics
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══─────────────────────────────────────────────────────────┴───────────┘
 -> file: fediverse/2003
════════════════════════════════════════════════────────────────────────────────────
  The most important programming language to master is pseudocode.

  With a firm grasp of pseudocode in your toolbox, you can solve any problem in
  any language.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/6341
═════════════════════════════════════════════════════════════════════───────────────
  if you want to win, play suboptimally without danger of losing.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════════──┴───────────┘
 -> file: fediverse/3800
═══════════════════════════════════════════════════─────────────────────────────────
  @user-1352

  You're absolutely right, the compiler knows better than me! Certainly the
  compiler doesn't know *best*, but certainly the compiler knows *better than me*.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/3274
══════════════════════════════════════════════════──────────────────────────────────
  "I can't remember that function, it does too few things"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: messages/1279
═════════════════════════════════════════════════════════════════════════───────────
  based on the nature of interaction.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧═──────────┘
 -> file: fediverse/5233
═════════════════════════════════════════════════════════════───────────────────────
  @user-1086

  ... good idea...!
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════──────────┴───────────┘
 -> file: fediverse/2730
═════════════════════════════════════════════════───────────────────────────────────
  80% of the complexity in modern computing is from the graphics stack.

  the other 20% is from networks.

  the last 40% is in avoiding race conditions with multithreading.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘