What I Am Learning as a CS Student

Layers of representation (high to low level) High-level language program  high-level language - a programming language that uses English and mathematical symbols in its instructions (e.g. C)  High-level programming languages are abstractions to lower-level programming languages  compiler - turns high-level language problem into an assembly language program Assembly language program  assembly language - a low-level programming language for a computer in which there is a strong correspondence between the language and the architecture's machine code instructions (e.g. MIPS, x86, 32b ARM)  Assembly languages are abstractions of machine languages  Assembly code is human-readable version of computer's native machine code  There are different assembly languages for different CPUs following different ISAs (each assembly language is tied to a particular ISA)  assembler - turns assembly language program into machine language program Machine Language Program (MIPS)

Memory sections stack - the portion of memory that stores variables that were declared inside functions (i.e. stores local variables and constants) local variables are freed when the function returns (these variables cannot be accessed once the function ends) Stack memory grows downward heap - the portion of memory that stores things that were created by malloc() Data on the heap persists across functions (unlike the local variables of stack memory) Heap memory grows upward static - the portion of memory that stores "pre-allocated" variables including static and global variables (variables declared outside functions), constants, and string literals  Two sections of static memory:  read-only (stores variables that can only be read and not modified) read-write (stores variables that can be both read and written to (modified)) Static memory does not grow or shrink code (text) - the portion of memory that stores the executable instructions and constants C

*p++ vs. (*p)++   *p++ means *(p++) ++ binds to p , not to *p ++ will increment "p," not "*p," which is the thing that "p" points to The value of the expression *p++ is the value that p pointed to before being incremented ( *p ) Two useful charts Pointer arithmetic notes (~pointer~) += (~number~);  means  (~pointer~) += ~number~) * sizeof((~type~)); Pointer arithmetic addition adds multiples of the type size to the memory address Ex. If p is a pointer to an integer, then p += 1 means p += 1 * sizeof(int)   (~pointer name~) + 1 points to the next object in memory (returns a pointer to the next element)  (~pointer name~) + i points to the i -th object beyond (~pointer name~) in memory  (~pointer name~) += i increments (~pointer name~) to point to i elements beyond itself  Types of valid pointer arithmetic Adding an integer to a pointer Subtracting 2 pointers (in the same array) Comparing poi

adversarial search problems - games In adversarial search, the agent maximizes utility rather than minimizing cost (which is done for standard search problems) Solution to adversarial search problem: strategy strategy  - the recommended best possible move given some configuration of the agent(s) and their opponent(s) game tree  - a tree where the nodes are game states and edges are moves Types of adversarial search problems zero-sum games  - deterministic, turn-taking, two-player games (pure competition between the two players) In zero-sum games, the sum of the utilities of the game agents is zero (i.e. equal and opposite utilities) stochastic games  - games with probabilistic outcomes cooperative games  - games in which players have common interests and utility function general games  - games in which agents have independent utilities (cooperation, indifference, competition, etc. are all possible) Components of an adversarial search problem initial state:

identification problem  - a problem in which the agent must identify whether it is a goal state or not, with no regards of how it arrives at that goal In identification problems, the goal itself it important, not the path of reaching the goal All paths have the same depth, which is the number of variables in the problem constraint satisfaction problem (CSP)  - an identification search problem in which each state must satisfy a number of constraints (limitations) in order to be a valid goal state In CSPs, states are partial assignments  of variables (i.e. some variables have been assigned values while others have not) constraint graph  - a graph whose nodes represent a CSP's variables and edges represent the constraints between the variables/nodes Components of a CSP variables - a set of $N$ variables ($X_1,...,X_N$) that can each take on a single value from the domain domain  - a set ${x_1,...,x_d}$ representing all possible values that a CSP variable can tak

Standard search problems Solution to a standard search problem: a plan Use a search algorithm  to find the plan and solve the search problem Search algorithms are performed on the search tree (of the problem) to find the solution to the search problem All search algorithms follow the same algorithm, but just use a different data structures for the fringe   Types of standard searches ➤  UNINFORMED SEARCH uninformed search  - a search that does not know information about the goal's location Types of uninformed searches Depth first search (DFS) - a search strategy that expands the deepest node first Implementation : uses a last-in-first-out (LIFO)  stack as the fringe Time complexity : $O(b^m)$, for a finite tree where $m$ is the maximum depth and $b$ is the branching factor Space complexity : $O(bm)$ DFS expands only the nodes on a single path from the deepest level to the root Breadth first search (BFS) - a search strategy in which the root is ex

What is an agent? agent - an entity that perceives and acts planning agent - an agent that make decisions based on (hypothesized) consequences of actions Planning agents simulate situations and performs/executes the best action according to its simulations done in the "planning" stage Planning agents consider how the world would be Planning agents must have a model of how the world evolves in response to actions Planning agents must formulate a goal (test) Planning agents are complete (i.e. they never get stuck and always find a solution, since the plan ahead) The agent does not actually perform all the plans out in the real world The planning is all done "in simulation" search agent - a planning agents that solves search problems Search problems search problem - a type of planning problem with the four components (listed below); the environment in which a rational planning agent exists in Search operates over models of the real world