Assessment Rubric

Assessment Rubric

This course is not graded by memorizing Java syntax. Assess whether learners can read, reason about, and safely modify Java code.

Lesson 1: Advanced OOP

Skill	Developing	Proficient	Strong
Records and invariants	Can identify record fields.	Can explain constructor validation and immutable data use.	Can choose between record, class, and enum for a new domain concept.
Interfaces and sealed types	Can call interface methods.	Can explain permitted implementations and polymorphic dispatch.	Can add behavior while preserving a sealed hierarchy's design intent.
Generics and collections	Can read `List<T>`.	Can explain bounded generic types in `Order<T extends LineItem>`.	Can justify when generic flexibility is useful or unnecessary.
Exercise functions	Can make code compile.	Implements totals, optionals, shipping, tax, sorting, and grouping correctly.	Explains validation boundaries, rounding, deterministic ordering, and duplicate aggregation.

Lesson 2: Decorators

Skill	Developing	Proficient	Strong
Wrapper flow	Can identify the wrapped object.	Can trace call order through multiple decorators.	Can predict how changing wrapper order changes output.
Object vs function decorators	Recognizes both styles.	Can implement both object and lambda wrappers.	Can explain when a pipeline is clearer than nested decorators.
Java I/O decorators	Can instantiate a `BufferedReader`.	Can explain stream-to-reader layering.	Can design a small resource-safe wrapper using try-with-resources.
Exercise functions	Adds simple prefix behavior.	Implements transforms, audit, blocklist, truncation, counting, and composition.	Predicts how wrapper placement changes side effects and short-circuit behavior.

Lesson 3: Multi-Threading

Skill	Developing	Proficient	Strong
Executors and futures	Can submit a task.	Can collect results and close an executor.	Can choose a pool style based on workload shape.
Shared state	Recognizes a race condition.	Uses immutable results or atomics safely.	Can redesign a shared-state solution into result aggregation.
Async pipelines	Can run a `CompletableFuture`.	Can explain `supplyAsync` and `thenApply`.	Can identify where error handling or cancellation is missing.
Exercise functions	Produces correct word counts.	Uses parallel tasks, deterministic merge behavior, top-N ranking, stop-word filtering, and ordered results.	Discusses overhead, exact token semantics, failure handling, and when sequential code is better.

Lesson 4: Toy Edge Library

Skill	Developing	Proficient	Strong
Image representation	Understands pixels as numbers.	Can map `BufferedImage` to a grayscale matrix.	Can explain boundary handling and value clamping.
Convolution	Can read a kernel.	Can trace a 3x3 kernel over an image.	Can add a new filter and reason about output scale.
Sobel edges	Recognizes horizontal and vertical gradients.	Can explain magnitude calculation.	Can discuss preprocessing tradeoffs such as blur before edge detection.
Exercise functions	Implements simple clamp.	Implements pixel conversion, normalization, blending, Sobel magnitude, and boundary sampling correctly.	Handles validation, numerical rounding, packed color values, and edge sampling tradeoffs clearly.

Lesson 5: Java `@` Annotations

Skill	Developing	Proficient	Strong
Built-in annotations	Can identify `@Override` and `@Deprecated`.	Can explain compiler-checked versus runtime-visible annotations.	Can choose narrow annotation scope and explain tool/runtime effects.
Custom annotations	Can read `@interface`.	Can explain annotation elements, defaults, `@Retention`, and `@Target`.	Designs annotation metadata that is simpler than equivalent boilerplate.
Reflection	Can call `getAnnotation`.	Reads class, method, repeatable, package, record, and type-use annotations correctly.	Explains why retention and target determine what reflection can see.
Framework-style metadata	Recognizes decorator and getter/setter annotations.	Explains that metadata needs a framework or annotation processor to create behavior.	Can distinguish metadata-driven design from explicit method calls.

Lesson 6: Spring Boot Hello World

Skill	Developing	Proficient	Strong
Boot startup	Can run the app.	Explains `SpringApplication.run`, the application context, and the embedded server.	Can separate Boot startup concerns from application behavior.
Web routing	Can identify `@GetMapping`.	Traces query parameters and JSON request bodies into controller methods.	Designs a new route while preserving service reuse and HTTP semantics.
Service rules	Implements the happy path.	Handles defaults, whitespace, punctuation validation, and configured length limits.	Explains why validation belongs in reusable service logic for this lesson.
Testing	Can run Maven tests.	Reads unit and controller tests as executable requirements.	Adds a failing test first for a new route or edge case, then implements it.

Course Completion Evidence

Learners are ready to continue independently when they can:

Run demos and exercises without instructor help.
Explain package names, class names, method signatures, and output flow.
Implement each exercise without changing public method signatures.
Compare their implementation to answers and state at least one tradeoff.
Add one small extension in a playground directory and compile it.
Start the Spring Boot lesson locally and verify one HTTP response with curl.