The 64 poems closest in meaning to this word, arranged to spread the colours (progress bar shows chronological position)
-> 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 ~~
┌─────────┐ ┌───────────┐ │ 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
┌─────────┐ ┌───────────┐ │ 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
┌─────────┐ ┌───────────┐ │ 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
┌─────────┐ ┌───────────┐ │ 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 │ ╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘ |