Poems similar to: inefficient

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

Menu │ Chronological


 -> 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/2058
════════════════════════════════════════════════────────────────────────────────────
  @user-1071 I have the opposite problem, where my ideas come too quickly and
  they're gone before I can implement. I think I'd prefer to burn out TBH because
  burning out just means an inexcusable output of energy (in return for
  not-enough-learning)
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: notes/1234-sort-me
═══════════════════════════════════════════════════════════════════════════════─────
  inefficiency is design.
                  design can have inefficient parts.
                  design is worth more useitude than just performance.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧═══════────┘
 -> file: fediverse/6254
═════════════════════════════════════════════════════════════════════───────────────
  economies of scale come to mind
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════════──┴───────────┘
 -> file: fediverse/702
═════════════════════════════════════════───────────────────────────────────────────
  Branches cause cache misses which are slow when done on repeat.

  Better to structure your code to avoid them, if possible, for example by using
  an array of function pointers instead of switch statements.

  unrelated, but once the data is cached from memory, operations like bit
  shifting and arithmetic are essentially free. The slowest part of the process
  is moving data from RAM to cache so that the CPU can use it.

  That being said, CPUs and compilers are VERY good at optimizing that type of
  thing these days.
┌─────────┐                                                            ┌───────────┐
│ 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/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: fediverse/6106
════════════════════════════════════════════════════════════════════────────────────
  ┌─────────────────────────────────────────────┐
  │ CW: wild-unhinged-absurd-thoughts-mentioned │
  └─────────────────────────────────────────────┘


  what if closed source computing is actually better?

  computer programs should be dumb
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════════════───┴───────────┘
 -> file: fediverse/2859
═════════════════════════════════════════════════───────────────────────────────────
  ┌───────────────────────┐
  │ CW: cursing-mentioned │
  └───────────────────────┘


  large corporations will often error check *constantly* which slows down their
  software to an immense degree.

  every time data passes from one function to another, there's like... 15
  different tests to check if it's this type or that, or in the right random seed

  and it's like... wow can you not, like. design your software intelligently and
  then you won't need a bunch of slow-ass if checks every time you want to update
  a string???

  software should be writable without fucking getters and setters. If it isn't,
  then your functions aren't complete.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/3338
══════════════════════════════════════════════════──────────────────────────────────
  @user-246

  I tend to stack overflow a lot T.T
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/3792
═══════════════════════════════════════════════════─────────────────────────────────
  If you have a thousand options in your case / switch statement, you should
  probably refactor.

  consider putting function pointers (to the things you would have switched to)
  in an array and instead of checking "if this enum, then this, if that enum,
  then that" etc send an index into the function pointer array. That way there's
  no branching at all.

  The best way to generate performant code is to reduce or eliminate branches. If
  you're working on a video game or networked program, this can be incredibly
  important.

  The second best way is probably reducing cache misses and increasing
  parallelism, but those are different problems.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: notes/my-desired-profession
══════════════════════════════════════════════──────────────────────────────────────
  I want to work with compute shaders. massively distributed computations that
  handle things using the graphics card. That's why I want to make low-level
  games, because you can utilize your system to it's utmost potential by
  sacrificing the incredibly expensive modern gaming graphical requirements.

  like honestly, we don't need ray-tracing in a poker game.

  Seriously use that graphical technology for more interesting things, like
  manually computing every single hair on the other player's character model

  ... wait bad example
┌─────────┐                                                            ┌───────────┐
│ 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/3274
══════════════════════════════════════════════════──────────────────────────────────
  "I can't remember that function, it does too few things"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/1553
════════════════════════════════════════════────────────────────────────────────────
  if you optimize for competitive advantage, then eventually you'll optimize away
  from all the reasons to compete.

  which is how you get ~~paperclip~~ profit maximizers.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════───────────────────────────┴───────────┘
 -> file: fediverse/1034
══════════════════════════════════════════──────────────────────────────────────────
  @user-192

  be careful, recursion can cause stack overflows.

  better to run function pointers from a loop. That way you can operate as long
  as necessary. Just make sure you don't get in an infinite loop...
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: fediverse/3663
══════════════════════════════════════════════════──────────────────────────────────
  @user-1582

  It depends on the size of the file, copying a thousand lines of config file
  probably isn't that big of a deal, but copying a million lines in a log file
  just to pass it as an argument to... pad it to the left, or whatever, that'll
  DEFINITELY slow down your execution speed!

  Much better to pass by reference, usually...
┌─────────┐                                                            ┌───────────┐
│ 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 │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> 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/4118
═════════════════════════════════════════════════════───────────────────────────────
  all modern software should be written in a multithreaded way, change my mind
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════──────────────────┴───────────┘
 -> file: fediverse/1252
═══════════════════════════════════════════─────────────────────────────────────────
  @user-883

  hmmmm, I see. Once I have it set up I'll keep that in mind if I notice latency!
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: notes/why-I-never-get-hired
═══════════════════════════════════════════════════════════════════════════════─────
  because I solve problems permanently and can't do repeated work.
  they just want to waste time. a solved problem is one less worker to hire.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧═══════────┘
 -> file: fediverse/2729
═════════════════════════════════════════════════───────────────────────────────────
  haha it's always as soon as I open my resource monitor, the fans die down xD
screenshot of a resource monitor where there's a sharp vertical line right as the program is opened and the graph starts, implying the task given to the CPU was cancelled as soon as the resource monitor was opened
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/3687
══════════════════════════════════════════════════──────────────────────────────────
  @user-1573

  I saw this video:
  https://www.youtube.com/watch?v=CwfKlX3rA6E

  and I was like "yeah that sounds pretty neat" so I started doing it by hand
  lmaoooo but learning their system could be probably better. Reduced duplication
  of effort. Though TBH the biggest effort for me is learning someone else's
  tools, not writing them. So....
┌─────────┐                                                            ┌───────────┐
│ 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: 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/5360
══════════════════════════════════════════════════════════════──────────────────────
  another day goes by when I haven't done any programming... oh well
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════════════─────────┴───────────┘
 -> file: fediverse/4123
═════════════════════════════════════════════════════───────────────────────────────
  @user-883

  you're right

  but I think your first impulse should be to think about how to do it in a
  multithreaded way

  If the result is that single-threading would be better, great! It'll be easier!

  But thinking about multithreading first will give you crucial insights into the
  structure of the program.

  depending on what kinds of programming you do...!
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════──────────────────┴───────────┘
 -> file: fediverse/4124
═════════════════════════════════════════════════════───────────────────────────────
  @user-883

  well, depending on what you're trying to accomplish, maybe processing 1/16th of
  the audio file on 16 different threads would be faster. I guess it depends on
  if you need context from earlier in the processing stage - if you do, then
  you'd probably want to do 1/16th of the processing on each thread instead.

  ... hmmmm that doesn't look right, how about this:`[changes all the magic
  number 16s to num_threads]
  `
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════──────────────────┴───────────┘
 -> file: fediverse/879
══════════════════════════════════════════──────────────────────────────────────────
  @user-501

  also it's only undefined behavior because the order of the bits aren't defined,
  so if you do bitfield "pointer arithmetic" then you're screwed if you try and
  be portable with it. However if you're just using bitfields as compressed data
  storage then you can safely access integer.a integer.b integer.c etc safely and
  easily. The compiler doesn't care what order they're in if you don't write
  logic that requires them to be in a certain order
┌─────────┐                                                            ┌───────────┐
│ 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: fediverse/5297
══════════════════════════════════════════════════════════════──────────────────────
  ┌──────────────────────┐
  │ CW: re: piss, ??     │
  └──────────────────────┘


  @user-1797

  this is something I routinely fail at T.T
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════════════════─────────┴───────────┘
 -> file: fediverse/1520
════════════════════════════════════════════────────────────────────────────────────
  the slower you think about things, the more time you have to write to long-term
  memory. School optimizes this out of us.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════───────────────────────────┴───────────┘
 -> file: fediverse/5035
════════════════════════════════════════════════════════════────────────────────────
  I don't think I could program in an IDE anymore. They're just way too
  inconvenient.
┌─────────┐                                                            ┌───────────┐
│ 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: messages/1170
════════════════════════════════════════════════════════════════════════────────────
  look, it's easy enough to solve bitrot. Just store three copies of the file and
  synchronize them everytime you open them. Like, an in-software raid array,
  except with less expense because a .png is what, 2mb? great, now they're 6mb.
  Nobody will notice except people who really should be buying more hard drives.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧───────────┘
 -> file: fediverse/3643
══════════════════════════════════════════════════──────────────────────────────────
  if you cannot rapidly reorganize, then you are not organized.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/6341
═════════════════════════════════════════════════════════════════════───────────────
  if you want to win, play suboptimally without danger of losing.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════════──┴───────────┘
 -> file: messages/129
═════════════════════════════════════════───────────────────────────────────────────
  So you're telling me the speed difference between Python and C is due not to
  the logic that the programmer uses, but rather the optimization capabilities of
  the compiler?

  (An interpreter includes a compiler, it just runs it in a loop rather than a
  single pass)
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘
 -> file: fediverse/4826
═════════════════════════════════════════════════════════───────────────────────────
  the fact that linux software by default shares libraries causes 90% of the
  difficulty that new and medium skill users of linux face.

  disk space is cheap. spend more on hard drives and double the software size.
  make redundancy that prevents software failures but doesn't slow down the
  machine.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════──────────────┴───────────┘
 -> file: fediverse/6348
═════════════════════════════════════════════════════════════════════───────────────
  here's a neat function
computer code
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════════──┴───────────┘
 -> file: fediverse/5663
════════════════════════════════════════════════════════════════────────────────────
  I'm going to write some lua code that doesn't do anything useful and which I
  don't share with anyone
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════════───────┴───────────┘
 -> file: fediverse/3123
═════════════════════════════════════════════════───────────────────────────────────
  using linux requires *constant maintenance* and that's kind of unfair, actually.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/4192
═════════════════════════════════════════════════════───────────────────────────────
  whyyyyyyy am I cursed with this 1024 character limit

  why can't it be like, 16 characters total. I think that'd limit my thoughts
  enough.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════──────────────────┴───────────┘
 -> file: fediverse_boost/334
◀═╦═════════════════════════[BOOST]══════════════════════════────────────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ compiler errors per revolution                                           │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ 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/3817
═══════════════════════════════════════════════════─────────────────────────────────
  hey, anyone wanna build the matrix with me? minus the human CPUs of course.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/5559
═══════════════════════════════════════════════════════════════─────────────────────
  @user-1850

  why not just reduce the number of ping checks to see if they're still
  connected? if nobody's talking then why bother sending nothing to nowhere?

  the bandwidth for silence is free.
┌─────────┐                                                            ┌───────────┐
│ 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: messages/107
════════════════════════════════════════────────────────────────────────────────────
  The most expensive is overpriced. The cheapest sucks. The middle option is the
  workhorse.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> file: fediverse/1712
═══════════════════════════════════════════════─────────────────────────────────────
  @user-246

  I think you're right, I tend to examine things at their most extreme as
  practice in identifying my own weaknesses. ^_^
┌─────────┐                                                            ┌───────────┐
│ 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/1872
═══════════════════════════════════════════════─────────────────────────────────────
  the most efficient productivity hack that I know is:

  pkill firefox
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: fediverse/2099
════════════════════════════════════════════════────────────────────────────────────
  @user-1168

  Well of course it's in slow motion, otherwise we'd have the urgency to do
  something about it.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/3615
══════════════════════════════════════════════════──────────────────────────────────
  code is useless

  the ability to write, maintain, or implement it is priceless
┌─────────┐                                                            ┌───────────┐
│ 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/3264
══════════════════════════════════════════════════──────────────────────────────────
  @user-883

  !!!! this is a GREAT and FANTASTIC idea!!!

  then all the components would be guaranteed to have a synchronous clock
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: notes/memory-is-expensive
═════════════════════════════════════════════════════════════════════════════════───
  computer memory is expensive right now. Not long-term memory, but the short term
  stuff.

  so, programmers should write programs that use misd more than simd.

  simd is graphics cards, it is many, it is small medium and large.

  misd is many smaller processors, it is one, it is atomic in scale.

  simd iterates over data.

  misd changes one frame at a time.

  simd applies routines to all of the data,

  like running functions in a loop,

  misd adjusts from all angles

  like cells in molecular goop.

  each angle, a processor, pointed at shared memory.

  or at least a thread or a core.

  each cell, a part of functionality.

  the molecular goop is the program's timeline.

  the program is abstractable-ing in usage.

  and by timeline, I mean like... "these functions are stored in this place in
  ram, these datas are stored at that place in ram, oh that function just ran so
  let's load it to this particular spot on disk, etc etc" etc etc
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧═════════──┘
 -> file: fediverse/6
══════════════════════════════──────────────────────────────────────────────────────
  ┌──────────────────────┐
  │ CW: Math             │
  └──────────────────────┘


  @user-5 create an array of length 7 initialized to zero. then use a for loop
  that loops 97 times and adds a random number between 1 and 20 to an array index
  that iterates through the array each time through the for loop.

  NOTE: be sure to also change the loop counter based on the random number too,
  so you allocate exactly 97 points no matter what random number you get.

  Oh and speaking of which if the loop counter
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════─────────────────────────────────────────┴───────────┘
 -> file: messages/1116
═══════════════════════════════════════════════════════════════════════─────────────
  What works for me might not work for another,

  But

  What works for me might work for another.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════┴───────────┘
 -> file: fediverse/2640
════════════════════════════════════════════════────────────────────────────────────
  ┌──────────────────────────┐
  │ CW: capitalism-mentioned │
  └──────────────────────────┘


  capitalism is like if your thread allocator gave 90% of the work to 10% of the
  threads in the pool and your tech lead claimed it was more efficient because
  the remaining 90% of threads would have the results of the program "trickle
  down" to them somehow
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/1047
══════════════════════════════════════════──────────────────────────────────────────
  #CDCsays if you budget for 50% of what you're making then the other 50% could
  double your headcount

  EDIT: also that it's opposite day
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: fediverse/1067
══════════════════════════════════════════──────────────────────────────────────────
  ummmm srry about that, changing channels for a bit
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: fediverse/658
═════════════════════════════════════════───────────────────────────────────────────
  posts and replies: the superior way to view a performance
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘