• The code we write is designed for a specific language.
• But algorithms are portable.
• What does this mean?
• An algorithm represents the way we solve a problem rather than the code itself.
• This is why we can design algorithms in flowcharts and pseudocode.
• In this unit, you'll re-engineer one of your algorithms in a second language.

• This is the summative assessment for the CSE2140: Second Language 1 module.

How it Works:

• The project outline can be found in the Free Learning Unit (this page) and the Project Rubric.
• This project is broken down into 3 steps:
• Build: Code your elevator system using your existing algorithm.
• Test: Test and refine your system.
• Reflect: Compare this system to your elevator written in C#.

Assessment:

• You'll receive a 1-7 grade and comment for each step in the project.
• From those grades, you'll receive an overall 1-7 grade for this project.
• These grades and feedback will be shared via the project rubric.
• The overall grade will be entered into the Gibbon markbook.
• Be sure to read the Project Rubric so you're familiar with how this project will be graded.

• Consider the flowchart you created for your Elevator Challenge.
• You created this algorithm to meet a set of requirements for 4 user stories.
• If algorithms truly are portable, then it should be possible to create a new elevator system in a different language, right?

• Your goal is to re-engineer this algorithm in JavaScript.
• To do this, you'll use the p5.js editor
• This editor gives you access to the processing library and an interface to write your code:
  
  
• Open up the p5js editor to familiarize yourself with how it works.
• Be sure to check out the p5js reference.
• There is also a great JavaScript reference on W3Schools.

• You'll note that p5js is a 2D drawing library and Unity is a 3D engine.
• This means your new system is not going to look exactly the same as your old one.
• You need to adapt how you implement your algorithm to this new environment.
• However, the logic you designed in your algorithm should remain the same.
• The sources of input should be the same (a button press?)
• The processing steps are the same, although the functions and variables may differ.
• The different types of output should remain the same.
• This is a great demonstration of how the implementation of two systems can be different, but they can share the same underlying algorithm.

• Look back at the User Stories described in the Elevator Challenge.
• Ask yourself: Would this user accept my elevator algorithm as a solution to their problem?
• User Story 1: Does my system manage at least two elevator shafts?
• User Story 2: Can my users see which floor the elevator is on?
• User Story 3: Do my elevators allow users to go up or down?
• User Story 4: Will my system stop and pick up passengers along the way?

• Be sure to test your code with these user stories in mind.
• Also aim to eliminate any syntax or runtime errors in your code.
• Once you're happy with your elevator system, move onto the next step.

• You've now built and tested two different elevator systems using the same algorithm:
• One system created in Unity 3D using C#.
• One system created in p5js using JavaScript.
• Consider:
• How are these implementations the same?
• How are they different? And, in which ways did the two languages differ?
• What characteristics of these languages made writing your code easier, or harder?
• Was there one language that seemed better suited to this task? Why?
• Your goal is to write a one paragraph reflection on your experience re-engineering your algorithm.
• The above questions can serve as a prompt to get you started.
• Feel free to reflect on any aspects of the project that stood out to you.