Chapter 3 — Identifiers and Literals

Definition and role
An identifier is a name given to a program element such as a variable, function, array or class. It serves as a label through which the program can access stored data or a block of code. Identifiers give meaning to parts of a program and make code human-readable. Without identifiers, the programmer would not be able to refer to data or behaviour in a clear way.

How identifiers are used
When you declare a variable, you create an identifier that the program uses to store a value. For example, declaring a variable to hold a student's score gives a meaningful name that shows intent. Identifiers are used in statements, expressions and function calls. The same identifier can be read or assigned new values during program execution.

Scope and lifetime (simple view)
Identifiers have a scope — the area of the program where the name is visible. For example, a variable declared inside a function is visible only inside that function. Lifetime refers to how long the storage for the identifier lasts while the program runs.

Best practices
Choose meaningful names: use names that describe the purpose, like totalMarks instead of x. Keep names short but descriptive and follow a consistent style so others can easily understand your code.

Identifiers across program elements
Identifiers are not only for variables; functions, constants, classes, arrays and labels all use identifiers. For instance, a function that calculates the average may be named calculateAverage. Naming different elements clearly helps when reading program flow: you can quickly see where data is stored and where operations are performed.

Naming and readability
Good identifiers explain intent. When you see studentAge you immediately know what the data represents. Avoid meaningless names like a1, b2 except in short loops. In exam answers and assignments, choose clear identifiers so your logic is easier to follow and marks are not lost for unclear presentation.

Examples in code
When declaring variables you often write a type followed by an identifier and optionally an initial literal value. For example: int marks = 78; Here marks is the identifier and 78 is a literal. Later statements use the identifier: marks = marks + 2; The reuse of the identifier to refer to the same memory location is a core concept in programming.

Basic rules
Every programming language has rules for valid identifiers. Common rules include: an identifier must start with a letter (A–Z or a–z) or underscore (_); subsequent characters may include letters, digits (0–9) or underscores; identifiers cannot contain spaces or special characters like @, #, %, -, +; and they must not match reserved words of the language. Knowing these rules helps avoid syntax errors.

Length and characters
Some languages limit identifier length, but modern languages usually allow long names. Avoid beginning an identifier with a digit because the compiler or interpreter will treat it as a numeric literal. Using only underscore is usually allowed but not recommended for meaningful names.

Reserved words
Reserved words (or keywords) are part of the language grammar and cannot be used as identifiers. Examples include words like if, while, return in many languages. Attempting to use a reserved word as a variable name will cause an error.

Practice tip
When in doubt, test an identifier in your programming environment; the interpreter/compiler will point out illegal names. Use meaningful and valid names to reduce debugging time.

Detailed formation rules and examples
Most environments follow a common pattern for valid identifiers: the first character should be a letter (either case) or an underscore, while later characters can be letters, digits or underscores. For example, student1 and _temp are acceptable, whereas 2ndPlace is not because it starts with a digit. Identifiers cannot include characters like spaces, hyphens, commas or arithmetic symbols. In addition, some languages allow Unicode letters, enabling identifiers in other scripts; however, for ICSE class work stick to English letters, digits and underscores to avoid portability issues.

Leading underscores and special meanings
Some conventions use a leading underscore to indicate private or internal variables (for example _index). Certain libraries or language runtimes may reserve names with double underscores for internal use. It is a good habit to avoid creating identifiers that collide with language or library internal names.

Length limits and style guidance
While languages may permit very long identifiers, extremely long names make code hard to read. Aim for a balance: names should be descriptive but concise. Also, remember that names are case-sensitive in many languages, so studentMarks and studentmarks are different. Consistent, valid formation reduces errors and eases communication among developers.

What are reserved words?
Reserved words, also called keywords, are words that the programming language has set aside for special syntactic purposes. These words form the structure of the language and cannot be used for naming variables, functions or other identifiers. Examples include control words (if, else, while), data-type names (int, float) and other statements (return, break).

Why they are reserved
Keywords tell the compiler or interpreter how to parse the program. If you used a keyword as an identifier, the compiler could not distinguish between language structure and user-defined names. For clarity and to avoid confusion, languages block these words from use as identifiers.

Common lists and language dependence
Different languages have different sets of keywords. A word that is reserved in one language may be free in another. Always check the language documentation for the complete list. Learning common keywords early helps in reading and writing programs.

Categories of keywords
Keywords can be grouped by purpose: control-flow keywords (if, else, switch), loop keywords (for, while, do), declaration keywords (var, let, const, int, float), access and object-related keywords (class, public, private), and others that control program behaviour (return, break, continue). Understanding these groups helps you recognise why a word cannot be repurposed as an identifier.

Examples and classroom relevance
Try declaring a variable with a keyword and observe the compiler error: int int = 5; will not work because int is used both to declare a type and is reserved. In exams, students should not attempt to use reserved words as names; doing so shows a lack of understanding of language syntax.

Workarounds and naming choices
If a word you want to use is a keyword, modify it slightly to create a valid identifier: instead of class use classInfo or className. Avoid names that are visually similar to keywords to reduce confusion. Also be aware of new keywords added in language updates which may make previously valid identifiers forbidden later.

Meaning of case sensitivity
Case sensitivity means that uppercase and lowercase letters are considered different when comparing identifiers. In case-sensitive languages, Score, score and SCORE refer to three separate identifiers. In case-insensitive languages, they would be treated as the same name. Students must know whether the language they use is case-sensitive to avoid bugs.

Common practice
Many modern languages are case-sensitive. This allows programmers to use conventions like capitalising class names and starting variable names with lowercase. Remember that reserved words are also subject to case rules — writing If instead of if may be treated as a different identifier rather than the keyword.

Problems caused by case errors
Typographical differences in case lead to runtime or compile-time errors that can be hard to spot. For example, assigning to variable Total and later reading total will either produce an error or use a different, uninitialised value. Always use consistent names and consider tools or editors that highlight identifiers to reduce mistakes.

Naming conventions tied to case
Conventions make use of case rules: camelCase (first word lowercase, next words capitalised) is popular for variables and methods, while PascalCase (every word capitalised) is common for class or type names. Constants often use UPPER_CASE to stand out. These styles rely on languages being case-sensitive to create readable code structure.

Practical advice
Adopt a naming style: camelCase for variables (studentName), PascalCase for types (StudentRecord), UPPER_CASE for constants. Stick to the conventions used in your class or project. When debugging, search for all uses of an identifier to ensure case matches everywhere.

Exam and classroom tips
In answers and code on tests, be precise with case: marksScored and Marksscored are not the same. Use consistent capitalization throughout your program and check for errors when copying names from one place to another. Familiarity with case rules reduces simple mistakes and saves time during corrections.

What is a literal?
A literal is a fixed value written directly in the source code. It tells the computer to use that exact value. Examples include numbers like 42, text inside quotes like "Hello", a single character like 'A', and boolean values true or false. Literals contrast with variables which can change during program execution.

Main literal categories
1) Integer literals: whole numbers without a decimal point, e.g., 0, 7, -15.
2) Real (floating-point) literals: numbers with a decimal point or in exponential form, e.g., 3.14, -0.5, 2.0e3.
3) Character literals: single characters enclosed in single quotes, e.g., 'a', '9', '\n'.
4) String literals: sequence of characters within double quotes, e.g., "Hello".
5) Boolean literals: true and false represent truth values.

Literal usage
Literals appear in assignments, expressions and function calls. They are immediately understood by the compiler as values of some type. For example, x = 10 assigns the integer literal 10 to variable x. Using correct literal format prevents syntax errors.

Care with representation
Be careful with quotes and escape sequences inside string or character literals. For instance, to include a double quote inside a string, use an escape like \" in many languages. Know the exact rules of your language for character and string literals.

Choosing the correct literal type
When writing code, pick literals that match the type you need. Use integer literals for counts and indices, real literals for measurements and averages, character literals for single symbols and string literals for text. Boolean literals are used in conditions and flags. Selecting the right form prevents type mismatch errors and makes intent clear to readers and compilers.

Literal interpretation and storage
Each literal has a type the compiler recognises: integers are stored in integer types, reals in floating types, characters in char types and strings in string types. The exact storage size depends on the language and platform. For simple school programs, assume standard sizes and focus on correct usage and representation.

Practical examples
Common uses include: int age = 16; double price = 49.99; char grade = 'A'; String name = "Amit"; boolean isOpen = true. Mixing up quotes or using wrong notation causes errors, so practice writing different literal types correctly.

Definition
Integer literals represent whole numbers without a decimal part. They can be positive, negative or zero. The simplest forms are base-10 numerals such as 0, 1, 25, -7. Some languages allow other bases like binary (prefix 0b), octal (prefix 0o or leading zero in older languages) and hexadecimal (prefix 0x) — check your language rules.

Range and size
The range of integer literals depends on the data type that will store them (for example, short, int, long). If a literal is too large for the type, the compiler will either promote it or give an error. For classroom problems, we usually use values that fit typical integer ranges.

Underscores and readability
Some languages allow underscores inside integer literals to group digits for readability, like 1_000_000 to represent one million. This does not change the value; it is only a formatting aid supported in newer languages.

Common pitfalls
Leading zeros may be interpreted as octal numbers in some languages, causing unexpected values. A number like 09 may be invalid in such a language. Always use the plain decimal form unless you need a specific base.

Integer literal forms and prefixes
Decimal integers use digits 0–9. Hexadecimal uses 0–9 and A–F with prefix 0x (e.g., 0x1F). Binary uses 0 and 1 with prefix 0b (e.g., 0b1010). Octal historically used a leading zero but modern code prefers 0o prefix to avoid mistakes. Be careful: different forms are useful for tasks like bit manipulation or working with colours.

Practical classroom uses
Integer literals are used to set loop counters, array sizes and fixed values like maximum marks. For example: int maxStudents = 30; for (int i = 0; i < 30; i++) { ... } Using integer literals correctly prevents index errors and off-by-one mistakes common in loops.

Definition and form
Real or floating-point literals represent numbers with a fractional part. They include a decimal point or use exponential notation. Examples: 3.5, -0.001, 2.0e3 (which means 2.0 × 10^3 = 2000). Floating-point literals are stored in types like float or double, which hold approximate real numbers using binary fractions.

Precision and accuracy
Floating-point types have limited precision. Not every decimal number can be represented exactly in binary; small rounding errors can occur. For classroom work, understand that operations on floating-point numbers may result in tiny differences from exact mathematical results. This affects equality checks; prefer comparisons using a small tolerance (epsilon) rather than direct equality for floats.

Notation
Use a decimal point even when the fractional part is zero if you want a real literal: 2.0 is a real literal while 2 is an integer literal. Exponential notation uses e or E: 5.12E-3 means 0.00512. Some languages allow suffixes like f or F to mark a float literal distinct from double.

Storage and range
Float and double differ in precision and range: float typically stores about 7 decimal digits of precision while double stores about 15. Choose the type suited for the needed accuracy. For most school programs double is sufficient for common calculations, but be aware of potential differences when very large or very small numbers are used.

Common classroom issues
A common mistake is assuming decimal arithmetic is exact. For example, 0.1 + 0.2 may not equal 0.3 exactly in floating-point representation. Avoid relying on exact float equality; instead, check if the absolute difference is smaller than a chosen epsilon, e.g., |a - b| < 1e-6.

When to use
Use floating-point literals for measurements, averages, percentages or any value needing fractions. Avoid using floating-point for exact counts or where precise arithmetic is required (money calculations prefer fixed-point or special libraries). Always format output sensibly (for example, rounding to two decimal places for currency presentation).

Characters
Character literals are single symbols enclosed in single quotes, like 'A' or '5'. They represent a single character and are stored in a character type. Special characters such as new line or tab are represented by escape sequences like '\n' and '\t'. To represent the single quote character itself, use the escape '\'' inside a character literal.

Strings
String literals are sequences of characters enclosed in double quotes, for example "Hello". Strings represent text and are used for user messages, names and other textual data. Strings may include spaces and punctuation. Escape sequences also work inside strings to represent otherwise special characters.

Immutability and mutability (basic idea)
In many languages strings are immutable, meaning their content cannot change after creation; operations produce new strings. Other languages provide mutable string objects. For Class 9, treat strings as a value representing text to be used, compared and concatenated.

Concatenation and length
You can join strings using a concatenation operator or function, for example "Hello" + " World". The length of a string counts its characters; special escape sequences may count as a single character depending on how they are stored. When concatenating different types, many languages implicitly convert non-string types to string; explicit conversion functions are clearer and safer.

Special characters and encoding
Be aware of character encoding issues when using characters beyond basic English letters. Unicode supports many scripts, but for classroom work prefer ASCII-compatible characters to avoid surprises. Use escape sequences for control characters and to include quotes inside strings safely.

Practical examples
Strings are used to read and display data: String name = "Priya"; System.out.println("Hello, " + name); Character literals are often used to store grades, single symbols or to process characters in loops. Combining these correctly is an essential skill for handling textual data in programs.

Definition
Boolean literals represent truth values and are usually written as true and false. They are used in conditions, comparisons and logical expressions. A boolean literal is not a number or string; it is a special type used to control program flow.

Use in decisions
When you write if (isRaining) or while (finished == false), the boolean values of expressions determine whether a block of code runs. Comparisons such as 5 > 3 produce boolean results that can be stored in boolean variables or used directly.

Combining boolean values
Logical operators like AND, OR and NOT combine boolean expressions. For example, isAdult AND hasTicket means both conditions must be true. Understanding boolean literals helps you test conditions and design correct decision-making in programs.

Truth tables (simple)
Learn basic truth tables: true AND true = true, true AND false = false, true OR false = true, NOT true = false. These rules guide how complex conditions behave and help in simplifying logical expressions.

Boolean variables and flags
Boolean variables often act as flags to indicate states, such as isLoggedIn or hasPassed. Use clear names starting with is or has for readability. Boolean literals often appear when initialising such flags: boolean verified = false; Later code updates the flag based on events and checks it in decisions.

Practical tip
Use boolean literals and variables for flags, success/failure checks, and condition results. Avoid using numbers directly as truth values unless the language defines that behaviour, because it reduces code clarity and can cause errors during maintenance or when switching languages.

What are constants?
Constants are identifiers whose values do not change during program execution. They are used when a value must remain fixed, like PI = 3.14 or MAX_LIMIT = 100. Declaring a constant helps prevent accidental modification and makes code easier to maintain.

Defining constants
Most languages provide a way to declare constants, such as using const or final keywords or using enumerations. The syntax varies, but the idea is the same: give a meaningful name and assign a literal value that stays constant.

Why use constants?
Constants make programs clearer because names explain purpose. They simplify updates; change the value in one place and the entire program uses the new value. Constants reduce magic numbers in code, which are unexplained numeric literals scattered around the program.

Constants vs literals
A literal is the actual value written in code (like 100), while a constant is a named identifier that refers to that literal (like MAX_SCORE). It is good practice to give important literals constant names.

Naming conventions
Constants are often written in uppercase with underscores between words, such as MAX_SPEED or DEFAULT_TIMEOUT, to distinguish them from regular variables. This visual difference alerts anyone reading the code to the unchanging nature of the value.

When to use
Use constants for configuration values, limits, conversion factors and other values that should not change. Examples include PI for circle calculations, MAX_ATTEMPTS for login tries, and TAX_RATE for fixed tax percentages used across a program. Using constants improves clarity and reduces errors caused by accidental changes.

Purpose of conventions
Naming conventions are agreed styles for writing identifiers that make code consistent and easier to read. They do not change how the program runs but help programmers understand code quickly, which is important in teams and examinations.

Common conventions
1) camelCase: start with a lowercase letter and capitalise subsequent words (studentName, totalMarks). Often used for variables and methods.
2) PascalCase: capitalise the first letter of each word (StudentRecord). Often used for classes or types.
3) UPPER_CASE: constants are often written in uppercase with underscores (MAX_COUNT).
4) underscores: some prefer snake_case for variable names (student_name).

Good practices
Choose meaningful names, avoid single-letter names except in loops (i, j), do not use abbreviations unless commonly known, and keep names neither very long nor very short. For example, use averageMarks rather than a or avgMk which may be unclear.

Internationalisation and readability
Avoid non-English letters or special characters in identifiers. Use English words so code is widely understandable. Also, use proper spacing and comments to explain complex logic rather than relying solely on names.

Consistency
Stick to one style within a program or project. Teachers may expect a particular style in class; follow that for assessments. When working in teams, adopt the project's style guide to maintain uniformity and reduce confusion.

Practical examples and decisions
Decide conventions early: for example use camelCase for variables and PascalCase for classes. Document decisions in project notes or comments at the top of files so everyone knows the expected style. Readability saves time during debugging and improves the chances of correct, well-structured solutions in exams.

Allowed special characters
Many languages permit underscore _ in identifiers and treat it as a normal character. Some languages also allow dollar sign $ (commonly seen in certain environments). Other special characters like @, #, !, -, + are generally not allowed because they have other meanings in the language.

Use of underscore
The underscore is often used to separate words in names (snake_case) or to start private or special identifiers. A single underscore as a name is usually allowed but not descriptive. Avoid using leading underscores when they have special meaning in the language or libraries.

Why avoid other special characters
Characters such as hyphen (-) conflict with the minus operator; spaces separate tokens; punctuation may be parsed differently. Using only letters, digits and underscores reduces errors and improves portability across languages and tools.

Examples of language differences
Some languages allow $ for generated or internal names. Others explicitly reserve such characters for special purposes. Always check language rules before using non-letter characters in identifiers.

Practical advice
Prefer underscores and letters. Do not use characters that may not be portable or that confuse readers. Maintain readability and follow class conventions. Avoid starting identifiers with characters that have special meaning in frameworks or libraries used by the language.

Special-case conventions
Some coding styles use a leading underscore to mark private members, or double underscores for special system names. JavaScript historically allows $ in identifiers and uses it in libraries like jQuery. Understand your language's conventions before adopting a special character in names.

What are escape sequences?
Escape sequences are special combinations of characters used inside character or string literals to represent characters that are hard to type or have special meaning. They begin with a backslash \ followed by a character. For example, \n represents a newline, \t a tab, \' a single quote and \" a double quote inside a string.

Why they are needed
Without escapes, including quotes inside a string would end the string unintentionally. Also, some characters like newline are not visible as single characters in source code; escape sequences let you include them in text values.

Common escape sequences
\n (newline), \t (tab), \\ (backslash), \' (single quote), \" (double quote). Some languages support more escapes like \r (carriage return) or \uXXXX for Unicode code points.

Usage examples
To print a path like C:\Users\Name you must escape backslashes: "C:\\Users\\Name". To write "He said \"Hello\"" use "He said \"Hello\"". Escape sequences are essential when building strings that include special punctuation or control characters.

Raw strings and alternatives
Some languages offer raw string literals where backslashes are treated as ordinary characters, which simplifies writing patterns with many backslashes such as regular expressions or file paths. For class work, learn the standard escape sequences and use raw strings only if taught in your language course.

Common errors
Forgetting to escape special characters or using wrong escape notation leads to syntax errors or unexpected output. If a string does not compile, check for missing escapes, incorrect quotes, or unsupported escape forms. Always test strings that include both quotes and backslashes carefully.

Multiple bases
Numeric literals can be written in bases other than decimal. Binary (base 2), octal (base 8) and hexadecimal (base 16) are useful in low-level programming and when working with colours, flags or bitwise operations. Each base has a common prefix in many languages: 0b for binary, 0 for octal (in older languages) and 0x for hexadecimal.

Binary
Binary literals use only 0 and 1. Example: 0b1010 represents decimal 10. Binary is convenient for understanding bits and masks. It shows clearly which bits are set and is used when working directly with hardware or bit-level algorithms.

Octal
Octal uses digits 0–7. Historically a leading zero indicated octal, for example 075 equals decimal 61. This convention can be a source of bugs if unintended; modern languages often use explicit 0o prefix for clarity. Use octal when dealing with file permissions or legacy code that uses this base.

Hexadecimal
Hex uses digits 0–9 and letters A–F to represent values 10–15. Example: 0xFF equals decimal 255. Hex is widely used for memory addresses and RGB colour codes. It is more compact than binary and easier to read for humans when dealing with bytes and words.

Conversions and classroom practice
Practice converting between bases: hexadecimal to decimal, binary to decimal, and vice versa. Use place-value understanding: each hex digit represents a power of 16, each binary digit a power of 2. Tools and calculators can help, but manual conversion reinforces understanding of how numbers are represented in different bases.

When to use
Use these formats when working with binary data, bitwise operations, or where a compact representation of values is needed. For everyday calculations, decimal is simpler. Always include the correct prefix so the compiler interprets the literal in the intended base.

Purpose of suffixes
Many languages allow type suffixes on numeric literals to force a specific data type. For example, adding L to a number may indicate a long integer, or f to indicate a float rather than a double. Suffixes tell the compiler the intended type of the literal so operations use the correct precision and range.

Common suffixes
Examples include: 100L or 100l for long, 3.14f or 3.14F for float, and sometimes u or U for unsigned. Syntax varies by language so learn the rules for the language you use in class.

Why they matter
Using correct suffixes avoids unintended type promotions or loss of precision. For example, dividing two integers may produce integer division; making one operand a float by using a suffix leads to floating-point division and a fractional result.

Examples of effects
Consider 2 / 3: if both are integer literals the result is integer division and may be 0. If written 2.0 / 3 or 2 / 3.0 or 2.0f / 3f, the operation is floating-point and yields approximately 0.6667. Using suffixes ensures literals behave as expected in mixed-type expressions.

Classroom guidance
When assignments or function parameters expect a particular type, use suffixes to match types and to avoid implicit casts. For large integer values that do not fit in default integer range, append the long suffix. For single-precision float operations use the float suffix if the language requires it.

Language specifics
Suffix rules and available types depend on the language and its version. Always consult your class notes or language reference for exact suffixes and behaviours. Relying on clear suffix usage avoids many common type-related bugs in programs.

Syntax errors
Common errors include using invalid characters in identifiers (like spaces or hyphens), starting an identifier with a digit, or attempting to use a reserved word as a name. With literals, missing quotes, wrong escape sequences, or incorrect numeric formats (like 09 in octal) lead to compile-time errors.

Type errors
Assigning a literal of the wrong type to a variable can cause errors or incorrect behaviour. For example, assigning a string literal to an integer variable or a floating literal to an integer without casting will cause problems. Be mindful of required conversions.

Logical errors
Using incorrect literals may produce logically wrong results even if code compiles. For example, using 3.14 for PI instead of a more accurate value can affect calculations, or accidentally swapping a string literal with a variable name will change outputs.

Runtime issues
Improperly escaped strings can lead to unexpected output or runtime failures. Also, using literals that exceed the allowed range for the data type may cause overflow or exceptions.

Common exam mistakes
Students often mistake variable names by case differences, reuse reserved keywords as identifiers, forget to close quotes, or misuse escape sequences. Carefully reading error messages and matching exact lines of code to the problem usually finds these errors quickly.

Debugging tips
Read error messages carefully, check the exact place the compiler points to, verify identifier spelling and case, ensure quotes and escapes are correct, and test with simple values to isolate the problem. Breaking down complex expressions into smaller parts can reveal which literal or identifier causes the issue.

Assignments
Literals are often used to give initial values to variables. For example, int age = 15; assigns the integer literal 15 to age. String greetings = "Hello" stores a textual literal. Correct literal type must match or be convertible to the variable's type.

Expressions
Literals can appear inside arithmetic and logical expressions, such as total = score + 5 or average = (sum + 0.0) / count to force floating-point division. Combining literals and variables allows you to compute results directly in code.

Type mixing
When expressions mix integers and floating-point literals, type promotion rules apply: usually integers are converted to floating point for the operation. Be aware of these rules to get the expected result (for example, integer division versus floating-point division).

Operator precedence
When using literals in complex expressions, remember operator precedence and use parentheses to make intentions clear: 2 + 3 * 4 equals 14, but (2 + 3) * 4 equals 20. Use parentheses to avoid surprises.

Constants vs literals in expressions
Rather than scattering literals into expressions, use named constants for important values. For example average = total / (double)MAX_STUDENTS reads clearer than average = total / 30. Constants improve readability and make maintenance easier when values change.

Practical examples
Use literals to test functions, set constants for calculations and write clear expressions. Replace magic numbers with named constants for readability and correctness. Practice writing sample expressions and tracing their evaluation to build confidence with precedence and type promotion rules.

Choose clear names
Select identifiers that explain purpose: totalMarks is better than t or x. Use verbs for functions (calculateAverage) and nouns for variables (studentName). Clear names make code self-documenting and reduce the need for extra comments.

Avoid magic numbers
Do not scatter unexplained numeric literals throughout code. Instead, assign them to named constants with descriptive names (e.g., MAX_ATTEMPTS = 5). This makes the code easier to update and understand.

Keep consistency
Follow a consistent naming convention (camelCase, PascalCase or UPPER_CASE) across the program. Consistency helps when several students or developers read and maintain the code.

Minimise long literals
If a literal is used many times, use a constant. For long strings, consider breaking them or storing them in named variables. For precise numerical work, avoid using floating literals where exact arithmetic is needed.

Comment where needed
If an identifier or literal may not be obvious, add a short comment to explain intent. But prefer meaningful names so comments are minimal and focused on why rather than what the code does.

Review and refactor
After writing code, review identifiers and literals: rename unclear names, extract repeated literals into constants and ensure naming style is consistent. Refactoring improves readability and reduces errors, making programs easier to grade and maintain.