Code Playground
Learning to think in systems, one small program at a time.
I learned Java through a structured 10-week course (using Java Software Solutions, 9th Ed.) and completed weekly labs, mid-size OOP assignments, and two major projects. These exercises helped me understand how programs think: how data flows, how objects interact, and how to structure software in a clean, modular way.
- Role
- Beginner Java programmer, course-based learning
- Timeline
- 3 months
- Contribution
- Weekly labs, OOP assignments, two major projects
What I learned
Four building blocks, practiced week over week
Click a card to see what each block covered.
-
- Writing and running Java programs.
- Variables, operators, expressions.
- Using Scanner for user input.
- Printing structured output.
-
- if/else decision-making.
- Multi-branch logic (grading systems, validation).
- Loops (for, while, do-while).
- Pattern and sequence generation.
-
- Creating and managing collections.
- Searching, filtering, summation.
- Using ArrayLists in real programs (E-Book tracker, Jobs lists).
-
- Classes, objects, constructors.
- Encapsulation & access modifiers.
- Inheritance (superclass → subclass design).
- Polymorphism & method overriding.
- UML class diagramming.
Demonstrated in my projects
- Instrument Hierarchy (Drum, Piano, Guitar, Flute)
- Flower System (Final Exam), dynamic method binding
- E-Book Tracker, array-based data management
- Job Board System, full multi-class application
Weekly labs (10 weeks)
- Week 1–2: Variables, expressions, user input.
- Week 3: Conditionals.
- Week 4–5: Loops & pattern generation.
- Week 6: Methods and modular thinking.
- Week 7–8: Arrays & ArrayLists (book examples, lab exercises).
- Week 9–10: Classes, objects, inheritance, UML + multi-class design.
Highlight projects
A multi-class OOP system modeling real-world job listings.
- Abstract superclass
Jobwith shared attributes. - Subclasses:
FullTimeJob,InternshipJob. - Additional class:
Location. - Salary calculations, job comparisons, filtering.
- User interaction via console menu.
- UML diagram defining relationships.
Skills demonstrated: inheritance, abstraction, encapsulation, UML modeling, system architecture.
A clean example of polymorphism in action.
- Superclass:
Instrument. - Subclasses:
Guitar,Drum,Flute,Piano. - Overridden
playSound()in each class. - Central tester (
MusicTester.java) to trigger behavior.
Skills demonstrated: overriding, constructors, polymorphism, multi-class structure.
A small console system storing and retrieving e-books.
- Add, remove, search books.
- Array-based storage.
- Input validation + utility methods.
Skills demonstrated: arrays, methods, searching/filtering.
A set of classes, Flower, Lily, Rose, tested via a driver.
Skills demonstrated: inheritance, method overriding, object arrays, driver testing.
A console program that calculates System Usability Scale scores.
Skills demonstrated: user input, arithmetic logic, printing results.
A tiny demo of the same idea: a state machine
One of the ideas that stuck with me from these exercises is how much of programming is just managing state, where something is, and what's allowed to happen next. Here's a minimal version of that: three states, one transition rule, nothing else. Press the button to advance it.
Traffic light state machine
A small interactive demo, not a screenshot. Advances one state at a time, logs each transition below.
Under the hood, this is the same idea as the console exercises: a fixed set of states, one rule for what comes next, and a log of what happened, just with a visual layer on top instead of a terminal print.
What I learned
Reflected- As a UX researcher learning Java. Coding taught me the "system's perspective," how constraints, logic, and state transitions can shape UX.
- As a psychology + HCI student. Writing code helped me understand mental models, error recovery, and cognitive load from a developer's viewpoint.
- As a beginner programmer. Debugging sharpened my problem-solving mindset, and building class systems showed me how software mirrors real-world structure. Week by week, I learned to break complex problems into simple, manageable steps, a skill that now strengthens both my technical and UX thinking.