Programming 2: Final Portfolio and Reflection

Lesson Overview

Assemble three stronger artefacts with evidence of requirements, design, implementation, testing, teamwork and reflection.

Portfolio focus: Audit the portfolio for missing evidence.

ConceptPortfolio synthesis

Run fileFinalPortfolioAndReflectionDemo.java

BaselinePortfolio includes: requirements Portfolio includes: design Portfolio includes: code Portfolio includes: tests Portfolio includes: reflection

Evidence3 tasks

Starter: think before typing

Before running this portfolio synthesis example, find the line where the main idea becomes active. Write a prediction: what must already be true for that line to work, and what should be different after it runs? The checked run ends with `Portfolio includes: requirements Portfolio includes: design Portfolio includes: code Portfolio includes: tests Portfolio includes: reflection`; predict how the focus line helps produce that evidence.

Learning Objectives

Select evidence that demonstrates growth.
Write reflections that explain decisions rather than narrating tasks.
Link artefacts to software lifecycle stages.
Prepare a clean portfolio for assessment-style review.

Learning Outcomes

By the end of the lesson, you can select evidence that demonstrates growth.
By the end of the lesson, you can write reflections that explain decisions rather than narrating tasks.
By the end of the lesson, you can link artefacts to software lifecycle stages.
By the end of the lesson, you can prepare a clean portfolio for assessment-style review.

Why this idea exists

A final portfolio is a curated argument about your development as a programmer. It should not be a dump of every file; it should show carefully selected evidence of capability and growth.

Reflection became important in professional and academic computing because technical skill alone does not prove judgement. Programmers need to explain why choices were made and how feedback changed the work.

A top-quality portfolio connects artefacts to concepts: lifecycle, abstraction, testing, collaboration, ethics, maintainability and future improvement. It shows not only what you built, but how your thinking matured.

Deep dive

Mechanism in this example

The important mechanism is visible around `String[] evidence = {"requirements", "design", "code", "tests", "reflection"};`. Read it as a concrete move in the program, not as decorative syntax: identify what value, object, branch, call or boundary is being created at that point.

Design pressure

Failure mode to watch

For Final Portfolio and Reflection, deliberately disturb the assumption behind `String[] evidence = {"requirements", "design", "code", "tests", "reflection"};`: use an awkward value, missing input, wrong order of calls or boundary case. The useful question is how that disturbance exposes a weakness in the portfolio synthesis design.

Extension step

Extend the example by doing this: Write one reflective paragraph per artefact. The point is to make one small change that forces you to revisit the concept, rather than adding unrelated features.

Portfolio standard

The portfolio note should not repeat the lesson wording. It should show the edited code, the run result, and your own explanation of this evidence: create a final skills map across the module.

Lesson visual

Photo-real final portfolio desk with three artefact folders, code screenshots, test evidence, team notes and reflection pages.Download visual

Type this and run it

Create FinalPortfolioAndReflectionDemo.java, type the program, and run it before changing anything. This section is about reproducing the checked baseline.

public class FinalPortfolioAndReflectionDemo {
  public static void main(String[] args) {
    String[] evidence = {"requirements", "design", "code", "tests", "reflection"};
    for (String item : evidence) {
      System.out.println("Portfolio includes: " + item);
    }
  }
}

Build and run it with:

javac FinalPortfolioAndReflectionDemo.java && java FinalPortfolioAndReflectionDemo

Expected baseline: Portfolio includes: requirements Portfolio includes: design Portfolio includes: code Portfolio includes: tests Portfolio includes: reflection

Run the code in your browser

Use the editor as an experiment surface. First run the checked version, then make one small change to the part of the program that demonstrates portfolio synthesis and compare the new behaviour with the reference output.

Editable Java code

public class FinalPortfolioAndReflectionDemo {
  public static void main(String[] args) {
    String[] evidence = {"requirements", "design", "code", "tests", "reflection"};
    for (String item : evidence) {
      System.out.println("Portfolio includes: " + item);
    }
  }
}

Portfolio includes: requirements
Portfolio includes: design
Portfolio includes: code
Portfolio includes: tests
Portfolio includes: reflection

Line-by-line explanation

Read the code as a sequence of responsibilities. The focus line for this lesson is String[] evidence = {"requirements", "design", "code", "tests", "reflection"};; the surrounding lines prepare it, use its result or make the behaviour observable.

public class FinalPortfolioAndReflectionDemo {

This names the runnable class for the Final Portfolio and Reflection example, giving the compiler and JVM one clear unit to build.

public static void main(String[] args) {

This is the program entry point. In Final Portfolio and Reflection, it keeps the demonstration of portfolio synthesis in one traceable starting script.

String[] evidence = {"requirements", "design", "code", "tests", "reflection"};

This introduces evidence as named state for Final Portfolio and Reflection. Later lines can read, update, pass or print that specific value as evidence.

for (String item : evidence) {

This starts repetition in Final Portfolio and Reflection. Check the initial value, the stopping condition and the update on each pass.

System.out.println("Portfolio includes: " + item);

This prints "Portfolio includes: " + item as the observable evidence for Final Portfolio and Reflection. The output lets the learner check whether the portfolio synthesis idea behaved as predicted.

}

This closes the innermost Final Portfolio and Reflection block, so the immediately preceding method, branch or loop has finished.

}

This closes the outer Final Portfolio and Reflection structure, returning the reader to the surrounding class or file.

}

This closing brace number 3 completes another layer of the Final Portfolio and Reflection source structure Java has been checking.

Worked example

From code to explanation

Problem: Use Final Portfolio and Reflection to complete a small portfolio-quality step: Audit the portfolio for missing evidence.

Method: Locate the line `String[] evidence = {"requirements", "design", "code", "tests", "reflection"};`, explain the exact role it plays, then decide what you would change to extend the example without changing the whole program.

Reveal worked answer

The checked run should produce `Portfolio includes: requirements Portfolio includes: design Portfolio includes: code Portfolio includes: tests Portfolio includes: reflection`. A strong answer links the result back to portfolio synthesis: what was created, selected, stored, called or protected, and why that matters for the portfolio task.

Trace the program

Before: Before the key operation, identify the relevant value, object, branch or resource that the portfolio synthesis concept depends on.

During: Trace `String[] evidence = {"requirements", "design", "code", "tests", "reflection"};` as the Final Portfolio and Reflection example executes. Say whether that operation creates data, checks a condition, calls behaviour, stores information or crosses a boundary.

After: Compare the run with the expected evidence: `Portfolio includes: requirements Portfolio includes: design Portfolio includes: code Portfolio includes: tests Portfolio includes: reflection`.

Change: Now write one reflective paragraph per artefact, run again, and explain the smallest reason the behaviour changed.

Common misconception

A common mistake in final portfolio and reflection is treating the example as a finished answer. For portfolio synthesis, the important question is narrower: which operation carries the idea, what does it make possible, and what would break if you changed it carelessly?

Quick checks

1. In this Final Portfolio and Reflection example, what is the best reason to focus on `String[] evidence = {"requirements", "design", "code", "tests", "reflection"};`?

It is the only line where punctuation matters.It can be ignored as long as the final page looks correct.It is where the code demonstrates portfolio synthesis in a concrete way.

2. Which evidence is strongest after you edit and rerun this example?

Only a screenshot of the page after pressing Run.The edited code, the run result `Portfolio includes: requirements Portfolio includes: design Portfolio includes: code Portfolio includes: tests Portfolio includes: reflection` or changed output, and a short explanation of the decision.Only the final answer, with failed attempts removed.

How to study this lesson

For Final Portfolio and Reflection, predict how portfolio synthesis changes the run before you press Run.

Use the first portfolio task as your main edit: Audit the portfolio for missing evidence.

Use the second task as your variation: Write one reflective paragraph per artefact.

Finish with evidence, not a diary entry: Create a final skills map across the module.

Portfolio Practice

Audit the portfolio for missing evidence.
Write one reflective paragraph per artefact.
Create a final skills map across the module.

Final self-check

Can you explain the key operation?

Explain the line identified in the quick check in one or two sentences. Your answer should say what it does before the output Portfolio includes: requirements Portfolio includes: design Portfolio includes: code Portfolio includes: tests Portfolio includes: reflection appears.

Can you justify the portfolio evidence?

Your evidence should include the original run, one edited run, and a short note explaining how the edit affected portfolio synthesis.

Study route

Practise portfolio synthesis by predicting the Java example, typing it, running it in the browser, tracing the result and saving portfolio evidence.

This is the final lesson in the route, so use it to audit the whole portfolio for runnable examples, test evidence and honest reflection.