Easy to maintain.

Maintainable beyond the functionality of the original program.

The growth rate of something as you add more things. It's given as a function of O, Omega, Theta, etc. That basically means it's an approximation of how the value grows.

A function or other block of code that calls itself repeatedly and indefinitely, or until some condition is met. While harder to conceptualize, solutions that make use of recursion are often faster than their interative counterparts.

The process of making changes to a function, code block, or system in order to make it more efficient. Efficiency could be in terms of speed, memory use, or even power draw.

The complexity of time.

The complexity of memory, or hard drive space.

Integral is the word the c++ documentation uses when describing a whole number/integer. Basically any variable that counts by one.

A word set aside by a language for a specific purpose. Like const, int, async, await, nullptr, etc.

Convention where people include the type in the name using a single character, like iBruh. This isn't optimal as there are other techniques to get around this as mentioned in Lesson 1: Variable Names.

A good variable name to use when you're trying to make an example of a variable (or if you can't think of anything. Especially useful for avoiding potential naming conventions/keywords.

Integrated development environment. Basically a GUI that compiles and runs your code, with extra features like live compiler warning evaluation, file heiarchy/outliner, variable/register watchlists, etc.

Adjective describing something with multiple potential meanings. This is because you want to make your code be obvious in its intention.

Ternary statment. Uses the ternary operator (?) to switch true/false to two possible values. condition? true : false. The ternary operator has one of the lowest precedences, but can still cause issues, so remember to use parentheses.

The area in which a variable lives (and afterwards, dies). Some things come with their own scopes, like for loops, but you can also make your own "floating" scopes by using { var brackets; }. This is helpful as it frees up the variable name for reuse in some other place in the current scope.

A function or variable is part of the global namespace if it is not explicitly from a specific namespace. You could say it has no namespace, though in some languages they have an explicit global:: tag. It is best practice to avoid using the global scope when possible.

Adjective describing a variable in the global namespace

Variable, function, namespace, macro, etc's assigned name when initialized. Basically a name for names, but that gets confisung to talk about. You don't want to say "Type the person's name" when you mean the identifier of the person object.

File where the functions, variables, and other code is defined. This gets compiled separately and later linked with other files that use those definitions.

The file you use when #include ing. It's a good resource if you just want to see the members an object has. It's like free documentation.

Things existing in the same space when they shouldn't be. Like two different object's hashes being the same, two variables being named the same, or your wife finding you with your girlfriend.

Something an object has. Variable, function, defined types etc.

Member function. A function an object has.

A built in type like int, float, bool, char*. Sometimes something like an ArrayList will require an Object, and these primatives need to be wrapped in an object.

Without the programmer needing to code it.

Writing multiple functions with the same name, but different parameters.

Writing a different function with the same signature in a child class.

The line including the return type, the function identifier, the parameters, and whatever compiler flags you throw on there.

A function that is made not to get called by others, but to deduplicate and/or hide away code. They're just there to help make writing code easier and cleaner. These are private functions / functions defined and not exported out of a different source file, because they're not meant to be called again.

Any instruction that has a condition. Typically for performance because the processor has to jump somewhere else, which makes the processor pipeline mess up. After you optimize code, the only way you could avoid this is preprocessor hackery, or self modifying code, so don't worry about this too much. Remain stoic, only care about things you can control.

A tool much like a class, but only for data, not functionality. Instances of a struct may be created, then the properties of that struct can be set for each object.

Decoupling two systems means to remove any reliance they have on one another. In other words, if two systems depended on eachother, but you decoupled them, they no longer depend on eachother.

Function argument. The thing in the parentheses. You'd be surprised how many people don't know that. This word comes from highschool algebra, but is used throughout computer science.

To report an error during runtime. The phrase "throwing an error" is funny because how ridiculous and unprompted it normally is.

To deal with a thrown error. Errors propogate up searching for something to catch them. If nothing catches it, the program has to crash.

Collections of pre-written code that can be used to accomplish and optimize tasks.

Different variations in which a set can be ordered or arranged (ABC, BAC, BCA, ...).

A program that converts code or instructions into machine language that can be executed by a computer.

The amount of time that a CPU has been running for a specific program or process.