=== ANCHOR POEM ===
════════════════════════════════════════───────────────────────────────────────────
old school programmers use short variable names because the computer monitors
they would code on had a lower resolution, meaning fewer characters per line.
why waste pixels being verbose?
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════──────────────────────────────┴───────────┘
=== SIMILARITY RANKED ===
--- #1 fediverse/282 ---
════════════════════════════════════════───────────────────────────────────────────
@user-209
I think you're right. Every letter in the variable name is another byte the OS
has to keep track of, which was a bigger problem in the past than it is today
(when it's been made irrelevant)
it's interesting how habits persist though the conditions that caused them
have faded. like a personal reflection of the environment you learned in.
"A a = new a();" is much more concise and (crucially) you can fit more words
to the right.
"a + b = c; c -= 2; f_z.write(c); f_z.close();" could conceivably be written
on a single line if you have short variable names. and when you only have so
many lines...
glad we're not constrained by those things anymore. the skeletal code that we
look at daily is much clearer - scope is more important, and so it makes sense
to encourage a coding style that illustrates it. however I can't help but
think block formatting like this could be useful in some situations, such as
when you'd normally be compelled to write a function for an operation that
runs once or more.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════──────────────────────────────┴───────────┘
--- #2 fediverse/5179 ---
══════════════════════════════════════════════════════════════─────────────────────
why don't corporations let you write code in whatever language you want? it's
trivial to run a compiler or interpreter inside of another program.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════════════════────────┴───────────┘
--- #3 fediverse/5658 ---
══════════════════════════════════════════════════════════════════─────────────────
do you think the "main menu" in video games is named after the main() function?
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════════════════════────┴───────────┘
--- #4 fediverse/3559 ---
════════════════════════════════════════════════════───────────────────────────────
@user-1209
like... var = x?? that doesn't make sense. Or like, 5 = var x? that feels
*wrong*
in programming = is assignment, not equality, which tripped me up for a bit.
But if you read it left to right it's like X equals 5. Got it, now I know that
X is the same as 5. Right?
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════════════──────────────────┴───────────┘
--- #5 fediverse/646 ---
╔══════════════════════════════════════════────────────────────────────────────────┐
║ @user-470 │
║ │
║ oh sorry I'll "en-longify" that for you: │
║ │
║ most monitors have a fixed resolution, somewhere between 720 pixels wide and │
║ 480 pixels high to 2560 by 1440 pixels high/wide. │
║ │
║ This is due to both the desire for humans to read left to right (ingrained in │
║ our minds at a very young age by learning to read) (or right to left, same │
║ direction) that we develop the desire for wide-screen monitors. │
║ │
║ Therefore, the windows of perception that we have unto this digital world are │
║ constrained (necessarily) to their own individual specifications. Of which, │
║ the property value "width" is more valued than "height". Because of this, we │
║ believe that computers are mistakenly re-acclimated - for everything is most │
║ efficient when it's aligned to the smallest bits of it's design. │
║ │
║ sorry, I like programming in C. Basically I'm very porous, and thinking about │
║ low level topics (like C programming) is an easy way to burn characters when │
║ there's only so many in the mastodon post that I can use to express my intents │
║ and tr │
╠═════════╗ ┌───────────┤
║ similar ║ chronological │ different │
╚═════════╩═══════════════════════════════─────────────────────────────┴───────────┘
--- #6 fediverse/5035 ---
══════════════════════════════════════════════════════════════─────────────────────
I don't think I could program in an IDE anymore. They're just way too
inconvenient.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════════════════────────┴───────────┘
--- #7 fediverse/3396 ---
╔═══════════════════════════════════════════════════───────────────────────────────┐
║ you should only use variables for things that are user-configurable. │
║ │
║ everything else should be hard-coded, with a clear and coherent reasoning │
║ stored in the documentation, with git-style revisions included and easily │
║ browsable. │
║ │
║ (what if you want to tweak a value somewhere? you'd have to update it on every │
║ single page!) │
║ │
║ true. maybe we could set aside a section of memory to store a value and then │
║ just point to it using a label. That way we could always keep our values │
║ hardcoded, but also be able to find them easier. │
║ │
║ [tweak them, not find them] │
║ │
║ ... yah okay fine both would technically work │
║ │
║ [yes but one of them is not a good timeline to lead the world down.] │
║ │
║ ?..?...?....?..... -.- ...... /shrug ....... ...? │
║ │
║ "bruh why is she reinventing variables" │
║ │
║ she's learning give her time │
║ │
║ ... did you hear a doctor diagnosed her finally │
║ │
║ "whaaat what'd they give her" │
║ │
║ they said it was "schizotypal" │
║ │
║ "... did she forget a symptom or three?" │
║ │
║ no dude thats one of the bad ones │
║ │
║ "oh right. I heard typical" │
║ │
║ yeah so anyway │
╠═════════╗ ┌───────────┤
║ similar ║ chronological │ different │
╚═════════╩════════════════════════════════════════────────────────────┴───────────┘
--- #8 fediverse/4845 ---
═══════════════════════════════════════════════════════════────────────────────────
put the variable type at the front of the variable and 90% of your type errors
will dissapear
like...`int int_main(){ return 0; }
`
or`int int_modulation_gauge_percentage_point_plus_or_minus_engagement = 0;
`
seeeee if the "int" value is at the start of the name then you can do this
too:`double double_modulation_gauge_percentage_point_plus_or_minus_engagement
= 0.0;
`
then when you go to fill in an "int" value you know to use the one that has
the "int" value at the beginning (doh)
(do you really think they haven't tried that already? it... sorta worked.
people started doing things like "int int_a; int int_b; int int_c;" and such
and that got confusing pretty quick because the letters weren't at the start
of the word. So for some situations we would mirror them like so: "int A =
int_a; int B = int_b; int C = int_c;" and then just use the capitalized
letters.
... just don't forget to update the original teehee (this is why we invented
shadowed variables)
wait, no I meant pointers !!~! -.-
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════════════════════════───────────┴───────────┘
--- #9 messages/890 ---
═══════════════════════════════════════════════════════════════────────────────────
If your code is too long to fit in 80 or 120 characters (preference) then you
need to use more numbers (indexable with a small table-of-contents style
comment description just above) or character symbols (referencably by meaning
just as above) (by above she means earlier in the string of text you just read)
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════════════════════════════───────┴───────────┘
--- #10 fediverse/1810 ---
═════════════════════════════════════════════════──────────────────────────────────
some people hear words like "datastructures" and "object-oriented programming"
and think they're made up terms that don't mean anything important.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧══════════════════════════════════════─────────────────────┴───────────┘
--- #11 fediverse/6437 ---
════════════════════════════════════════════════════════════════════════───────────
if I was writing a programming language, I'd name it C just to fuck with people
(great, now others can decide how it's known)
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════════════════════════╧═──────────┘
--- #12 fediverse/5248 ---
═══════════════════════════════════════════════════════════════────────────────────
programming is something that everyone should learn at 14 to be used for
calculating large sums of data, visualizing something they're trying to
explain, or connect two systems that aren't normally connected.
It should not be used as an eternal debug producing machine, nor as a way to
collect and store user information to be sold as the real product, nor to be
collecting and targeting -- stack overflow -- wow, talk about death of the
author, amiright? -- -- endless data hoarding monger machines to point and to
ponder the eternal ramifications of the brutal and violent prompts and their
baggage implied when submitted for each semi-random thought that from the
users mind was displaced.
... "they can sell this" and or "this is mrs selvig" who is this mister and
why is the ms's his-es
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════════════════════════════───────┴───────────┘
--- #13 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 │
╘═════════╧═══════════════════════════════════════════════════────────┴───────────┘
--- #14 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 │
╘═════════╧═════════════════════════════════════════──────────────────┴───────────┘
--- #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/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 │
╘═════════╧═══════════════════════════════════════────────────────────┴───────────┘
--- #17 fediverse/857 ---
╔══════════════════════════════════════════────────────────────────────────────────┐
║ I feel like I'd learn from coding tutorials more if someone started with a │
║ complete program they can fit on one panel of their screen, a second for │
║ showing what each particular thing they're pointing at means, and a third for │
║ a typical usecase they might build and dismantle on the fly. │
║ │
║ like, scientific toys that they could use to explain a particular phenomena. │
║ the way people used to have 3d models they either bought or built themselves │
║ of like, atoms and wind patterns and stuff they could explain to kids. │
║ │
║ you know, like exactly the kind of things that are commonly stored at │
║ children's museums. │
║ │
║ I was homeschooled, so I went to those places quite a lot. I always felt a │
║ little unwelcome because I always seemed to be the eldest in every bunch. │
║ That's continued all throughout my adulthood, like each of my peers are just a │
║ few years younger than me. I think I just mature more slowly, and thus │
║ associate with below the average. │
║ │
║ it's like, a descriptor of your rate of defining reality and being guided by │
║ it. when │
╠═════════╗ ┌───────────┤
║ similar ║ chronological │ different │
╚═════════╩═══════════════════════════════─────────────────────────────┴───────────┘
--- #18 fediverse/3226 ---
═══════════════════════════════════════════════════────────────────────────────────
if your man page is longer than a list of options and their usage and a
paragraph or twenty of how to use the software... then you need to abstract,
and break your code into multiple purpose-built applications.
do one thing, and do it right. alternatively, do one set of things, and do
them concisely.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════════════════───────────────────┴───────────┘
--- #19 fediverse/5839 ---
════════════════════════════════════════════════════════════════════───────────────
@user-1074
good code isn't always easily read. sometimes the architecture is more
important.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════════════════════════════──┴───────────┘
--- #20 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 │
╘═════════╧════════════════════════════───────────────────────────────┴───────────┘
--- #21 fediverse/5696 ---
image.png
══════════════════════════════════════════════════════════════════─────────────────
hey does anyone wanna go over my code for this text adventure game thingy that
I spent 2 days on so far?
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════════════════════────┴───────────┘
--- #22 fediverse/185 ---
═══════════════════════════════════════────────────────────────────────────────────
so... is dynamic typing just automatic typecasting?
#programming
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════───────────────────────────────┴───────────┘
--- #23 fediverse/4196 ---
╔══════════════════════════════════════════════════════────────────────────────────┐
║ if you only have a phone, you can still program. Just write it out on paper, │
║ and put the whole program out on the floor. │
║ │
║ Screens will never compare, for they are but a tiny keyhole into the total │
║ program at hand. And you can pick parts of it up and carry them around - so │
║ useful! You could make an entire building out of that. [floorplan, layout, │
║ that kind of thing] │
║ │
║ downside is, of course, *you don't have a computer*, so you have to look up │
║ syntax on your phone. │
║ │
║ and eventually you're gonna have to type it, unless you can get a computer to │
║ read it for you. │
║ │
║ just imagining office buildings where employees can follow along with monitors │
║ on the wall that explains what they're working on and what they need to resolve │
║ │
║ then they meet up with a bunch of other humans and they hash things out │
║ │
║ turns out computers are *really bad* at speaking in group situations. │
║ │
║ which is why they let humans do that all on their own. [uhhh, no it's how you │
║ can tell if someone's a robot/alien/lizard/spy/secret-agent/whatever-sneaking] │
╠═════════╗ ┌───────────┤
║ similar ║ chronological │ different │
╚═════════╩═══════════════════════════════════════════─────────────────┴───────────┘
--- #24 fediverse/5979 ---
═════════════════════════════════════════════════════════════════════──────────────
whenever you call a function, just pass along the arguments that you don't
know what to do with yet. they'll surely be useful sometime. and, luckily, you
can always search for them from the past, and just insert a "store this value
in this random spot of memory and mark it as needed" then pass it along. used
something? think it's still useful? pass it along (suddenly, formulaic
stateless development, where everything is used until it's no longer needed,
then generated again in a cyclical time-loop cycle which echoes and
reverberates groundhog day but mostly a game-loop, which nobody will
understand unless you're a game dev. but now since I said game dev, anyone can
look it up, so like... not that one, but others like it.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧══════════════════════════════════════════════════════════─┴───────────┘
--- #25 fediverse/1768 ---
═════════════════════════════════════════════════──────────────────────────────────
programming is great but have you heard of "not working on forging new
technological paradigms and instead playing a 500th round of Mechabellum"?
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧══════════════════════════════════════─────────────────────┴───────────┘
--- #26 fediverse/3615 ---
════════════════════════════════════════════════════───────────────────────────────
code is useless
the ability to write, maintain, or implement it is priceless
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════════════──────────────────┴───────────┘
--- #27 fediverse/403 ---
═════════════════════════════════════════──────────────────────────────────────────
cursed idea:
a compiler that only accepts source-code with exactly 80 characters per line
(whitespace counts)
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧══════════════════════════════─────────────────────────────┴───────────┘
--- #28 fediverse/4093 ---
══════════════════════════════════════════════════════─────────────────────────────
I have no idea why people *prefer* a GUI when working with software. How the
heck do they expect to use their computer remotely if they can't even run
their software over SSH?
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═══════════════════════════════════════════────────────────┴───────────┘
--- #29 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 │
╘═════════╧══════════════════════════════─────────────────────────────┴───────────┘
--- #30 fediverse/3544 ---
════════════════════════════════════════════════════───────────────────────────────
┌───────────────────────────┐
│ CW: programming-mentioned │
└───────────────────────────┘
"I wish there was a language that was as simple as C but had [insert complex
language feature here]"
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════════════──────────────────┴───────────┘
--- #31 messages/971 ---
═══════════════════════════════════════════════════════════════════────────────────
vimcoders can be vibecoders too. it's just about what language you want to use
to talk to the computer, right?
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════════════════════════════════───┴───────────┘
--- #32 fediverse/1597 ---
════════════════════════════════════════════════───────────────────────────────────
hey a couple months ago there was this really cool visual programming language
posted here that was like, windows aero themed and it was super cute - does
anyone know what that was called or have a link to it?
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧═════════════════════════════════════──────────────────────┴───────────┘
--- #33 fediverse/3173 ---
═══════════════════════════════════════════════════────────────────────────────────
you've heard of an array of function pointers, yes,
but have you ever heard
of an array of GOTO labels?
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧════════════════════════════════════════───────────────────┴───────────┘
|