This glossary defines common terms used in our class. Most are split up by the week they are introduced, though you can skip to course-specific terms for acronyms and words that are about our class itself (rather than computer science concepts).

This glossary is a new experimental resource! We’d love to hear from you with questions, suggestions, or concerns. Post on Ed!

Week 1: Java Basics; Printing, Strings, and Variables¶

• bug: an error in a program
• class*: a file in Java where code is written
  • Note: all code you write in CSE 121 goes into one class
• class comment: a comment that explains a program and its general functionality
• comment: text in a code file that does not affect the behavior of a program
• compiler: a program that translates a programmer's instructions into a form that is more usable by a computer
• console: the place where a program's printed output appears
• debugging: the process of finding and fixing bugs
• executes/runs: when a computer reads a set of instructions written in code and performs them
• hardcode: the practice of placing fixed, unchangeable values directly into code that cannot be modified without modifying the program
• header comment: a comment at the top of a program that includes your name, the date you wrote the program, the class, the assignment, and your TA's name.
• print: display text to the console
• String: represents a collection of letters, digits, or other characters that are strung together
• whitespace: a term to describe characters that are 'invisible' on a screen, such as spaces, tabs, and new lines

Week 2: Data Types and Expressions; String Methods, char, and Variables¶

Data Types, Expressions, Operators¶

• boolean: a data type that represents either true or false
• char: a data type that represents a single character
• double: a data type that represents decimal numbers
• expression: a combination of values and operators that evaluates to a single value
• int: a data type that represents whole numbers
• logical operators: a symbol used to evaluate an expression to true or false (ex &&, ||, !)
• modulo (mod): an operation that finds the remainder of division (%)
• operator: a symbol that performs an operation on a value or variable (ex +, /, %, &&)
• PMMDAS (a simplified order of operations):
  • P - parenthesis
  • MMD - modulo, multiplication, or division, whichever comes first (left to right)
  • AS - addition or subtraction, whichever comes first (left to right)
• precedence: the order in which subexpressions of an expression are evaluated
• relational operators: a symbol used to compare two values and evaluate an expression to either true or false (ex ==, <, >=)
• subexpression: a portion of an expression that can be evaluated independently
• type: the kind of data specified for a value (ex: int, double, String)
  

Variables, Strings, Debugging¶

• assignment: a way to assign a value to a variable
• case-sensitive: distinguishes between uppercase and lowercase letters
• case-insensitive: does not distinguish between uppercase and lowercase letters
• declaration: a way to define a variable with a name and a data type
• index (pertaining to a String): the numerical position of a character in a String
• initialization: a way to store a value into a variable for the first time
• passing in: referring to the argument passed into the parentheses
• primitive: a type that is directly built into Java that always begin as a lowercase letter (ex int, boolean, char, double)
• substring: a portion of characters in a String, defined by a specific starting and ending position
• variable: gives a name to a specific value
• zero-based indexing: the first character in a String is assigned an index of 0 (not 1)

Week 3: for Loops and Nested for Loops; the Random Class¶

for Loops and Nested for Loops¶

• block: the code between two curly braces
• fenceposting: a programming technique used to handle scenarios where the first or last iteration of a loop requires special handling, such as avoiding extra characters or operations. Similar to building a fence with wires separated by posts, we want the fence to start and end with a post to avoid having an extra dangling wire at the end.
  • Let's say we want to print "p-i-c-k-l-e-b-a-l-l" To prevent printing “-p-i-c-k-l-e-b-a-l-l”, we can use fenceposting. First, print out the p. Next, starting at the second character in the String, print a dash and the character, one after the other, for every character in the String.

          
            String word = "pickleball";
            System.out.print(word.charAt(0));
    
            for (int i = 1; i < word.length(); i++) {
              char letter = word.charAt(i);
              System.out.print("-" + letter);
            }
          
        

• for loop: a programming construct that repeats lines of code a set number of times
• infinite loop: a loop that does not stop because the condition required for it to end is never met
• iterate: the act of repeating a process or set of steps until a condition is met, often within a loop
• iteration: a single instance of a repeated process
• nested for loop: a for loop placed inside another for loop; used when we need to repeat a task (inner loop) multiple times within another repetition (outer loop)
• scope: the ability for different variables to be accessed, altered, and utilized within a particular part of a program; variables are typically only in scope within the curly braces that they were created inside
• String traversal: the process of accessing and processing each character in a String one by one

Random Class¶

• object*: a complex value that is typically created with the new keyword (in contrast to simple literal values) (ex Random)
• pseudorandom numbers: a sequence of numbers that appear random, but are actually generated by mathematical formulas and algorithms
• pseudorandom number generator: a computer algorithm that generates pseudorandom numbers
• seed: a starting value used within the initialization of a pseudorandom number generator

Footnotes¶

* This is a topic that is not covered deeply in CSE 121. However, you’ll revisit this idea in-depth in CSE 122 & 123.

Acknowledgements¶

This iteration of the glossary was developed by Hannah Swoffer, Maitreyi Parakh, and Sushma Shankar. This is based on a prior glossary written by Hannah Swoffer and Trey Adams.