Traister101

Github outside of hosting the actual git repo largly just provides good routes for collaboration, namely issues, their PR system and some convenient rules on who is allowed to mess with branches and how (IE you can set master to only accept merges done via github themselves). CI is the real lock in far as your git repo is concerned cause that just won’t work at all on another host

Uninitalized memory (int a; with no assignment) vector of int vectors (IE a dynamic int[][]) and attempting to find a, an int in the vector of vectors of int IE int instead of vector<int>. I think the iterator type is correct but I’m not sure off the top of my head

Okay? I’m well aware. I do so all the time

/ is used to separate the same branch in different repos. For example origin/main and remote/main. Surprising that the other stuff is legal though

You don’t have to be religious to think a fat dude in some red clothes that magically travels around the world giving out presents to good children isn’t a fun yearly tradition. Frankly it’s kind of an overdramatic reaction to a small red hat overlaid onto an icon. Should configuration be provided to disable the functionally? Sure I don’t care, hell have it disabled by default I don’t mind but it’s stupid to make a huge stink about something so minor.

JetBrains has really nice Git integration. Interactive rebaseses and merges are quite pleasant but I’m still dipping into the command line to do stuff occasionally. Most commonly a git reset HEAD~ cause I want to split a commit though I had to dig through the reflog the other day cause I suddenly realized I lost an important branch that ended up being over a hundred commits back.

Act works out pretty good but you need to pass it a token and stuff so the actual github CLI bits can work which is kind of a hassle. It took me much too long to discover you need a classic token, the one from the github CLI app gh auth token won’t work.

Edit: Ah! Also getting act setup involved getting docker setup which involved me enabling virtualization in my bios for what I swear is like the 4th time I’ve done so. Also because I’m on Windows (iirc at least) I had to setup WSL or just make a windows container ಠ_ಠ

I’d say in most cases that’s a sign something needs to be extracted into a separate function. Course sometimes code is just complicated and extracting only makes things harder to follow. Even then I’d much rather use early return than nested ifs as those are significantly harder for me to follow.

My code got much more readable when I learned about early returns lol

Nah standard libraries are great but C++ has a lot of… cruft. Maybe don’t plonk a lot of Rust in there despite all the positives

Gonna need to start calling it C++++ at this point. So much extra shit in the standard library

Eh? How’s that work. I’m not going to sit here and say there isn’t too many factories in Java but as a concept it’s extremely useful. You hand off a “factory” to something which actually creates the object. This is really useful in for example serialization. How so? You could register factories (mapped to some sort of ID) which get passed the serialized data and return some sort of created object. Now the core serialization code doesn’t know nor care how exactly any particular type gets serialized. Pretty nifty huh?

Some languages have better ways to encapsulate this functionality but that’s what the factory concept is

No python is statically typed. You have type hints, which makes the language tolerable but like their name implies it’s a hint at the type. You can perfectly legally pass in something completely different that doesn’t conform whatsoever.

The primary thing static languages provide is static typing, that being the ability to determine before runtime that all the types are valid. A good example of this is how C++ programs will refuse to compile if you try to invoke a method that doesn’t exist on the type. That’s because it’s statically typed. At compile time you know that the code is wrong. Dynamic languages fundamentally don’t work like that. You cannot know until runtime if the method you called or the field you are trying to touch exists or not. Again type hints help a lot with this but that doesn’t change how the language actually operates.

They specified statically typed languages. Python would be dynamically typed

And the entire stack trace

So the big important part of git is that it’s a collection of commits. A branch is just a labeled commit and each commit is a list of what changed from the parent. Rebasing (the most confusing one for people) is when you fiddle with a commit from underneath yourself. Or in even more simple terms editing a parent commit. Rebasing is extremely powerful but most useful for when you notice a bug you wrote a couple commits ago. Fixing such issues via rebase (or !fixup commits you auto squash at the end) keeps your history clean. It’s as though you never wrote the bug. The other thing you do a lot with rebasing is moving your branch up in the history cause somebody updated the remote.

Wow, that looks like a nightmare

Yep that’s why I refuse to use standard libraries. It just makes my code too complicated…

Permits is only required when the compiler can’t see the extending classes. IE inner classes can extend without needing to be written out in a permits clause. This isn’t really that useful but I’ve taken advantage of it more than once so who knows

Semantic whitespace is awful because whitespace (something that you can’t actually see) has meaning in how the program runs. Braces { } for scopes gives you the ability to easily tell at a glance where a scope ends. Whitespace doesn’t allow for that. Especially, especially when you can accidentally exit a scope (two new lines in a row with Python) and it’s not actually an error (Pythons global scope). Yeah formatters and linters make this less of an issue but it sucks… Languages with legible symbols for scoping are significantly easier to reason about, see end symbols in Lua.