Overall

This project, developed in two phases (A1 and A3), demonstrates the full lifecycle of building and evolving a maze-solving system.

• Foundation (A1): Built the initial program to explore mazes stored in text format, using the “right-hand rule” heuristic. Delivered an MVP with proper engineering practices—Git version control, Maven build, logging, and Kanban tracking. Supported path validation and both canonical (raw moves) and factorized (compressed) path representations.
• Evolution (A3): Refactored the system into a modular, object-oriented design guided by SOLID principles. Introduced graph-based algorithms (e.g., BFS/DFS) to find optimized paths and added benchmarking to compare performance against the heuristic approach. Unit testing and release management improved reliability and maintainability

Learning Outcomes

• Software Engineering Practices: Git workflow, Maven build automation, Kanban project tracking, release tagging.
• Code Quality: Applied SOLID principles, object-oriented design, and module interface specifications for extensibility.
• Algorithmic Thinking: Progressed from heuristic navigation to formal graph algorithms for optimal solutions.
• Performance Engineering: Benchmarked algorithms, interpreted speedup metrics, and considered micro-benchmarking with JMH.

Example of Maze and Path that breaks Maze

It use a algorithm called left hand rules which is: if you keep turn right at every dead end and crossroads, you will finally get out. It might not be the best solution but it works.

Applied Skill

Java

Key Features & Deliverables

• Maze Representation & Path Encoding: Mazes stored in text format (# for walls, spaces for passages), with paths expressed as sequences of moves (F = forward, L = left, R = right). Both canonical (raw sequence) and factorized (compressed instructions, e.g., 3F) forms were supported.
• Incremental Development: Introduced a walking skeleton, identified abstractions, and used a Kanban board for iterative delivery. Each milestone (MVP, new features, refactoring) was tagged and version-controlled on GitHub.
• Algorithm Polymorphism: Designed the system to allow multiple exploration strategies (e.g., right-hand, Trémaux’s method, graph-based search) through a unified interface.
• Refactoring & Maintainability: Audited and improved the original code, applying modular design and clear class abstractions to ensure extensibility.
• Benchmarking & Optimization: Implemented benchmark mode to compare exploration methods, measuring path length, runtime, and speedup. Demonstrated clear efficiency gains from moving to graph-based algorithms (e.g., Trémaux’s path vs. right-hand rule).
• Testing & Reliability: Wrote unit tests to validate path correctness and algorithm reliability, emphasizing code confidence over exhaustive testing.

Key Outcome

• Applied professional software engineering practices.
• Progressed from heuristic navigation to formal graph algorithms.
• Demonstrated measurable performance improvements.
• Built an extensible framework supporting multiple exploration strategies.

Together, A1 and A3 highlight the transition from a minimal viable solution to an optimized, maintainable software product.

So I use BFS algorithm to optimize the speed of breaking maze:

BFS Algorithm path

Right-hand Algorithm Path

Kanban Board

Github Link:

https://github.com/2AA4-W24/a3-maze-runner-take-two-maruko33

Project Documentation

a1-mak33.pdf