Elevator Simulation

Author(s): Henry Yost (henry-AY)

This repo is a re-upload

In this Elevator Simulation project, as a group, we simulated the performance of various elevators currently being proposed for a new 6-story building. The simulation provided data that was analyzed and then used to make a recommendation to the lead architect. This is a time-driven and event-driven simulation. The elevator functionality was modeled using a finite state machine (FSM), and passengers arrived at specified times with intended destinations – just like they would in a real building.

Approaching the Elevator Project with a Design Doc:

To complete the project successfully, we decided to create and fully flush out a design document to communicate necessary variables, methods, getters, and setters. Furthermore, each class was a separate document, with each method header written out with an executive-level summary of the function. This process was done to ensure each member working on their designated files would not need to access other files, to ensure there were no issues when merging into the main branch.

In depth-look at the Elevator Project GUI:

GUI Mockup (Version 1 → Final Version)

First GUI Mockup (Week 1 of the project)

Final Design of GUI

• Arrows represent the direction of the Elevator
• The blue box represents the elevator itself, and the number represents the # of passengers
• Toggleable buttons added to the bottom

High-Level class UML Layout:

Comprehensive JUnit Testing:

One of the numerous test cases for passing the JUnit. The one below is the Move 1 Floor Test (Mv1FlrTest.csv)

Final Elevator Simulation:

Fully interactive, user-friendly, GUI, that correctly shows the Elevator Simulation.

Added toggleable logging option, printing out detailed statistics every time an action occurs.

All 3 Elevator Config simulations fully passed (Used to recommend the best elevator to the architect).

Elevator Recommendation to Lead Architect:

Elevator Simulation Reflections:

4 Weekly Reflections: 1 Final Reflection

Week 1 Reflection

I completed the first pass goals. As a team, we finished the (as of now) complete design doc implementation and added the necessary methods to the second version. An obstacle we still face as a team is having derailing conversations about trivial topics, lack of team management, and lack of communication between all the members.

Week 2 Reflection

During the second week of the project, our group finished implementing multiple methods throughout the primary functionality classes. Furthermore, we planned pseudocode for methods we plan to implement within the next week. Moreover, we polished our design doc as beforehand it was unfinished and in a rough state. Our goal for the rest of the week is basic functionality.

Week 3 Reflection

Within the last week, the team management has suffered, therefore, I plan on stepping up to the role of leadership and pushing the deadlines that we are currently a week behind in. Our goal this week until the end of the project is to complete the project in multiple stages. The first stage is successfully being able to compile the code, passing the JUnits, and then implementing the GUI.

Week 4 Reflection

This week's productivity was significantly better compared to the last 3 weeks of the project. However, we are currently not able to debug the code, because the individual programming the main interface between all the classes is behind, therefore we need to step up and support him. This will hopefully enable us to debug, rewrite, and perform the necessary analysis by the deadline.

Final Reflection

Prompts:

1. What did you learn about programming collaboratively during this project?

What I learned about programming in a collaborative environment is that it is a lot more challenging than what I initially thought. I prefer 'challenging' over 'difficult', because it is not difficult, rather you run into challenges regarding communication, merging, bugs, and discussions.

2. What did you learn about yourself (from a programming perspective) during this project?

What I learned about myself from a programming perspective is that I am capable of writing, reading, and most importantly understanding significantly more complex code than I thought I was able to.

3. What worked well and what would you do differently on your next major assignment?

What worked really well with this project was understanding the project at a high-level, and getting the project done at the deadline. What I would do differently on my next major assignment, is team managment. Team management is crucial to the structure and success of an overall project.