=== ANCHOR POEM ===
═══════════════════════════════════════════────────────────────────────────────────
@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 │
╘═════════╧════════════════════════════════───────────────────────────┴───────────┘
=== SIMILARITY RANKED ===
--- #1 fediverse/5360 ---
════════════════════════════════════════════════════════════════───────────────────
another day goes by when I haven't done any programming... oh well
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════════════════════════──────┴───────────┘
--- #2 fediverse/3338 ---
═══════════════════════════════════════════════════────────────────────────────────
@user-246
I tend to stack overflow a lot T.T
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════════════════───────────────────┴───────────┘
--- #3 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 │
╘═════════╧═══════════════════════════════────────────────────────────┴───────────┘
--- #4 fediverse/3543 ---
════════════════════════════════════════════════════───────────────────────────────
@user-777
my favorite thing about specialization is that not everyone has to do
everything
(translate *that* into C lmao)
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════════════──────────────────┴───────────┘
--- #5 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 │
╘═════════╧═══════════════════════════════════════════════════════════╧═──────────┘
--- #6 fediverse/3737 ---
════════════════════════════════════════════════════───────────────────────────────
Nix the complexity.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════════════──────────────────┴───────────┘
--- #7 fediverse/6007 ---
═════════════════════════════════════════════════════════════════════──────────────
I always get the syntax backwards, for some reason...
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧══════════════════════════════════════════════════════════─┴───────────┘
--- #8 fediverse/5839 ---
════════════════════════════════════════════════════════════════════───────────────
@user-1074
good code isn't always easily read. sometimes the architecture is more
important.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════════════════════════════──┴───────────┘
--- #9 messages/966 ---
═══════════════════════════════════════════════════════════════════────────────────
boom, easy error-handling
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════════════════════════════════───┴───────────┘
--- #10 fediverse/111 ---
═══════════════════════════════════════────────────────────────────────────────────
@user-95 that's why I like programming - it's my favorite form of spelling.
i'm not very good at remembering all the names and the numbers, but I like to
think I can make things do a function.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════───────────────────────────────┴───────────┘
--- #11 fediverse/6348 ---
image.png
═══════════════════════════════════════════════════════════════════════────────────
here's a neat function
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════════════════════════╧───────────┘
--- #12 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 │
╘═════════╧═══════════════════════════════════════════────────────────┴───────────┘
--- #13 fediverse/94 ---
═══════════════════════════════════════────────────────────────────────────────────
@user-107 If you can figure out how to do it well, everything else seems less
difficult. : )
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════───────────────────────────────┴───────────┘
--- #14 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 │
╘═════════╧═════════════════════════════════════════──────────────────┴───────────┘
--- #15 fediverse/1960 ---
═════════════════════════════════════════════════──────────────────────────────────
Source code is like, the worst way to view code, but I can't think of anything
better, so whatever
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧══════════════════════════════════════─────────────────────┴───────────┘
--- #16 fediverse/5862 ---
════════════════════════════════════════════════════════════════════───────────────
time to do some programming...
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════════════════════════════──┴───────────┘
--- #17 fediverse/5935 ---
image.png
═════════════════════════════════════════════════════════════════════──────────────
I love computer programming
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧══════════════════════════════════════════════════════════─┴───────────┘
--- #18 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 │
╘═════════╧════════════════════════════════───────────────────────────┴───────────┘
--- #19 fediverse/2509 ---
══════════════════════════════════════════════════─────────────────────────────────
I've found that while working with modern internet technology, parsing json
and creating http requests are two of the most vital skills you can have.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════────────────────────┴───────────┘
--- #20 fediverse/1695 ---
════════════════════════════════════════════════───────────────────────────────────
@user-883
I love that. You're saying I should learn Assembly? ? ?
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════════──────────────────────┴───────────┘
--- #21 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 │
╘═════════╧══════════════════════════════─────────────────────────────┴───────────┘
--- #22 fediverse/5189 ---
══════════════════════════════════════════════════════════════─────────────────────
computer programming essentially boils down to putting the right values into
the right datastructures at the right time and in the right order.
If you count a function call as a datastructure, which I do, because I have
opinions.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════════════════────────┴───────────┘
--- #23 messages/1189 ---
══════════════════════════════════════════════════════════════════════════─────────
... )
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════════════════════════╧═══────────┘
--- #24 fediverse/4843 ---
═══════════════════════════════════════════════════════════────────────────────────
just because someone did something one way and it worked, doesn't mean you
have to do it that way again.
but you should have a reason why you aren't doing it that way.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════════════════════════───────────┴───────────┘
--- #25 fediverse/614 ---
image.png
══════════════════════════════════════════─────────────────────────────────────────
What does your template for a new project look like? Here's mine:
![39 lines of C code included in it's original form here: #include <stdio.h> #include "pthread.h" #include "raylib.h" void* draw(void* args){ const int screenWidth = 800; const int screenHeight = 450; InitWindow(screenWidth, screenHeight, "template"); SetTargetFPS(4); while (!WindowShouldClose()) { BeginDrawing(); ClearBackground(RAYWHITE); /* do something */ EndDrawing(); } CloseWindow(); return NULL; } void* game(void* args){ /* do something */ return NULL; } int main(void) { void* args; pthread_t threads[2]; pthread_create(&threads[0], NULL, draw, &args); pthread_create(&threads[1], NULL, game, &args); return 0; }](../media/8e35bbbdac68b6ae.png "39 lines of C code included in it's original form here: #include <stdio.h> #include \"pthread.h\" #include \"raylib.h\" void* draw(void* args){ const int screenWidth = 800; const int screenHeight = 450; InitWindow(screenWidth, screenHeight, \"template\"); SetTargetFPS(4); while (!WindowShouldClose()) { BeginDrawing(); ClearBackground(RAYWHITE); /* do something */ EndDrawing(); } CloseWindow(); return NULL; } void* game(void* args){ /* do something */ return NULL; } int main(void) { void* args; pthread_t threads[2]; pthread_create(&threads[0], NULL, draw, &args); pthread_create(&threads[1], NULL, game, &args); return 0; }")
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════────────────────────────────┴───────────┘
--- #26 fediverse/1221 ---
════════════════════════════════════════════───────────────────────────────────────
@user-883
either that or I might get lost in some C code we'll see how things develop
>.>
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════──────────────────────────┴───────────┘
--- #27 fediverse/3274 ---
═══════════════════════════════════════════════════────────────────────────────────
"I can't remember that function, it does too few things"
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════════════════───────────────────┴───────────┘
--- #28 fediverse/6244 ---
═══════════════════════════════════════════════════════════════════════────────────
numbers are one-dimensional numbers and vectors are multi-dimensional numbers,
fight me
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════════════════════════╧───────────┘
--- #29 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 │
╘═════════╧══════════════════════════════════════─────────────────────┴───────────┘
--- #30 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 │
╘═════════╧═══════════════════════════════════════════────────────────┴───────────┘
--- #31 fediverse/2879 ---
══════════════════════════════════════════════════─────────────────────────────────
┌────────────────────────┐
│ CW: re: tech info-dump │
└────────────────────────┘
@user-1370
I love this a lot! I want to put function pointers in a "matrix architecture
array" and make them point to different functions at different points in the
program. I bet you could even point them at each other, so like if M and Y
then point at N, A, Y or something.
this is really cool I like stuff like this tomorrow I'll take pictures of
something similar I'm working on! I abandoned it tho hehe anyway remind me if
I forget!!
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════────────────────────┴───────────┘
--- #32 messages/10 ---
───────────────────────────────────────────────────────────────────────────────────
https://www.reddit.com/r/learnprogramming/comments/n0vm6e/im_just_now_understan
ding_gitgithub_and_i_feel/
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘─────────┴───────────────────────────────────────────────────────────┴───────────┘
--- #33 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 │
╘═════════╧════════════════════════════════════════════───────────────┴───────────┘
|