Student Grading System

Overview

Real student data is never perfectly complete — a mark might genuinely not exist yet because a student has not sat an exam, transferred in mid-term, or been granted a deferral. Kotlin's type system makes that distinction explicit at compile time: `val marks: Int` can never be missing, but `val marks: Int?` can, and the compiler will not let you use a nullable value as if it were guaranteed to exist without first proving you have handled the `null` case. That single character, `?`, is the difference between a `NullPointerException` waiting to happen and a program the compiler has already verified is safe.

By the end of this tutorial you will have a console application that processes a list of `Student` records with genuinely nullable `marks: Int?`, converts each present score into a letter grade with a `when` expression over a range, and reports "No marks recorded" for anyone still missing a score — all without a single manual null check written as `if (x != null)`. Instead you will use Kotlin's safe-call operator `?.`, the elvis operator `?:`, and the scope function `let` together, which is the idiomatic combination for "do something with this value only if it exists, otherwise fall back to a default."

Prerequisites

Project Structure

The whole program lives in a single file, `StudentGradingSystem.kt`, containing one data class, `Student`, three top-level functions (`gradeFor`, `gradeSummary`, `classAverage`), and `fun main()`. Keeping `gradeFor` and `gradeSummary` as free functions rather than methods on `Student` is a deliberate choice: `Student` itself stays a pure, minimal data holder, while the grading logic — which could plausibly change independently of what a student record even looks like — lives separately and is easy to test or swap out on its own.

Step 1: Define the Student Data Class With Nullable Marks

The key design decision in this whole project is `val marks: Int?` instead of `val marks: Int`. That trailing `?` is not decoration — it changes `marks`'s type to "either an `Int`, or the absence of one," and from this point forward the Kotlin compiler refuses to compile any code that treats `student.marks` as a plain `Int` without first narrowing it, forcing every later step to deal with the missing case explicitly instead of letting it slip through as an accidental crash.

// marks is Int? (nullable), not Int, because a real student roster can have
// students who have not been marked yet — the type itself documents that a
// missing score is an expected, ordinary case, not an error condition.
data class Student(
    val name: String,   // Student's full name
    val marks: Int?      // Nullable: null means "no marks recorded yet" for this student
)

Step 2: Map a Score to a Letter Grade With when

`gradeFor()` takes a plain, non-nullable `Int` — by the time a score reaches this function, the caller in Step 3 will already have proven it is not null, so `gradeFor` itself never has to think about nullability at all. The `when` expression matches ranges with the `in` operator, and because every branch returns a `String`, the whole `when` block evaluates to a `String` that the function can return directly with Kotlin's single-expression `= when (...) { ... }` syntax.

// A single-expression function: the body is one when expression, so "=" is
// used instead of a { return ... } block. score is a plain Int here, never
// nullable — by the time this is called, the caller has already handled null.
fun gradeFor(score: Int): String = when (score) {
    in 90..100 -> "A"    // "in" tests range membership; matches 90 through 100 inclusive
    in 80..89 -> "B"
    in 70..79 -> "C"
    in 60..69 -> "D"
    in 0..59 -> "F"
    else -> "Invalid"     // Anything outside 0-100 is not a real percentage score
}

Step 3: Handle Missing Marks With Safe Calls and Elvis

`gradeSummary()` is where the null-safety idiom comes together in one line: `student.marks?.let { gradeFor(it) }` only runs the lambda — and only calls `gradeFor(it)` — when `student.marks` is non-null; if it is `null`, the whole `?.let { }` expression short-circuits to `null` without ever calling `gradeFor`. The `?:` (elvis operator) immediately after supplies what to use instead when that happens: `"No marks recorded"`. Together, `marks?.let { gradeFor(it) } ?: "No marks recorded"` reads almost like the English sentence it represents, and there is no `if (marks != null)` anywhere in it.

fun gradeSummary(student: Student): String {
    // ?. (safe call): only enters the lambda if marks is non-null.
    // let { }: runs the lambda with "it" bound to the non-null Int.
    // ?: (elvis): supplies the fallback string when the left side was null.
    val grade = student.marks?.let { gradeFor(it) } ?: "No marks recorded"
    return "${student.name}: $grade"
}

Step 4: Summarize a Class of Students

`classAverage()` needs to compute an average over only the students who actually have marks, silently excluding anyone with `null`. `students.mapNotNull { it.marks }` does exactly that in one call: it maps each student to their `marks`, then drops every `null` result, leaving a plain `List<Int>` with no nullability left to worry about at all. `average()` on an empty list returns `Double.NaN` rather than throwing, so the function still guards the empty-list case explicitly for a cleaner "N/A" result.

fun classAverage(students: List<Student>): Double? {
    val scores = students.mapNotNull { it.marks }   // Keeps only the non-null marks; nulls are silently filtered out
    if (scores.isEmpty()) {
        return null                                    // No marked students at all; the caller decides how to display that
    }
    return scores.average()                            // average() over a confirmed non-empty List<Int>
}

Step 5: Build the Program Entry Point

`main()` builds a small hard-coded roster mixing students who have marks with one who does not, then prints a summary line per student with `gradeSummary()` from Step 3, followed by the class average from Step 4 — using the same `?.let { } ?: ` pattern one more time to format a `Double?` only when it is actually present.

fun main() {
    val roster = listOf(
        Student("Ananya Rao", 88),
        Student("Vikram Shah", null),        // No marks recorded for this student yet
        Student("Priya Nair", 95),
        Student("Rohan Verma", 42),
    )

    println("===== STUDENT GRADING SYSTEM =====")
    for (student in roster) {
        println(gradeSummary(student))         // Reuses Step 3's null-safe summary for every student, uniformly
    }

    val average = classAverage(roster)
    // Formats the average only if one could be computed; falls back to "N/A" otherwise, same ?.let/?: idiom as Step 3
    println("\nClass average: ${average?.let { "%.2f".format(it) } ?: "N/A"}")
}

Complete Code

Here is the full program with every declaration assembled in the correct order, ready to save as `StudentGradingSystem.kt` and run with `kotlinc StudentGradingSystem.kt -include-runtime -d grading.jar && java -jar grading.jar`.

data class Student(
    val name: String,
    val marks: Int?
)

fun gradeFor(score: Int): String = when (score) {
    in 90..100 -> "A"
    in 80..89 -> "B"
    in 70..79 -> "C"
    in 60..69 -> "D"
    in 0..59 -> "F"
    else -> "Invalid"
}

fun gradeSummary(student: Student): String {
    val grade = student.marks?.let { gradeFor(it) } ?: "No marks recorded"
    return "${student.name}: $grade"
}

fun classAverage(students: List<Student>): Double? {
    val scores = students.mapNotNull { it.marks }
    if (scores.isEmpty()) {
        return null
    }
    return scores.average()
}

fun main() {
    val roster = listOf(
        Student("Ananya Rao", 88),
        Student("Vikram Shah", null),
        Student("Priya Nair", 95),
        Student("Rohan Verma", 42),
    )

    println("===== STUDENT GRADING SYSTEM =====")
    for (student in roster) {
        println(gradeSummary(student))
    }

    val average = classAverage(roster)
    println("\nClass average: ${average?.let { "%.2f".format(it) } ?: "N/A"}")
}

Sample Run

Extend This Project

Summary

You built a student grading system where a nullable `Int?` makes "no marks yet" a case the compiler forces you to handle, not a runtime surprise, and the combination of `?.`, `let`, and `?:` let you express that handling in a single readable line instead of an `if (x != null)` block. The `when`-over-a-range pattern in `gradeFor()` and the `mapNotNull` filtering in `classAverage()` are both idioms you will reach for constantly in Kotlin — anywhere you need to classify a value into buckets, or anywhere a collection can contain nulls you need to safely ignore.