firelizzard

Agreed. Even self-reviewing a few days after I wrote the code helps me see mistakes.

Ah, yeah that makes a lot more sense

Better to not have version control!? Dear god I hope I never work on anything with you.

I used this tutorial for shaders: https://learnopengl.com/Lighting/Colors

This one also has useful stuff about how lighting works: http://www.opengl-tutorial.org/beginners-tutorials/tutorial-8-basic-shading/

These are both about OpenGL, but the theory is the same regardless of the environment.

"Flagged as spam", "Publication Not Available". I can't see the article.

True, but if you read the article the point is clearly not about source code vs non-source configuration. There's an implicit assumption that source code is something the developer will be modifying as time goes on, but the real point is, "Don't make users merge changes."

Programming languages are tools. I couldn't care less about learning a new tool just for the sake of learning. My interest in learning tools is exclusively practical - if they help me do my work better.

I find functional languages interesting, but that's because I find the underlying theory interesting and worth learning for its own sake, not because I actually care about the specific language it's written in. Even then these days I'd rather learn about woodworking (which is currently my main hobby) than a programming paradigm I'm probably never going to use.

I think the author's primary point is, "Merging changes sucks, don't make your users do that," with a corollary: if your program loads configuration from a directory that is only populated by the user, there's nothing to merge and thus never any merge conflicts. Case in point: /etc/polkit-1/rules.d. I can add whatever rules files I want in there and they're never going to conflict when I update. If PolKit makes breaking changes to the format, it will log errors somewhere and I can look at those errors, look at my rules, and figure out how to fix them. That's a hell of a lot easier than merging conflicting changes to code/configuration.

Additionally, switch performs extra sanity checks that checkout doesn't, for example switch would abort operation if it would lead to loss of local changes.

What checks? Under what situation does checkout lead to loss of changes? If I make changes and attempt to checkout a ref that would overwrite them, I get the following error:

error: Your local changes to the following files would be overwritten by checkout:
        some/file
Please commit your changes or stash them before you switch branches.
Aborting

To my knowledge it's not possible to overwrite changes when switching branches/refs (git checkout <ref> without any other arguments or flags) so I guess what the author really means is, "If you use checkout incorrectly you can overwrite local changes." As far as I can recall I've never accidentally git checkout <ref> <some/file> so I don't see a reason to retrain my muscle memory. I do use git restore since it's behavior is a lot more obvious than checkout/reset though sometimes I still use git checkout <ref> -- <some/file> because muscle memory.

• Scenario: I'm in the middle of writing a new feature.
• Boss, to me: "Shit broke. Go figure it out."
• Me, thinking: I'm in the middle of doing some complex work. If I commit/stash and close the open files, it will take a day for me to remember WTF I was doing.
• Me: "Oh look, worktrees! I can leave my workspace intact with all the files open, pending changes, test results, terminal output, everything! And just create a new worktree to checkout the production version and debug! I'm saved!"

Also setting up a worktree is really easy. git worktree add ../hotfix prod-branch && cd ../hotfix and get working. Though in reality it's cd ../hotfix && git checkout prod-branch because I've never needed more than one secondary worktree.

To me this is an argument for why Go should not add type inference to function/method declarations. Go is like Rust (I guess, I haven't used Rust) - type inference works for declaring a variable (or const) and generic type parameters but not for type declarations, methods, functions, etc. I was in the "more inference is always better" camp but now I'm thinking Go has the perfect level of inference. Except for function literals/lambdas. I really want go to infer the argument and return types when I'm passing a function literal/lambda to a function.

The presence of semicolons is not a language killer.

I'm not saying it is. But every time I have to work in a language that requires semicolons I'm constantly forgetting them and constantly reminded of how nice it is to not have to care in Go.