Overview

This is your first graded project! It will count for 10% of your course grade and must be treated like an individual take-home exam. That means you absolutely must not discuss it with or get help from anyone other than the course teaching staff (Joanne + TAs). Even then, we will help you minimally since the goal is for you to show us what you have learned in the prior class exercises and homework assignments by applying the concepts to this somewhat complex problem.

You'll need to apply the following programming skills and concepts to solving this problem: solution design, method writing & calling, variables, operators, decisions statements, loops, proper docuamentation and other style guidelines. Download our posted P1start.zip file to get the file(s) necessary to start this assignment. This includes java skeleton P1start.java (you must rename) with required methods headers, and also an extensive sample run (sampleRun.txt) to further demonstrate how each menu option should work.

Reflection: In addition to the code itself, we want some insights as to how you have approached the problem, your design and thought processes in developing your solution, and particular problems you were or were not able to solve. Therefore, you must submit a short (2-5 min) video recording of yourself explaining your approach and code to us. Please refer to your code specifically as you do this (on screen or on paper). If you do not submit a reflection you will receive a 0 on the entire project. The video submission is due 12 hours after the actual code. (A secondary purpose of the reflection is to make sure you are accountable for the code you submit.)

If you don't have the equipment (cell phone or laptop) to make a brief recording, please let us know immediately so we can help you with this part of the assignment. You can ask a friend to help with the recording, as long as that person is not in this course. Please keep this reflection in mind as you develop your code and make some notes as you proceed so that you remember what to say in the video. The file type should be standard enough for us to view with any common video player.

Deliverables: Your main program solution should be a java program called P1a.java. You must submit your program code (actual project solution) in a zip file called P1-jhedLID.zip, substituting your actual JHED login as the second part of the file name, to P1a on Blackboard. Your video reflection must be a file called P1reflect-jhed and submitted separately to P1b on Blackboard. Ideally you would submit them both by the main deadline, but you will have an extra 12 hours to submit the reflection without penalty -- due by 11:30am on Saturday 10/21.

Submission: Remember that you can submit multiple times on Blackboard; just make sure that your final submission includes all parts! Also remember that your Java code must compile (no syntax errors) or you will receive a 0 grade (seriously). You can check your submission by downloading from MyGrades on Blackboard after submitting and making sure all was included in the zip file, and everything still compiles as submitted. Late submissions will not be accepted, so plan to submit by 11pm even though the deadline is 11:30.

The Problem

For this first project you will write a menu-driven program to encrypt text messages. We will provide you with a sample run (file "run.txt" in the provided zip) to ensure that you understand the overall operation of the program. DISCLAIMER: we will be using very, very simplified encryption techniques that are easy to decode and should never be used in practice! The first two approaches are known as substitution cyphers where we substitute the alphabet letters of a message with different letters. The third encryption scheme is an interval-based scramble of the original message. Name your program P1a.java and remember to make it checkstyle compliant for full credit!

The overall operation of your program will be a menu-driven approach to encrypting various messages based on user input. Throughout your program the encryption choices will be operating on a current message, that can also be changed by the program user. The initial message (before the user gives the program any input) should be "This is the original message." Then the program should repeatedly display the menu, get user input, and execute the requested operation until the user decides to quit. The displayed menu and all input/output must exactly match the format in the provided sample run. Users must be able to choose any of the operations, in any order that they want, as many times as they want, until they decide to quit.

Here are the menu operations:

• Quit the program.
• Display Message: Show the current message to the user, un-encrypted. This message should initially be set to "This is the original message."
• Read Message: Get a new message from the user. Validate the message to make sure that it starts with a capital letter and ends with either a period ('.'), question mark ('?') or exclamation point ('!'). If the input is invalid, reject it with an error message to the user (keep using the prior message instead). Otherwise if valid replace the original message.
• Shift Encrypt: Get user input for integer shift value, validate that it is between -25 and 25 inclusive. If invalid, display an error message. If valid, display the encrypted version of the current message by shifting every letter in the message by the indicated number of positions in the alphabet. A negative shift value means to shift left and a positive shift value means to shift right. When a character gets shifted past the beginning or end of the alphabet, wrap around to the other end to continue. For example, -6 would change all 'e' characters to 'y' (left shift with wrap-around) but a positive 6 would shift any 'e' characters to to 'k'. The shift must be applied to all letters in the message. Do not change any non-alphabet characters in the message, and preserve all capitalization. For example, with a shift value of -6, the original message would be encrypted as "Nbcm cm nby ilcachuf gymmuay."
• Mirror Encrypt: This substitution scheme exchanges letters in the alphabet by essentially folding it in half and flip-flopping corresponding letters. So the first letter becomes the last and vice versa (a's and z's are substitutes for each other). Same for the 2nd and the 2nd-to-last ('b' and 'y'), etc. Do not change any non-alphabet characters in the message, and preserve capitalization. For example, the original message would be encrypted as "Gsrh rh gsv lirtrmzo nvhhztv." with this scheme:

      original:    abcdefghijklmnopqrstuvwxyz
      substitutes: zyxwvutsrqponmlkjihgfedcba 

• Jump Encrypt: prompt the user to enter an integer (jump value) that is between 2 and the square root of the length of the current message, inclusive. Now imagine that we are going to write the current message in a table form, using the same number of rows as the jump value. The character order in the original message would be the order of the first column, followed by the second column, etc. For example, with jump value of 5, the original message would be in table form:

      Tieg a
      hs img
      i onee
      stras.
       hils

  To complete the encryption, display the encrypted message row by row, "Tieg ahs imgi oneestras. hils" for the above. Hint: this can be accomplished in one step with nested loops! No arrays or actual tables are required in the solution, that's just one way to explain the jump intervals. Also note that this encryption will jumble all the characters in the original message, not just the letters. [WARNING: This part is significantly harder than the others - make sure you leave plenty of time for algorithm development and coding.]

Implementation Details & Hints: There are several key features of this program solution that are required and/or will make your development job much easier. Here is a list of requirements and implementation hints:

• You must break this problem down into subroutines rather than writing everything in main. Because writing methods is a new skill, we have provided a complete skeleton for this program in the starter zip file. You must implement the methods we provide without changing their given structure. We will use testing methods that require these specific methods to work as provided. You may add other methods.
• Keep ALL input and output in main. This means that you should not be doing any print, println or printf statements in the other methods, and also must only get user input from the keyboard in main.
• All your methods must be static so that they are stand-alone and self-contained, relying only on the data passed to them to do their job. Remember to use the jGRASP debugger to trace any problems that you are encountering.
• You must not have any "global" variables - those declared outside of a method, with the exception of the provided ALPHA constant (to help with avoiding magic numbers). All others variables must be local to main or another method.
• Write statements in main to test your methods as you go along, rather than just testing them with the overall program operation. Remember that you must comment out these tests when they are no longer needed, rather than leaving them in your final solution.
• It is really important to develop this program incrementally! We are giving you a starter program (file "P1start.java" in the provided zip) that has the structure for a main method, and also for the other expected methods. Build your program from the bottom up: Have your main method display the menu and read the user's choices. For each choice, just display a brief message so that you can see that the menu works. Make sure the quit option works and that users can select various options in any order. Next, add the necessary variables for processing, including the initial value for the current message.
• One at a time, implement the various menu operations, testing each with the initial message to be sure they work correctly. Then test them with other inputs, using the menu operation to get new messages.
• You do not need and must not use arrays (or ArrayLists) in any form to solve this problem.

Grading

The 60 total points for this assignment will be broken down into expected functionality (how well the code works), how well the code is written, including style and documentation, and the video reflection. You are not required to submit pseudocode or extra tests for any parts of this project, but you are strongly encouraged to write them as part of the solution process.

• [45] Program functionality:
  • [5] Overall main processing of menu and user input.
  • [5] Current message initialized and used properly; display operation working.
  • [5] Input and validate new message.
  • [10] Shift Encrypt
  • [8] Mirror Encrypt
  • [12] Jump Encrypt
• [15] Program style and adherence to specifications:
  • [3] Good use of subroutines - implementing and calling those provided in the skelton appropriately.
  • [2] Meaningful variable names, use of in-line comments for documentation, meaningful javadoc comments, no global variables, conforms to expected input and output format, etc.
  • [4] Is fully checkstyle compliant, using our checks107.xml configuration file. -1 point for each type of violation (regardless of number of occurrences), up to 4 points total.
  • [1] Submission is zipped, named and submitted in two parts correctly.
  • [5] Video reflection addresses overall approach, design, implementation choices, actual code and any problems encountered. Remember that your entire project will get a 0 grade if you don't submit a video reflection.

Deadline & Time Management: We strongly recommend completing this project (along with the video reflection) by Monday 10/16. This is your best preparation for the midterm on Wednesday 10/18 and avoids having to finish the project on Fall Break Day (10/20). We will probably have reduced office hours over fall break (10/20-10/22), so plan to get help before then! Also remember to account for any travel plans you may have when planning your work schedule. Minimally you should start all aspects of the assignment by Monday 10/16.